diff --git a/CMakeLists.txt b/CMakeLists.txt index 16860245..3243a7d7 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -7,7 +7,6 @@ project("RedScarfEngine" set(CMAKE_C_STANDARD 23) set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH}) -set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Werror") add_subdirectory(red_scarf_engine) add_subdirectory(utilities) diff --git a/cmake/FindCmock.cmake b/cmake/FindCmock.cmake new file mode 100644 index 00000000..8638491e --- /dev/null +++ b/cmake/FindCmock.cmake @@ -0,0 +1,17 @@ +set(CMOCK_DIR "${PROJECT_SOURCE_DIR}/third_party/cmock/") + + +find_library( + cmock + NAMES cmock + HINTS ${CMOCK_DIR}/build/src/ +) + +find_library( + unity + NAMES unity + HINTS ${CMOCK_DIR}/build/vendor/unity/src/ +) + +set(cmock_INCLUDE_DIR "${CMOCK_DIR}/src/") +set(unity_INCLUDE_DIR "${CMOCK_DIR}/vendor/unity/src/") \ No newline at end of file diff --git a/dependencies.dep b/dependencies.dep index 54235702..8dd07816 100644 --- a/dependencies.dep +++ b/dependencies.dep @@ -23,3 +23,7 @@ tag = master [FreeType] dl_url = https://download.savannah.gnu.org/releases/freetype/freetype-2.10.0.tar.gz custom_commands = tar -xf FreeType && mv freetype-2.10.0 freetype && rm FreeType && cd freetype && cmake -E make_directory build && cmake -E chdir build cmake -D BUILD_SHARED_LIBS:BOOL=true .. && cmake --build build + +[CMock] +git_url = https://github.com/throwtheswitch/cmock.git +custom_commands = cd cmock && bundle install \ No newline at end of file diff --git a/graphics/CMakeLists.txt b/graphics/CMakeLists.txt index 840b33e2..f57a1d9d 100644 --- a/graphics/CMakeLists.txt +++ b/graphics/CMakeLists.txt @@ -7,6 +7,8 @@ find_package(FreeType REQUIRED) find_package(Vulkan COMPONENTS glslc) find_program(glslc_executable NAMES glslc HINTS ${Vulkan_GLSLC_EXECUTABLE}/..) +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Werror") + file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/shaders) cmake_policy(SET CMP0116 NEW) @@ -35,7 +37,11 @@ shaders/solid_objects.frag shaders/on_screen_text.frag ) -add_library(rse_graphics SHARED shaders/shader.vert.num shaders/shader.frag.num) +add_library(rse_graphics SHARED + shaders/shader.vert.num + shaders/solid_objects.frag.num + shaders/on_screen_text.frag.num + ) target_include_directories(rse_graphics PRIVATE ${PROJECT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR} diff --git a/graphics/shaders/solid_objects.frag b/graphics/shaders/solid_objects.frag index 4389dbb4..8f891f5d 100644 --- a/graphics/shaders/solid_objects.frag +++ b/graphics/shaders/solid_objects.frag @@ -14,5 +14,5 @@ layout(location = 0) out vec4 outColor; void main() { vec4 texturePixels = texture(texSampler[instanceTextureId], fragTexCoord); - outColor = vec4(fragColor * texturePixels, texturePixels.a); + outColor = vec4(fragColor * texturePixels.rgb, texturePixels.a); } diff --git a/graphics/src/vulkan_buffers.c b/graphics/src/vulkan_buffers.c index 7a3df4cc..6719acd4 100644 --- a/graphics/src/vulkan_buffers.c +++ b/graphics/src/vulkan_buffers.c @@ -1,6 +1,7 @@ #include "vulkan_buffers.h" #include "src/vulkan_commons.h" +#include "utilities/rse_commons.h" #include "vulkan_errors.h" #include "locale_vulkan.h" #include "utilities/logger.h" @@ -212,7 +213,7 @@ void update_uniform_buffers() g_vulkan_state.swapchain_extent.width / (float)g_vulkan_state.swapchain_extent.height, z_near, z_far); - memcpy(g_vulkan_state.uniform_buffers[g_vulkan_state.current_frame].allocation_info.pMappedData, &ubo, sizeof(ubo)); + rse_memcpy(g_vulkan_state.uniform_buffers[g_vulkan_state.current_frame].allocation_info.pMappedData, &ubo, sizeof(ubo)); } rse_err_t rse_add_vertices(uint16_t mesh_id, @@ -239,7 +240,7 @@ rse_err_t rse_add_vertices(uint16_t mesh_id, /* Fill staging buffer with vertex data */ memset(staging_buffer.allocation_info.pMappedData, 0, MAX_VERTEX_BUFFER_SIZE); - memcpy(staging_buffer.allocation_info.pMappedData, vertices, vertices_size); + rse_memcpy(staging_buffer.allocation_info.pMappedData, vertices, vertices_size); copy_buffer(staging_buffer.buffer, g_vertex_buffer.buffer, vertices_size, @@ -251,7 +252,7 @@ rse_err_t rse_add_vertices(uint16_t mesh_id, /* Fill staging buffer with index data */ memset(staging_buffer.allocation_info.pMappedData, 0, indices_size); - memcpy(staging_buffer.allocation_info.pMappedData, indices, indices_size); + rse_memcpy(staging_buffer.allocation_info.pMappedData, indices, indices_size); copy_buffer(staging_buffer.buffer, index_buffer->buffer, indices_size, @@ -267,7 +268,7 @@ rse_err_t rse_add_vertices(uint16_t mesh_id, draw_indirect_command.vertexOffset = vertex_data->buffer_offset; draw_indirect_command.firstInstance = 0; - memcpy(g_draw_indirect_command_buffer.allocation_info.pMappedData + (mesh_id * sizeof(VkDrawIndexedIndirectCommand)), &draw_indirect_command, sizeof(VkDrawIndexedIndirectCommand)); + rse_memcpy(g_draw_indirect_command_buffer.allocation_info.pMappedData + (mesh_id * sizeof(VkDrawIndexedIndirectCommand)), &draw_indirect_command, sizeof(VkDrawIndexedIndirectCommand)); return RSE_ERROR_NO_ERROR; } @@ -289,7 +290,7 @@ rse_err_t update_mesh_instances(uint16_t mesh_id, struct rse_instance_data_t* in &staging_buffer)); /* Copy transformation information about instance */ - memcpy(staging_buffer.allocation_info.pMappedData, instance_data, instance_size); + rse_memcpy(staging_buffer.allocation_info.pMappedData, instance_data, instance_size); copy_buffer(staging_buffer.buffer, instance_buffer->buffer, instance_size, @@ -299,9 +300,9 @@ rse_err_t update_mesh_instances(uint16_t mesh_id, struct rse_instance_data_t* in instance_buffer->allocated_size += instance_size; - memcpy(&draw_indirect_command, g_draw_indirect_command_buffer.allocation_info.pMappedData + (mesh_id * sizeof(VkDrawIndexedIndirectCommand)), sizeof(VkDrawIndexedIndirectCommand)); + rse_memcpy(&draw_indirect_command, g_draw_indirect_command_buffer.allocation_info.pMappedData + (mesh_id * sizeof(VkDrawIndexedIndirectCommand)), sizeof(VkDrawIndexedIndirectCommand)); draw_indirect_command.instanceCount++; - memcpy(g_draw_indirect_command_buffer.allocation_info.pMappedData + (mesh_id * sizeof(VkDrawIndexedIndirectCommand)), &draw_indirect_command, sizeof(VkDrawIndexedIndirectCommand)); + rse_memcpy(g_draw_indirect_command_buffer.allocation_info.pMappedData + (mesh_id * sizeof(VkDrawIndexedIndirectCommand)), &draw_indirect_command, sizeof(VkDrawIndexedIndirectCommand)); return RSE_ERROR_NO_ERROR; } diff --git a/graphics/src/vulkan_pipeline.c b/graphics/src/vulkan_pipeline.c index bf360667..a38e2e79 100644 --- a/graphics/src/vulkan_pipeline.c +++ b/graphics/src/vulkan_pipeline.c @@ -5,6 +5,7 @@ #include "src/window.h" #include "utilities/file_utils.h" #include "utilities/logger.h" +#include "utilities/rse_commons.h" #include "utilities/rse_errors_common.h" #include "vulkan/vulkan_core.h" #include "vulkan_errors.h" @@ -16,7 +17,7 @@ #include #include -#define SHADER_MODULES_COUNT 3U +#define SHADER_MODULES_COUNT 2U enum shader_stage_t { @@ -146,7 +147,7 @@ static rse_err_t create_swapchain() /* Obtain swapchain images */ vkGetSwapchainImagesKHR(g_vulkan_state.device, g_vulkan_state.swapchain, &g_swapchain_images_count, NULL); - g_swapchain_images = (VkImage*)malloc(sizeof(VkImage) * g_swapchain_images_count); + rse_malloc(g_swapchain_images, sizeof(VkImage) * g_swapchain_images_count); vkGetSwapchainImagesKHR(g_vulkan_state.device, g_vulkan_state.swapchain, &g_swapchain_images_count, g_swapchain_images); return RSE_ERROR_NO_ERROR; @@ -159,7 +160,7 @@ static rse_err_t create_swapchain() */ static rse_err_t create_swapchain_image_views() { - g_vulkan_state.swapchain_image_views = malloc(sizeof(VkImageView) * g_swapchain_images_count); + rse_malloc(g_vulkan_state.swapchain_image_views, sizeof(VkImageView) * g_swapchain_images_count); for (size_t i = 0; i < g_swapchain_images_count; i++) { VkImageViewCreateInfo create_info; @@ -381,18 +382,18 @@ static rse_err_t fill_shader_stages(VkPipelineShaderStageCreateInfo* shader_stag VkPipelineShaderStageCreateInfo frag_shader_stage_info = {}; rse_read_file(g_shader_paths[VERTEX], &buffer_size, NULL); - buffer = malloc(buffer_size); + rse_malloc(buffer, buffer_size); rse_read_file(g_shader_paths[VERTEX], &buffer_size, buffer); STATUS_CHECK(create_shader_module(buffer, buffer_size, &vertex_shader_module)); - free(buffer); + rse_free(buffer); rse_read_file(g_shader_paths[FRAGMENTS], &buffer_size, NULL); - buffer = malloc(buffer_size); + rse_malloc(buffer, buffer_size); rse_read_file(g_shader_paths[FRAGMENTS], &buffer_size, buffer); STATUS_CHECK(create_shader_module(buffer, buffer_size, &fragments_shader_module)); - free(buffer); + rse_free(buffer); /* Vertex Shader Pipeline Stage */ vert_shader_stage_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; @@ -415,8 +416,8 @@ static rse_err_t fill_shader_stages(VkPipelineShaderStageCreateInfo* shader_stag shader_stages[VERTEX] = vert_shader_stage_info; shader_stages[FRAGMENTS] = frag_shader_stage_info; - memcpy(&g_shader_modules[0], &vertex_shader_module, sizeof(VkShaderModule)); - memcpy(&g_shader_modules[1], &fragments_shader_module, sizeof(VkShaderModule)); + rse_memcpy(&g_shader_modules[0], &vertex_shader_module, sizeof(VkShaderModule)); + rse_memcpy(&g_shader_modules[1], &fragments_shader_module, sizeof(VkShaderModule)); return RSE_ERROR_NO_ERROR; } @@ -434,7 +435,7 @@ static void fill_dynamic_pipeline_state_info(VkPipelineDynamicStateCreateInfo* d * pipeline create structures. I'll list ignored members of structs, that will be ignored due to the * settings and also functions, that will need to be called to set specific state. */ - dynamic_states = malloc(sizeof(VkDynamicState) * 2); + rse_malloc(dynamic_states, sizeof(VkDynamicState) * 2); dynamic_states[0] = VK_DYNAMIC_STATE_VIEWPORT; /* VkPipelineViewportStateCreateInfo:pViewport; vkCmdSetViewport() */ dynamic_states[1] = VK_DYNAMIC_STATE_SCISSOR; /* VkPipelineViewportStateCreateInfo:pScissors; vkCmdSetScissors() */ @@ -456,7 +457,7 @@ static void fill_dynamic_pipeline_state_info(VkPipelineDynamicStateCreateInfo* d */ static void free_dynamic_pipeline_state_info(VkPipelineDynamicStateCreateInfo* dynamic_state) { - free((VkDynamicState*)dynamic_state->pDynamicStates); + rse_free((VkDynamicState*)dynamic_state->pDynamicStates); } /** @@ -468,14 +469,15 @@ static void fill_vertex_input_info(VkPipelineVertexInputStateCreateInfo* vertex_ { const size_t binding_descriptions_count = 2; const size_t attribute_descriptions_count = 7; - /* This is clusterfuck with some magic numbers here and there and unneeded malloc and memcpy stuff. Change, + /* TODO: This is clusterfuck with some magic numbers here and there and unneeded malloc and memcpy stuff. Change, * so you won't feel ashamed. */ VkVertexInputBindingDescription vertex_binding_description = get_binding_description(); VkVertexInputAttributeDescription* vertex_attribute_descriptions = get_attribute_descriptions(); - VkVertexInputBindingDescription* binding_descriptions = malloc(sizeof(VkVertexInputBindingDescription) - * binding_descriptions_count); - VkVertexInputAttributeDescription* attribute_descriptions = malloc(sizeof(VkVertexInputAttributeDescription) - * attribute_descriptions_count); + VkVertexInputBindingDescription* binding_descriptions = NULL; + VkVertexInputAttributeDescription* attribute_descriptions = NULL; + + rse_malloc(binding_descriptions, sizeof(VkVertexInputBindingDescription) * binding_descriptions_count); + rse_malloc(attribute_descriptions, sizeof(VkVertexInputAttributeDescription) * attribute_descriptions_count); binding_descriptions[0] = vertex_binding_description; @@ -483,7 +485,7 @@ static void fill_vertex_input_info(VkPipelineVertexInputStateCreateInfo* vertex_ binding_descriptions[1].stride = sizeof(struct rse_instance_data_t); binding_descriptions[1].inputRate = VK_VERTEX_INPUT_RATE_INSTANCE; - memcpy(attribute_descriptions, vertex_attribute_descriptions, sizeof(VkVertexInputAttributeDescription) * 3); + rse_memcpy(attribute_descriptions, vertex_attribute_descriptions, sizeof(VkVertexInputAttributeDescription) * 3); attribute_descriptions[3].binding = 1; attribute_descriptions[3].location = 3; @@ -523,8 +525,8 @@ static void fill_vertex_input_info(VkPipelineVertexInputStateCreateInfo* vertex_ */ static void free_vertex_input_info(VkPipelineVertexInputStateCreateInfo* vertex_input_info) { - free((VkVertexInputBindingDescription*)vertex_input_info->pVertexBindingDescriptions); - free((VkVertexInputAttributeDescription*)vertex_input_info->pVertexAttributeDescriptions); + rse_free((VkVertexInputBindingDescription*)vertex_input_info->pVertexBindingDescriptions); + rse_free((VkVertexInputAttributeDescription*)vertex_input_info->pVertexAttributeDescriptions); } /** @@ -548,9 +550,11 @@ static void fill_input_assembly_info(VkPipelineInputAssemblyStateCreateInfo* inp */ static void fill_viewport_state_info(VkPipelineViewportStateCreateInfo* viewport_state) { - VkViewport* viewport = malloc(sizeof(VkViewport)); - VkRect2D* scissor = malloc(sizeof(VkRect2D)); + VkViewport* viewport = NULL; + VkRect2D* scissor = NULL; + rse_malloc(viewport, sizeof(VkViewport)); + rse_malloc(scissor, sizeof(VkRect2D)); viewport->x = 0.0f; viewport->y = 0.0f; viewport->width = (float)(g_vulkan_state.swapchain_extent.width); @@ -577,8 +581,8 @@ static void fill_viewport_state_info(VkPipelineViewportStateCreateInfo* viewport */ static void free_viewport_state_info(VkPipelineViewportStateCreateInfo* viewport_state) { - free((VkViewport*)viewport_state->pViewports); - free((VkRect2D*)viewport_state->pScissors); + rse_free((VkViewport*)viewport_state->pViewports); + rse_free((VkRect2D*)viewport_state->pScissors); } /** @@ -628,7 +632,9 @@ static void fill_multisampling_state_info(VkPipelineMultisampleStateCreateInfo* */ static void fill_color_blend_state_info(VkPipelineColorBlendStateCreateInfo* color_blending) { - VkPipelineColorBlendAttachmentState* color_blend_attachment = malloc(sizeof(VkPipelineColorBlendAttachmentState)); + VkPipelineColorBlendAttachmentState* color_blend_attachment = NULL; + + rse_malloc(color_blend_attachment, sizeof(VkPipelineColorBlendAttachmentState)); color_blend_attachment->blendEnable = VK_TRUE; color_blend_attachment->srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA; @@ -660,7 +666,7 @@ static void fill_color_blend_state_info(VkPipelineColorBlendStateCreateInfo* col */ static void free_color_blend_info(VkPipelineColorBlendStateCreateInfo* color_blending) { - free((VkPipelineColorBlendAttachmentState*)color_blending->pAttachments); + rse_free((VkPipelineColorBlendAttachmentState*)color_blending->pAttachments); } static void fill_depth_stencil_info(VkPipelineDepthStencilStateCreateInfo* depth_stencil) @@ -749,7 +755,9 @@ static rse_err_t create_graphics_pipeline() */ static rse_err_t create_framebuffers() { - g_vulkan_state.swapchain_framebuffers = malloc(sizeof(VkFramebuffer) * g_swapchain_images_count); + g_vulkan_state.swapchain_framebuffers = NULL; + + rse_malloc(g_vulkan_state.swapchain_framebuffers, sizeof(VkFramebuffer) * g_swapchain_images_count); for (size_t i = 0; i < g_swapchain_images_count; i++) { VkImageView attachments[] = {rse_get_color_image_view(), rse_get_depth_image_view(), g_vulkan_state.swapchain_image_views[i]}; diff --git a/red_scarf_engine/CMakeLists.txt b/red_scarf_engine/CMakeLists.txt index df81ca25..0578b852 100644 --- a/red_scarf_engine/CMakeLists.txt +++ b/red_scarf_engine/CMakeLists.txt @@ -1,3 +1,5 @@ +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Werror") + add_executable(${PROJECT_NAME} src/main.c) target_include_directories(${PROJECT_NAME} PRIVATE diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 3e9d8c9c..ba442381 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -1,12 +1,51 @@ -find_package(Criterion) +find_package(Vulkan REQUIRED) +find_package(vma REQUIRED) +find_package(glfw3 REQUIRED) +find_package(Cmock REQUIRED) +find_package(stb REQUIRED) + +add_definitions( -DRSE_TEST=1 ) add_executable(tests -src/rse_math_tests.c) +src/main.c +src/mocks/vulkan/Mockvulkan_core.c +src/mocks/GLFW/Mockglfw3.c +src/mocks/vk_mem_alloc.c +src/rse_math_tests.c +src/rse_graphics_window_tests.c +src/rse_graphics_vulkan_tests.c +${PROJECT_SOURCE_DIR}/graphics/src/window.c +${PROJECT_SOURCE_DIR}/graphics/src/vulkan_base.c +${PROJECT_SOURCE_DIR}/graphics/src/vulkan_pipeline.c +${PROJECT_SOURCE_DIR}/graphics/src/rse_vulkan_commands.c +${PROJECT_SOURCE_DIR}/graphics/src/vulkan_buffers.c +${PROJECT_SOURCE_DIR}/graphics/src/vulkan_descriptors.c +${PROJECT_SOURCE_DIR}/graphics/src/rse_graphics.c +${PROJECT_SOURCE_DIR}/graphics/src/rse_math.c +${PROJECT_SOURCE_DIR}/graphics/src/mesh_controller.c +${PROJECT_SOURCE_DIR}/graphics/src/vulkan_commons.c +${PROJECT_SOURCE_DIR}/graphics/src/rse_vulkan_image.c +${PROJECT_SOURCE_DIR}/graphics/src/rse_text_renderer.c +${PROJECT_SOURCE_DIR}/utilities/src/logger.c +${PROJECT_SOURCE_DIR}/utilities/src/file_utils.c +${PROJECT_SOURCE_DIR}/utilities/src/rse_task_linux.c +) + target_include_directories(tests PRIVATE -${criterion_INCLUDE_DIR} -${CMAKE_SOURCE_DIR}) +${CMAKE_SOURCE_DIR} +${glfw3_INCLUDE_DIR} +${Vulkan_INCLUDE_DIR} +${unity_INCLUDE_DIR} +${cmock_INCLUDE_DIR} +src/mocks/ +${PROJECT_SOURCE_DIR}/graphics/ +${PROJECT_SOURCE_DIR}/graphics/src/ +${PROJECT_SOURCE_DIR}/utilities/ +) target_link_libraries(tests PRIVATE -${criterion} -rse_graphics) +${cmock} +${unity} +m +) diff --git a/tests/src/main.c b/tests/src/main.c new file mode 100644 index 00000000..37f1a66d --- /dev/null +++ b/tests/src/main.c @@ -0,0 +1,27 @@ +/** + * @file main.c + * @author Piotr Krygier (everyonecancode@gmail.com) + * @brief Main file for tests + * @version 0.1 + * @date 2024-02-16 + * + * @copyright Copyright (c) 2024 + * + */ + +#define RSE_TEST 1 +#include "rse_commons.h" +#define VMA_IMPLEMENTATION +#include "unity_internals.h" +#include "rse_graphics_window_tests.h" +#include "rse_math_tests.h" +#include "rse_graphics_vulkan_tests.h" + +int main(int argc, char *argv[]) +{ + UNITY_BEGIN(); + rse_graphics_window_tests(); + rse_math_tests(); + rse_graphics_vulkan_tests(); + return UNITY_END(); +} diff --git a/tests/src/mocks/GLFW/Mockglfw3.c b/tests/src/mocks/GLFW/Mockglfw3.c new file mode 100644 index 00000000..bafa5a13 --- /dev/null +++ b/tests/src/mocks/GLFW/Mockglfw3.c @@ -0,0 +1,15721 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ +#include +#include +#include +#include "cmock.h" +#include "Mockglfw3.h" + +static const char* CMockString_allocator = "allocator"; +static const char* CMockString_attrib = "attrib"; +static const char* CMockString_bottom = "bottom"; +static const char* CMockString_button = "button"; +static const char* CMockString_callback = "callback"; +static const char* CMockString_count = "count"; +static const char* CMockString_cursor = "cursor"; +static const char* CMockString_denom = "denom"; +static const char* CMockString_description = "description"; +static const char* CMockString_device = "device"; +static const char* CMockString_extension = "extension"; +static const char* CMockString_gamma = "gamma"; +static const char* CMockString_glfwCreateCursor = "glfwCreateCursor"; +static const char* CMockString_glfwCreateStandardCursor = "glfwCreateStandardCursor"; +static const char* CMockString_glfwCreateWindow = "glfwCreateWindow"; +static const char* CMockString_glfwCreateWindowSurface = "glfwCreateWindowSurface"; +static const char* CMockString_glfwDefaultWindowHints = "glfwDefaultWindowHints"; +static const char* CMockString_glfwDestroyCursor = "glfwDestroyCursor"; +static const char* CMockString_glfwDestroyWindow = "glfwDestroyWindow"; +static const char* CMockString_glfwExtensionSupported = "glfwExtensionSupported"; +static const char* CMockString_glfwFocusWindow = "glfwFocusWindow"; +static const char* CMockString_glfwGetClipboardString = "glfwGetClipboardString"; +static const char* CMockString_glfwGetCurrentContext = "glfwGetCurrentContext"; +static const char* CMockString_glfwGetCursorPos = "glfwGetCursorPos"; +static const char* CMockString_glfwGetError = "glfwGetError"; +static const char* CMockString_glfwGetFramebufferSize = "glfwGetFramebufferSize"; +static const char* CMockString_glfwGetGamepadName = "glfwGetGamepadName"; +static const char* CMockString_glfwGetGamepadState = "glfwGetGamepadState"; +static const char* CMockString_glfwGetGammaRamp = "glfwGetGammaRamp"; +static const char* CMockString_glfwGetInputMode = "glfwGetInputMode"; +static const char* CMockString_glfwGetInstanceProcAddress = "glfwGetInstanceProcAddress"; +static const char* CMockString_glfwGetJoystickAxes = "glfwGetJoystickAxes"; +static const char* CMockString_glfwGetJoystickButtons = "glfwGetJoystickButtons"; +static const char* CMockString_glfwGetJoystickGUID = "glfwGetJoystickGUID"; +static const char* CMockString_glfwGetJoystickHats = "glfwGetJoystickHats"; +static const char* CMockString_glfwGetJoystickName = "glfwGetJoystickName"; +static const char* CMockString_glfwGetJoystickUserPointer = "glfwGetJoystickUserPointer"; +static const char* CMockString_glfwGetKey = "glfwGetKey"; +static const char* CMockString_glfwGetKeyName = "glfwGetKeyName"; +static const char* CMockString_glfwGetKeyScancode = "glfwGetKeyScancode"; +static const char* CMockString_glfwGetMonitorContentScale = "glfwGetMonitorContentScale"; +static const char* CMockString_glfwGetMonitorName = "glfwGetMonitorName"; +static const char* CMockString_glfwGetMonitorPhysicalSize = "glfwGetMonitorPhysicalSize"; +static const char* CMockString_glfwGetMonitorPos = "glfwGetMonitorPos"; +static const char* CMockString_glfwGetMonitorUserPointer = "glfwGetMonitorUserPointer"; +static const char* CMockString_glfwGetMonitorWorkarea = "glfwGetMonitorWorkarea"; +static const char* CMockString_glfwGetMonitors = "glfwGetMonitors"; +static const char* CMockString_glfwGetMouseButton = "glfwGetMouseButton"; +static const char* CMockString_glfwGetPhysicalDevicePresentationSupport = "glfwGetPhysicalDevicePresentationSupport"; +static const char* CMockString_glfwGetPrimaryMonitor = "glfwGetPrimaryMonitor"; +static const char* CMockString_glfwGetProcAddress = "glfwGetProcAddress"; +static const char* CMockString_glfwGetRequiredInstanceExtensions = "glfwGetRequiredInstanceExtensions"; +static const char* CMockString_glfwGetTime = "glfwGetTime"; +static const char* CMockString_glfwGetTimerFrequency = "glfwGetTimerFrequency"; +static const char* CMockString_glfwGetTimerValue = "glfwGetTimerValue"; +static const char* CMockString_glfwGetVersion = "glfwGetVersion"; +static const char* CMockString_glfwGetVersionString = "glfwGetVersionString"; +static const char* CMockString_glfwGetVideoMode = "glfwGetVideoMode"; +static const char* CMockString_glfwGetVideoModes = "glfwGetVideoModes"; +static const char* CMockString_glfwGetWindowAttrib = "glfwGetWindowAttrib"; +static const char* CMockString_glfwGetWindowContentScale = "glfwGetWindowContentScale"; +static const char* CMockString_glfwGetWindowFrameSize = "glfwGetWindowFrameSize"; +static const char* CMockString_glfwGetWindowMonitor = "glfwGetWindowMonitor"; +static const char* CMockString_glfwGetWindowOpacity = "glfwGetWindowOpacity"; +static const char* CMockString_glfwGetWindowPos = "glfwGetWindowPos"; +static const char* CMockString_glfwGetWindowSize = "glfwGetWindowSize"; +static const char* CMockString_glfwGetWindowUserPointer = "glfwGetWindowUserPointer"; +static const char* CMockString_glfwHideWindow = "glfwHideWindow"; +static const char* CMockString_glfwIconifyWindow = "glfwIconifyWindow"; +static const char* CMockString_glfwInit = "glfwInit"; +static const char* CMockString_glfwInitHint = "glfwInitHint"; +static const char* CMockString_glfwJoystickIsGamepad = "glfwJoystickIsGamepad"; +static const char* CMockString_glfwJoystickPresent = "glfwJoystickPresent"; +static const char* CMockString_glfwMakeContextCurrent = "glfwMakeContextCurrent"; +static const char* CMockString_glfwMaximizeWindow = "glfwMaximizeWindow"; +static const char* CMockString_glfwPollEvents = "glfwPollEvents"; +static const char* CMockString_glfwPostEmptyEvent = "glfwPostEmptyEvent"; +static const char* CMockString_glfwRawMouseMotionSupported = "glfwRawMouseMotionSupported"; +static const char* CMockString_glfwRequestWindowAttention = "glfwRequestWindowAttention"; +static const char* CMockString_glfwRestoreWindow = "glfwRestoreWindow"; +static const char* CMockString_glfwSetCharCallback = "glfwSetCharCallback"; +static const char* CMockString_glfwSetCharModsCallback = "glfwSetCharModsCallback"; +static const char* CMockString_glfwSetClipboardString = "glfwSetClipboardString"; +static const char* CMockString_glfwSetCursor = "glfwSetCursor"; +static const char* CMockString_glfwSetCursorEnterCallback = "glfwSetCursorEnterCallback"; +static const char* CMockString_glfwSetCursorPos = "glfwSetCursorPos"; +static const char* CMockString_glfwSetCursorPosCallback = "glfwSetCursorPosCallback"; +static const char* CMockString_glfwSetDropCallback = "glfwSetDropCallback"; +static const char* CMockString_glfwSetErrorCallback = "glfwSetErrorCallback"; +static const char* CMockString_glfwSetFramebufferSizeCallback = "glfwSetFramebufferSizeCallback"; +static const char* CMockString_glfwSetGamma = "glfwSetGamma"; +static const char* CMockString_glfwSetGammaRamp = "glfwSetGammaRamp"; +static const char* CMockString_glfwSetInputMode = "glfwSetInputMode"; +static const char* CMockString_glfwSetJoystickCallback = "glfwSetJoystickCallback"; +static const char* CMockString_glfwSetJoystickUserPointer = "glfwSetJoystickUserPointer"; +static const char* CMockString_glfwSetKeyCallback = "glfwSetKeyCallback"; +static const char* CMockString_glfwSetMonitorCallback = "glfwSetMonitorCallback"; +static const char* CMockString_glfwSetMonitorUserPointer = "glfwSetMonitorUserPointer"; +static const char* CMockString_glfwSetMouseButtonCallback = "glfwSetMouseButtonCallback"; +static const char* CMockString_glfwSetScrollCallback = "glfwSetScrollCallback"; +static const char* CMockString_glfwSetTime = "glfwSetTime"; +static const char* CMockString_glfwSetWindowAspectRatio = "glfwSetWindowAspectRatio"; +static const char* CMockString_glfwSetWindowAttrib = "glfwSetWindowAttrib"; +static const char* CMockString_glfwSetWindowCloseCallback = "glfwSetWindowCloseCallback"; +static const char* CMockString_glfwSetWindowContentScaleCallback = "glfwSetWindowContentScaleCallback"; +static const char* CMockString_glfwSetWindowFocusCallback = "glfwSetWindowFocusCallback"; +static const char* CMockString_glfwSetWindowIcon = "glfwSetWindowIcon"; +static const char* CMockString_glfwSetWindowIconifyCallback = "glfwSetWindowIconifyCallback"; +static const char* CMockString_glfwSetWindowMaximizeCallback = "glfwSetWindowMaximizeCallback"; +static const char* CMockString_glfwSetWindowMonitor = "glfwSetWindowMonitor"; +static const char* CMockString_glfwSetWindowOpacity = "glfwSetWindowOpacity"; +static const char* CMockString_glfwSetWindowPos = "glfwSetWindowPos"; +static const char* CMockString_glfwSetWindowPosCallback = "glfwSetWindowPosCallback"; +static const char* CMockString_glfwSetWindowRefreshCallback = "glfwSetWindowRefreshCallback"; +static const char* CMockString_glfwSetWindowShouldClose = "glfwSetWindowShouldClose"; +static const char* CMockString_glfwSetWindowSize = "glfwSetWindowSize"; +static const char* CMockString_glfwSetWindowSizeCallback = "glfwSetWindowSizeCallback"; +static const char* CMockString_glfwSetWindowSizeLimits = "glfwSetWindowSizeLimits"; +static const char* CMockString_glfwSetWindowTitle = "glfwSetWindowTitle"; +static const char* CMockString_glfwSetWindowUserPointer = "glfwSetWindowUserPointer"; +static const char* CMockString_glfwShowWindow = "glfwShowWindow"; +static const char* CMockString_glfwSwapBuffers = "glfwSwapBuffers"; +static const char* CMockString_glfwSwapInterval = "glfwSwapInterval"; +static const char* CMockString_glfwTerminate = "glfwTerminate"; +static const char* CMockString_glfwUpdateGamepadMappings = "glfwUpdateGamepadMappings"; +static const char* CMockString_glfwVulkanSupported = "glfwVulkanSupported"; +static const char* CMockString_glfwWaitEvents = "glfwWaitEvents"; +static const char* CMockString_glfwWaitEventsTimeout = "glfwWaitEventsTimeout"; +static const char* CMockString_glfwWindowHint = "glfwWindowHint"; +static const char* CMockString_glfwWindowHintString = "glfwWindowHintString"; +static const char* CMockString_glfwWindowShouldClose = "glfwWindowShouldClose"; +static const char* CMockString_height = "height"; +static const char* CMockString_heightMM = "heightMM"; +static const char* CMockString_hint = "hint"; +static const char* CMockString_image = "image"; +static const char* CMockString_images = "images"; +static const char* CMockString_instance = "instance"; +static const char* CMockString_interval = "interval"; +static const char* CMockString_jid = "jid"; +static const char* CMockString_key = "key"; +static const char* CMockString_left = "left"; +static const char* CMockString_major = "major"; +static const char* CMockString_maxheight = "maxheight"; +static const char* CMockString_maxwidth = "maxwidth"; +static const char* CMockString_minheight = "minheight"; +static const char* CMockString_minor = "minor"; +static const char* CMockString_minwidth = "minwidth"; +static const char* CMockString_mode = "mode"; +static const char* CMockString_monitor = "monitor"; +static const char* CMockString_numer = "numer"; +static const char* CMockString_opacity = "opacity"; +static const char* CMockString_pointer = "pointer"; +static const char* CMockString_procname = "procname"; +static const char* CMockString_queuefamily = "queuefamily"; +static const char* CMockString_ramp = "ramp"; +static const char* CMockString_refreshRate = "refreshRate"; +static const char* CMockString_rev = "rev"; +static const char* CMockString_right = "right"; +static const char* CMockString_scancode = "scancode"; +static const char* CMockString_shape = "shape"; +static const char* CMockString_share = "share"; +static const char* CMockString_state = "state"; +static const char* CMockString_string = "string"; +static const char* CMockString_surface = "surface"; +static const char* CMockString_time = "time"; +static const char* CMockString_timeout = "timeout"; +static const char* CMockString_title = "title"; +static const char* CMockString_top = "top"; +static const char* CMockString_value = "value"; +static const char* CMockString_width = "width"; +static const char* CMockString_widthMM = "widthMM"; +static const char* CMockString_window = "window"; +static const char* CMockString_xhot = "xhot"; +static const char* CMockString_xpos = "xpos"; +static const char* CMockString_xscale = "xscale"; +static const char* CMockString_yhot = "yhot"; +static const char* CMockString_ypos = "ypos"; +static const char* CMockString_yscale = "yscale"; + +typedef struct _CMOCK_glfwInit_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + int ReturnVal; + +} CMOCK_glfwInit_CALL_INSTANCE; + +typedef struct _CMOCK_glfwTerminate_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + +} CMOCK_glfwTerminate_CALL_INSTANCE; + +typedef struct _CMOCK_glfwInitHint_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + int Expected_hint; + int Expected_value; + char IgnoreArg_hint; + char IgnoreArg_value; + +} CMOCK_glfwInitHint_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetVersion_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + int* Expected_major; + int* Expected_minor; + int* Expected_rev; + char IgnoreArg_major; + char IgnoreArg_minor; + char IgnoreArg_rev; + +} CMOCK_glfwGetVersion_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetVersionString_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + const char* ReturnVal; + +} CMOCK_glfwGetVersionString_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetError_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + int ReturnVal; + const char** Expected_description; + char IgnoreArg_description; + +} CMOCK_glfwGetError_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetErrorCallback_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWerrorfun ReturnVal; + GLFWerrorfun Expected_callback; + char IgnoreArg_callback; + +} CMOCK_glfwSetErrorCallback_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetMonitors_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWmonitor** ReturnVal; + int* Expected_count; + char IgnoreArg_count; + +} CMOCK_glfwGetMonitors_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetPrimaryMonitor_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWmonitor* ReturnVal; + +} CMOCK_glfwGetPrimaryMonitor_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetMonitorPos_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWmonitor* Expected_monitor; + int* Expected_xpos; + int* Expected_ypos; + char IgnoreArg_monitor; + char IgnoreArg_xpos; + char IgnoreArg_ypos; + +} CMOCK_glfwGetMonitorPos_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetMonitorWorkarea_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWmonitor* Expected_monitor; + int* Expected_xpos; + int* Expected_ypos; + int* Expected_width; + int* Expected_height; + char IgnoreArg_monitor; + char IgnoreArg_xpos; + char IgnoreArg_ypos; + char IgnoreArg_width; + char IgnoreArg_height; + +} CMOCK_glfwGetMonitorWorkarea_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetMonitorPhysicalSize_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWmonitor* Expected_monitor; + int* Expected_widthMM; + int* Expected_heightMM; + char IgnoreArg_monitor; + char IgnoreArg_widthMM; + char IgnoreArg_heightMM; + +} CMOCK_glfwGetMonitorPhysicalSize_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetMonitorContentScale_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWmonitor* Expected_monitor; + float* Expected_xscale; + float* Expected_yscale; + char IgnoreArg_monitor; + char IgnoreArg_xscale; + char IgnoreArg_yscale; + +} CMOCK_glfwGetMonitorContentScale_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetMonitorName_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + const char* ReturnVal; + GLFWmonitor* Expected_monitor; + char IgnoreArg_monitor; + +} CMOCK_glfwGetMonitorName_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetMonitorUserPointer_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWmonitor* Expected_monitor; + void* Expected_pointer; + char IgnoreArg_monitor; + char IgnoreArg_pointer; + +} CMOCK_glfwSetMonitorUserPointer_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetMonitorUserPointer_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + void* ReturnVal; + GLFWmonitor* Expected_monitor; + char IgnoreArg_monitor; + +} CMOCK_glfwGetMonitorUserPointer_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetMonitorCallback_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWmonitorfun ReturnVal; + GLFWmonitorfun Expected_callback; + char IgnoreArg_callback; + +} CMOCK_glfwSetMonitorCallback_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetVideoModes_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + const GLFWvidmode* ReturnVal; + GLFWmonitor* Expected_monitor; + int* Expected_count; + char IgnoreArg_monitor; + char IgnoreArg_count; + +} CMOCK_glfwGetVideoModes_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetVideoMode_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + const GLFWvidmode* ReturnVal; + GLFWmonitor* Expected_monitor; + char IgnoreArg_monitor; + +} CMOCK_glfwGetVideoMode_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetGamma_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWmonitor* Expected_monitor; + float Expected_gamma; + char IgnoreArg_monitor; + char IgnoreArg_gamma; + +} CMOCK_glfwSetGamma_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetGammaRamp_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + const GLFWgammaramp* ReturnVal; + GLFWmonitor* Expected_monitor; + char IgnoreArg_monitor; + +} CMOCK_glfwGetGammaRamp_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetGammaRamp_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWmonitor* Expected_monitor; + const GLFWgammaramp* Expected_ramp; + char IgnoreArg_monitor; + char IgnoreArg_ramp; + +} CMOCK_glfwSetGammaRamp_CALL_INSTANCE; + +typedef struct _CMOCK_glfwDefaultWindowHints_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + +} CMOCK_glfwDefaultWindowHints_CALL_INSTANCE; + +typedef struct _CMOCK_glfwWindowHint_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + int Expected_hint; + int Expected_value; + char IgnoreArg_hint; + char IgnoreArg_value; + +} CMOCK_glfwWindowHint_CALL_INSTANCE; + +typedef struct _CMOCK_glfwWindowHintString_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + int Expected_hint; + const char* Expected_value; + char IgnoreArg_hint; + char IgnoreArg_value; + +} CMOCK_glfwWindowHintString_CALL_INSTANCE; + +typedef struct _CMOCK_glfwCreateWindow_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* ReturnVal; + int Expected_width; + int Expected_height; + const char* Expected_title; + GLFWmonitor* Expected_monitor; + GLFWwindow* Expected_share; + char IgnoreArg_width; + char IgnoreArg_height; + char IgnoreArg_title; + char IgnoreArg_monitor; + char IgnoreArg_share; + +} CMOCK_glfwCreateWindow_CALL_INSTANCE; + +typedef struct _CMOCK_glfwDestroyWindow_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + char IgnoreArg_window; + +} CMOCK_glfwDestroyWindow_CALL_INSTANCE; + +typedef struct _CMOCK_glfwWindowShouldClose_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + int ReturnVal; + GLFWwindow* Expected_window; + char IgnoreArg_window; + +} CMOCK_glfwWindowShouldClose_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetWindowShouldClose_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + int Expected_value; + char IgnoreArg_window; + char IgnoreArg_value; + +} CMOCK_glfwSetWindowShouldClose_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetWindowTitle_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + const char* Expected_title; + char IgnoreArg_window; + char IgnoreArg_title; + +} CMOCK_glfwSetWindowTitle_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetWindowIcon_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + int Expected_count; + const GLFWimage* Expected_images; + char IgnoreArg_window; + char IgnoreArg_count; + char IgnoreArg_images; + +} CMOCK_glfwSetWindowIcon_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetWindowPos_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + int* Expected_xpos; + int* Expected_ypos; + char IgnoreArg_window; + char IgnoreArg_xpos; + char IgnoreArg_ypos; + +} CMOCK_glfwGetWindowPos_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetWindowPos_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + int Expected_xpos; + int Expected_ypos; + char IgnoreArg_window; + char IgnoreArg_xpos; + char IgnoreArg_ypos; + +} CMOCK_glfwSetWindowPos_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetWindowSize_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + int* Expected_width; + int* Expected_height; + char IgnoreArg_window; + char IgnoreArg_width; + char IgnoreArg_height; + +} CMOCK_glfwGetWindowSize_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetWindowSizeLimits_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + int Expected_minwidth; + int Expected_minheight; + int Expected_maxwidth; + int Expected_maxheight; + char IgnoreArg_window; + char IgnoreArg_minwidth; + char IgnoreArg_minheight; + char IgnoreArg_maxwidth; + char IgnoreArg_maxheight; + +} CMOCK_glfwSetWindowSizeLimits_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetWindowAspectRatio_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + int Expected_numer; + int Expected_denom; + char IgnoreArg_window; + char IgnoreArg_numer; + char IgnoreArg_denom; + +} CMOCK_glfwSetWindowAspectRatio_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetWindowSize_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + int Expected_width; + int Expected_height; + char IgnoreArg_window; + char IgnoreArg_width; + char IgnoreArg_height; + +} CMOCK_glfwSetWindowSize_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetFramebufferSize_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + int* Expected_width; + int* Expected_height; + char IgnoreArg_window; + char IgnoreArg_width; + char IgnoreArg_height; + +} CMOCK_glfwGetFramebufferSize_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetWindowFrameSize_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + int* Expected_left; + int* Expected_top; + int* Expected_right; + int* Expected_bottom; + char IgnoreArg_window; + char IgnoreArg_left; + char IgnoreArg_top; + char IgnoreArg_right; + char IgnoreArg_bottom; + +} CMOCK_glfwGetWindowFrameSize_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetWindowContentScale_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + float* Expected_xscale; + float* Expected_yscale; + char IgnoreArg_window; + char IgnoreArg_xscale; + char IgnoreArg_yscale; + +} CMOCK_glfwGetWindowContentScale_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetWindowOpacity_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + float ReturnVal; + GLFWwindow* Expected_window; + char IgnoreArg_window; + +} CMOCK_glfwGetWindowOpacity_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetWindowOpacity_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + float Expected_opacity; + char IgnoreArg_window; + char IgnoreArg_opacity; + +} CMOCK_glfwSetWindowOpacity_CALL_INSTANCE; + +typedef struct _CMOCK_glfwIconifyWindow_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + char IgnoreArg_window; + +} CMOCK_glfwIconifyWindow_CALL_INSTANCE; + +typedef struct _CMOCK_glfwRestoreWindow_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + char IgnoreArg_window; + +} CMOCK_glfwRestoreWindow_CALL_INSTANCE; + +typedef struct _CMOCK_glfwMaximizeWindow_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + char IgnoreArg_window; + +} CMOCK_glfwMaximizeWindow_CALL_INSTANCE; + +typedef struct _CMOCK_glfwShowWindow_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + char IgnoreArg_window; + +} CMOCK_glfwShowWindow_CALL_INSTANCE; + +typedef struct _CMOCK_glfwHideWindow_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + char IgnoreArg_window; + +} CMOCK_glfwHideWindow_CALL_INSTANCE; + +typedef struct _CMOCK_glfwFocusWindow_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + char IgnoreArg_window; + +} CMOCK_glfwFocusWindow_CALL_INSTANCE; + +typedef struct _CMOCK_glfwRequestWindowAttention_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + char IgnoreArg_window; + +} CMOCK_glfwRequestWindowAttention_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetWindowMonitor_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWmonitor* ReturnVal; + GLFWwindow* Expected_window; + char IgnoreArg_window; + +} CMOCK_glfwGetWindowMonitor_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetWindowMonitor_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + GLFWmonitor* Expected_monitor; + int Expected_xpos; + int Expected_ypos; + int Expected_width; + int Expected_height; + int Expected_refreshRate; + char IgnoreArg_window; + char IgnoreArg_monitor; + char IgnoreArg_xpos; + char IgnoreArg_ypos; + char IgnoreArg_width; + char IgnoreArg_height; + char IgnoreArg_refreshRate; + +} CMOCK_glfwSetWindowMonitor_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetWindowAttrib_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + int ReturnVal; + GLFWwindow* Expected_window; + int Expected_attrib; + char IgnoreArg_window; + char IgnoreArg_attrib; + +} CMOCK_glfwGetWindowAttrib_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetWindowAttrib_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + int Expected_attrib; + int Expected_value; + char IgnoreArg_window; + char IgnoreArg_attrib; + char IgnoreArg_value; + +} CMOCK_glfwSetWindowAttrib_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetWindowUserPointer_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + void* Expected_pointer; + char IgnoreArg_window; + char IgnoreArg_pointer; + +} CMOCK_glfwSetWindowUserPointer_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetWindowUserPointer_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + void* ReturnVal; + GLFWwindow* Expected_window; + char IgnoreArg_window; + +} CMOCK_glfwGetWindowUserPointer_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetWindowPosCallback_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindowposfun ReturnVal; + GLFWwindow* Expected_window; + GLFWwindowposfun Expected_callback; + char IgnoreArg_window; + char IgnoreArg_callback; + +} CMOCK_glfwSetWindowPosCallback_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetWindowSizeCallback_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindowsizefun ReturnVal; + GLFWwindow* Expected_window; + GLFWwindowsizefun Expected_callback; + char IgnoreArg_window; + char IgnoreArg_callback; + +} CMOCK_glfwSetWindowSizeCallback_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetWindowCloseCallback_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindowclosefun ReturnVal; + GLFWwindow* Expected_window; + GLFWwindowclosefun Expected_callback; + char IgnoreArg_window; + char IgnoreArg_callback; + +} CMOCK_glfwSetWindowCloseCallback_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetWindowRefreshCallback_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindowrefreshfun ReturnVal; + GLFWwindow* Expected_window; + GLFWwindowrefreshfun Expected_callback; + char IgnoreArg_window; + char IgnoreArg_callback; + +} CMOCK_glfwSetWindowRefreshCallback_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetWindowFocusCallback_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindowfocusfun ReturnVal; + GLFWwindow* Expected_window; + GLFWwindowfocusfun Expected_callback; + char IgnoreArg_window; + char IgnoreArg_callback; + +} CMOCK_glfwSetWindowFocusCallback_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetWindowIconifyCallback_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindowiconifyfun ReturnVal; + GLFWwindow* Expected_window; + GLFWwindowiconifyfun Expected_callback; + char IgnoreArg_window; + char IgnoreArg_callback; + +} CMOCK_glfwSetWindowIconifyCallback_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetWindowMaximizeCallback_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindowmaximizefun ReturnVal; + GLFWwindow* Expected_window; + GLFWwindowmaximizefun Expected_callback; + char IgnoreArg_window; + char IgnoreArg_callback; + +} CMOCK_glfwSetWindowMaximizeCallback_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetFramebufferSizeCallback_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWframebuffersizefun ReturnVal; + GLFWwindow* Expected_window; + GLFWframebuffersizefun Expected_callback; + char IgnoreArg_window; + char IgnoreArg_callback; + +} CMOCK_glfwSetFramebufferSizeCallback_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetWindowContentScaleCallback_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindowcontentscalefun ReturnVal; + GLFWwindow* Expected_window; + GLFWwindowcontentscalefun Expected_callback; + char IgnoreArg_window; + char IgnoreArg_callback; + +} CMOCK_glfwSetWindowContentScaleCallback_CALL_INSTANCE; + +typedef struct _CMOCK_glfwPollEvents_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + +} CMOCK_glfwPollEvents_CALL_INSTANCE; + +typedef struct _CMOCK_glfwWaitEvents_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + +} CMOCK_glfwWaitEvents_CALL_INSTANCE; + +typedef struct _CMOCK_glfwWaitEventsTimeout_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + double Expected_timeout; + char IgnoreArg_timeout; + +} CMOCK_glfwWaitEventsTimeout_CALL_INSTANCE; + +typedef struct _CMOCK_glfwPostEmptyEvent_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + +} CMOCK_glfwPostEmptyEvent_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetInputMode_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + int ReturnVal; + GLFWwindow* Expected_window; + int Expected_mode; + char IgnoreArg_window; + char IgnoreArg_mode; + +} CMOCK_glfwGetInputMode_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetInputMode_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + int Expected_mode; + int Expected_value; + char IgnoreArg_window; + char IgnoreArg_mode; + char IgnoreArg_value; + +} CMOCK_glfwSetInputMode_CALL_INSTANCE; + +typedef struct _CMOCK_glfwRawMouseMotionSupported_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + int ReturnVal; + +} CMOCK_glfwRawMouseMotionSupported_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetKeyName_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + const char* ReturnVal; + int Expected_key; + int Expected_scancode; + char IgnoreArg_key; + char IgnoreArg_scancode; + +} CMOCK_glfwGetKeyName_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetKeyScancode_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + int ReturnVal; + int Expected_key; + char IgnoreArg_key; + +} CMOCK_glfwGetKeyScancode_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetKey_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + int ReturnVal; + GLFWwindow* Expected_window; + int Expected_key; + char IgnoreArg_window; + char IgnoreArg_key; + +} CMOCK_glfwGetKey_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetMouseButton_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + int ReturnVal; + GLFWwindow* Expected_window; + int Expected_button; + char IgnoreArg_window; + char IgnoreArg_button; + +} CMOCK_glfwGetMouseButton_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetCursorPos_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + double* Expected_xpos; + double* Expected_ypos; + char IgnoreArg_window; + char IgnoreArg_xpos; + char IgnoreArg_ypos; + +} CMOCK_glfwGetCursorPos_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetCursorPos_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + double Expected_xpos; + double Expected_ypos; + char IgnoreArg_window; + char IgnoreArg_xpos; + char IgnoreArg_ypos; + +} CMOCK_glfwSetCursorPos_CALL_INSTANCE; + +typedef struct _CMOCK_glfwCreateCursor_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWcursor* ReturnVal; + const GLFWimage* Expected_image; + int Expected_xhot; + int Expected_yhot; + char IgnoreArg_image; + char IgnoreArg_xhot; + char IgnoreArg_yhot; + +} CMOCK_glfwCreateCursor_CALL_INSTANCE; + +typedef struct _CMOCK_glfwCreateStandardCursor_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWcursor* ReturnVal; + int Expected_shape; + char IgnoreArg_shape; + +} CMOCK_glfwCreateStandardCursor_CALL_INSTANCE; + +typedef struct _CMOCK_glfwDestroyCursor_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWcursor* Expected_cursor; + char IgnoreArg_cursor; + +} CMOCK_glfwDestroyCursor_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetCursor_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + GLFWcursor* Expected_cursor; + char IgnoreArg_window; + char IgnoreArg_cursor; + +} CMOCK_glfwSetCursor_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetKeyCallback_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWkeyfun ReturnVal; + GLFWwindow* Expected_window; + GLFWkeyfun Expected_callback; + char IgnoreArg_window; + char IgnoreArg_callback; + +} CMOCK_glfwSetKeyCallback_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetCharCallback_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWcharfun ReturnVal; + GLFWwindow* Expected_window; + GLFWcharfun Expected_callback; + char IgnoreArg_window; + char IgnoreArg_callback; + +} CMOCK_glfwSetCharCallback_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetCharModsCallback_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWcharmodsfun ReturnVal; + GLFWwindow* Expected_window; + GLFWcharmodsfun Expected_callback; + char IgnoreArg_window; + char IgnoreArg_callback; + +} CMOCK_glfwSetCharModsCallback_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetMouseButtonCallback_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWmousebuttonfun ReturnVal; + GLFWwindow* Expected_window; + GLFWmousebuttonfun Expected_callback; + char IgnoreArg_window; + char IgnoreArg_callback; + +} CMOCK_glfwSetMouseButtonCallback_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetCursorPosCallback_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWcursorposfun ReturnVal; + GLFWwindow* Expected_window; + GLFWcursorposfun Expected_callback; + char IgnoreArg_window; + char IgnoreArg_callback; + +} CMOCK_glfwSetCursorPosCallback_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetCursorEnterCallback_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWcursorenterfun ReturnVal; + GLFWwindow* Expected_window; + GLFWcursorenterfun Expected_callback; + char IgnoreArg_window; + char IgnoreArg_callback; + +} CMOCK_glfwSetCursorEnterCallback_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetScrollCallback_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWscrollfun ReturnVal; + GLFWwindow* Expected_window; + GLFWscrollfun Expected_callback; + char IgnoreArg_window; + char IgnoreArg_callback; + +} CMOCK_glfwSetScrollCallback_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetDropCallback_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWdropfun ReturnVal; + GLFWwindow* Expected_window; + GLFWdropfun Expected_callback; + char IgnoreArg_window; + char IgnoreArg_callback; + +} CMOCK_glfwSetDropCallback_CALL_INSTANCE; + +typedef struct _CMOCK_glfwJoystickPresent_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + int ReturnVal; + int Expected_jid; + char IgnoreArg_jid; + +} CMOCK_glfwJoystickPresent_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetJoystickAxes_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + const float* ReturnVal; + int Expected_jid; + int* Expected_count; + char IgnoreArg_jid; + char IgnoreArg_count; + +} CMOCK_glfwGetJoystickAxes_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetJoystickButtons_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + const unsigned char* ReturnVal; + int Expected_jid; + int* Expected_count; + char IgnoreArg_jid; + char IgnoreArg_count; + +} CMOCK_glfwGetJoystickButtons_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetJoystickHats_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + const unsigned char* ReturnVal; + int Expected_jid; + int* Expected_count; + char IgnoreArg_jid; + char IgnoreArg_count; + +} CMOCK_glfwGetJoystickHats_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetJoystickName_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + const char* ReturnVal; + int Expected_jid; + char IgnoreArg_jid; + +} CMOCK_glfwGetJoystickName_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetJoystickGUID_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + const char* ReturnVal; + int Expected_jid; + char IgnoreArg_jid; + +} CMOCK_glfwGetJoystickGUID_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetJoystickUserPointer_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + int Expected_jid; + void* Expected_pointer; + char IgnoreArg_jid; + char IgnoreArg_pointer; + +} CMOCK_glfwSetJoystickUserPointer_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetJoystickUserPointer_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + void* ReturnVal; + int Expected_jid; + char IgnoreArg_jid; + +} CMOCK_glfwGetJoystickUserPointer_CALL_INSTANCE; + +typedef struct _CMOCK_glfwJoystickIsGamepad_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + int ReturnVal; + int Expected_jid; + char IgnoreArg_jid; + +} CMOCK_glfwJoystickIsGamepad_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetJoystickCallback_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWjoystickfun ReturnVal; + GLFWjoystickfun Expected_callback; + char IgnoreArg_callback; + +} CMOCK_glfwSetJoystickCallback_CALL_INSTANCE; + +typedef struct _CMOCK_glfwUpdateGamepadMappings_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + int ReturnVal; + const char* Expected_string; + char IgnoreArg_string; + +} CMOCK_glfwUpdateGamepadMappings_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetGamepadName_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + const char* ReturnVal; + int Expected_jid; + char IgnoreArg_jid; + +} CMOCK_glfwGetGamepadName_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetGamepadState_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + int ReturnVal; + int Expected_jid; + GLFWgamepadstate* Expected_state; + char IgnoreArg_jid; + char IgnoreArg_state; + +} CMOCK_glfwGetGamepadState_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetClipboardString_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + const char* Expected_string; + char IgnoreArg_window; + char IgnoreArg_string; + +} CMOCK_glfwSetClipboardString_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetClipboardString_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + const char* ReturnVal; + GLFWwindow* Expected_window; + char IgnoreArg_window; + +} CMOCK_glfwGetClipboardString_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetTime_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + double ReturnVal; + +} CMOCK_glfwGetTime_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSetTime_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + double Expected_time; + char IgnoreArg_time; + +} CMOCK_glfwSetTime_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetTimerValue_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + uint64_t ReturnVal; + +} CMOCK_glfwGetTimerValue_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetTimerFrequency_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + uint64_t ReturnVal; + +} CMOCK_glfwGetTimerFrequency_CALL_INSTANCE; + +typedef struct _CMOCK_glfwMakeContextCurrent_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + char IgnoreArg_window; + +} CMOCK_glfwMakeContextCurrent_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetCurrentContext_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* ReturnVal; + +} CMOCK_glfwGetCurrentContext_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSwapBuffers_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWwindow* Expected_window; + char IgnoreArg_window; + +} CMOCK_glfwSwapBuffers_CALL_INSTANCE; + +typedef struct _CMOCK_glfwSwapInterval_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + int Expected_interval; + char IgnoreArg_interval; + +} CMOCK_glfwSwapInterval_CALL_INSTANCE; + +typedef struct _CMOCK_glfwExtensionSupported_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + int ReturnVal; + const char* Expected_extension; + char IgnoreArg_extension; + +} CMOCK_glfwExtensionSupported_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetProcAddress_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWglproc ReturnVal; + const char* Expected_procname; + char IgnoreArg_procname; + +} CMOCK_glfwGetProcAddress_CALL_INSTANCE; + +typedef struct _CMOCK_glfwVulkanSupported_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + int ReturnVal; + +} CMOCK_glfwVulkanSupported_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetRequiredInstanceExtensions_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + const char** ReturnVal; + uint32_t* Expected_count; + char IgnoreArg_count; + +} CMOCK_glfwGetRequiredInstanceExtensions_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetInstanceProcAddress_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + GLFWvkproc ReturnVal; + VkInstance Expected_instance; + const char* Expected_procname; + char IgnoreArg_instance; + char IgnoreArg_procname; + +} CMOCK_glfwGetInstanceProcAddress_CALL_INSTANCE; + +typedef struct _CMOCK_glfwGetPhysicalDevicePresentationSupport_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + int ReturnVal; + VkInstance Expected_instance; + VkPhysicalDevice Expected_device; + uint32_t Expected_queuefamily; + char IgnoreArg_instance; + char IgnoreArg_device; + char IgnoreArg_queuefamily; + +} CMOCK_glfwGetPhysicalDevicePresentationSupport_CALL_INSTANCE; + +typedef struct _CMOCK_glfwCreateWindowSurface_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + VkResult ReturnVal; + VkInstance Expected_instance; + GLFWwindow* Expected_window; + const VkAllocationCallbacks* Expected_allocator; + VkSurfaceKHR* Expected_surface; + char IgnoreArg_instance; + char IgnoreArg_window; + char IgnoreArg_allocator; + char IgnoreArg_surface; + +} CMOCK_glfwCreateWindowSurface_CALL_INSTANCE; + +static struct Mockglfw3Instance +{ + char glfwInit_IgnoreBool; + int glfwInit_FinalReturn; + char glfwInit_CallbackBool; + CMOCK_glfwInit_CALLBACK glfwInit_CallbackFunctionPointer; + int glfwInit_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwInit_CallInstance; + char glfwTerminate_IgnoreBool; + char glfwTerminate_CallbackBool; + CMOCK_glfwTerminate_CALLBACK glfwTerminate_CallbackFunctionPointer; + int glfwTerminate_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwTerminate_CallInstance; + char glfwInitHint_IgnoreBool; + char glfwInitHint_CallbackBool; + CMOCK_glfwInitHint_CALLBACK glfwInitHint_CallbackFunctionPointer; + int glfwInitHint_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwInitHint_CallInstance; + char glfwGetVersion_IgnoreBool; + char glfwGetVersion_CallbackBool; + CMOCK_glfwGetVersion_CALLBACK glfwGetVersion_CallbackFunctionPointer; + int glfwGetVersion_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetVersion_CallInstance; + char glfwGetVersionString_IgnoreBool; + const char* glfwGetVersionString_FinalReturn; + char glfwGetVersionString_CallbackBool; + CMOCK_glfwGetVersionString_CALLBACK glfwGetVersionString_CallbackFunctionPointer; + int glfwGetVersionString_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetVersionString_CallInstance; + char glfwGetError_IgnoreBool; + int glfwGetError_FinalReturn; + char glfwGetError_CallbackBool; + CMOCK_glfwGetError_CALLBACK glfwGetError_CallbackFunctionPointer; + int glfwGetError_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetError_CallInstance; + char glfwSetErrorCallback_IgnoreBool; + GLFWerrorfun glfwSetErrorCallback_FinalReturn; + char glfwSetErrorCallback_CallbackBool; + CMOCK_glfwSetErrorCallback_CALLBACK glfwSetErrorCallback_CallbackFunctionPointer; + int glfwSetErrorCallback_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetErrorCallback_CallInstance; + char glfwGetMonitors_IgnoreBool; + GLFWmonitor** glfwGetMonitors_FinalReturn; + char glfwGetMonitors_CallbackBool; + CMOCK_glfwGetMonitors_CALLBACK glfwGetMonitors_CallbackFunctionPointer; + int glfwGetMonitors_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetMonitors_CallInstance; + char glfwGetPrimaryMonitor_IgnoreBool; + GLFWmonitor* glfwGetPrimaryMonitor_FinalReturn; + char glfwGetPrimaryMonitor_CallbackBool; + CMOCK_glfwGetPrimaryMonitor_CALLBACK glfwGetPrimaryMonitor_CallbackFunctionPointer; + int glfwGetPrimaryMonitor_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetPrimaryMonitor_CallInstance; + char glfwGetMonitorPos_IgnoreBool; + char glfwGetMonitorPos_CallbackBool; + CMOCK_glfwGetMonitorPos_CALLBACK glfwGetMonitorPos_CallbackFunctionPointer; + int glfwGetMonitorPos_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetMonitorPos_CallInstance; + char glfwGetMonitorWorkarea_IgnoreBool; + char glfwGetMonitorWorkarea_CallbackBool; + CMOCK_glfwGetMonitorWorkarea_CALLBACK glfwGetMonitorWorkarea_CallbackFunctionPointer; + int glfwGetMonitorWorkarea_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetMonitorWorkarea_CallInstance; + char glfwGetMonitorPhysicalSize_IgnoreBool; + char glfwGetMonitorPhysicalSize_CallbackBool; + CMOCK_glfwGetMonitorPhysicalSize_CALLBACK glfwGetMonitorPhysicalSize_CallbackFunctionPointer; + int glfwGetMonitorPhysicalSize_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetMonitorPhysicalSize_CallInstance; + char glfwGetMonitorContentScale_IgnoreBool; + char glfwGetMonitorContentScale_CallbackBool; + CMOCK_glfwGetMonitorContentScale_CALLBACK glfwGetMonitorContentScale_CallbackFunctionPointer; + int glfwGetMonitorContentScale_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetMonitorContentScale_CallInstance; + char glfwGetMonitorName_IgnoreBool; + const char* glfwGetMonitorName_FinalReturn; + char glfwGetMonitorName_CallbackBool; + CMOCK_glfwGetMonitorName_CALLBACK glfwGetMonitorName_CallbackFunctionPointer; + int glfwGetMonitorName_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetMonitorName_CallInstance; + char glfwSetMonitorUserPointer_IgnoreBool; + char glfwSetMonitorUserPointer_CallbackBool; + CMOCK_glfwSetMonitorUserPointer_CALLBACK glfwSetMonitorUserPointer_CallbackFunctionPointer; + int glfwSetMonitorUserPointer_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetMonitorUserPointer_CallInstance; + char glfwGetMonitorUserPointer_IgnoreBool; + void* glfwGetMonitorUserPointer_FinalReturn; + char glfwGetMonitorUserPointer_CallbackBool; + CMOCK_glfwGetMonitorUserPointer_CALLBACK glfwGetMonitorUserPointer_CallbackFunctionPointer; + int glfwGetMonitorUserPointer_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetMonitorUserPointer_CallInstance; + char glfwSetMonitorCallback_IgnoreBool; + GLFWmonitorfun glfwSetMonitorCallback_FinalReturn; + char glfwSetMonitorCallback_CallbackBool; + CMOCK_glfwSetMonitorCallback_CALLBACK glfwSetMonitorCallback_CallbackFunctionPointer; + int glfwSetMonitorCallback_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetMonitorCallback_CallInstance; + char glfwGetVideoModes_IgnoreBool; + const GLFWvidmode* glfwGetVideoModes_FinalReturn; + char glfwGetVideoModes_CallbackBool; + CMOCK_glfwGetVideoModes_CALLBACK glfwGetVideoModes_CallbackFunctionPointer; + int glfwGetVideoModes_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetVideoModes_CallInstance; + char glfwGetVideoMode_IgnoreBool; + const GLFWvidmode* glfwGetVideoMode_FinalReturn; + char glfwGetVideoMode_CallbackBool; + CMOCK_glfwGetVideoMode_CALLBACK glfwGetVideoMode_CallbackFunctionPointer; + int glfwGetVideoMode_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetVideoMode_CallInstance; + char glfwSetGamma_IgnoreBool; + char glfwSetGamma_CallbackBool; + CMOCK_glfwSetGamma_CALLBACK glfwSetGamma_CallbackFunctionPointer; + int glfwSetGamma_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetGamma_CallInstance; + char glfwGetGammaRamp_IgnoreBool; + const GLFWgammaramp* glfwGetGammaRamp_FinalReturn; + char glfwGetGammaRamp_CallbackBool; + CMOCK_glfwGetGammaRamp_CALLBACK glfwGetGammaRamp_CallbackFunctionPointer; + int glfwGetGammaRamp_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetGammaRamp_CallInstance; + char glfwSetGammaRamp_IgnoreBool; + char glfwSetGammaRamp_CallbackBool; + CMOCK_glfwSetGammaRamp_CALLBACK glfwSetGammaRamp_CallbackFunctionPointer; + int glfwSetGammaRamp_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetGammaRamp_CallInstance; + char glfwDefaultWindowHints_IgnoreBool; + char glfwDefaultWindowHints_CallbackBool; + CMOCK_glfwDefaultWindowHints_CALLBACK glfwDefaultWindowHints_CallbackFunctionPointer; + int glfwDefaultWindowHints_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwDefaultWindowHints_CallInstance; + char glfwWindowHint_IgnoreBool; + char glfwWindowHint_CallbackBool; + CMOCK_glfwWindowHint_CALLBACK glfwWindowHint_CallbackFunctionPointer; + int glfwWindowHint_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwWindowHint_CallInstance; + char glfwWindowHintString_IgnoreBool; + char glfwWindowHintString_CallbackBool; + CMOCK_glfwWindowHintString_CALLBACK glfwWindowHintString_CallbackFunctionPointer; + int glfwWindowHintString_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwWindowHintString_CallInstance; + char glfwCreateWindow_IgnoreBool; + GLFWwindow* glfwCreateWindow_FinalReturn; + char glfwCreateWindow_CallbackBool; + CMOCK_glfwCreateWindow_CALLBACK glfwCreateWindow_CallbackFunctionPointer; + int glfwCreateWindow_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwCreateWindow_CallInstance; + char glfwDestroyWindow_IgnoreBool; + char glfwDestroyWindow_CallbackBool; + CMOCK_glfwDestroyWindow_CALLBACK glfwDestroyWindow_CallbackFunctionPointer; + int glfwDestroyWindow_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwDestroyWindow_CallInstance; + char glfwWindowShouldClose_IgnoreBool; + int glfwWindowShouldClose_FinalReturn; + char glfwWindowShouldClose_CallbackBool; + CMOCK_glfwWindowShouldClose_CALLBACK glfwWindowShouldClose_CallbackFunctionPointer; + int glfwWindowShouldClose_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwWindowShouldClose_CallInstance; + char glfwSetWindowShouldClose_IgnoreBool; + char glfwSetWindowShouldClose_CallbackBool; + CMOCK_glfwSetWindowShouldClose_CALLBACK glfwSetWindowShouldClose_CallbackFunctionPointer; + int glfwSetWindowShouldClose_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetWindowShouldClose_CallInstance; + char glfwSetWindowTitle_IgnoreBool; + char glfwSetWindowTitle_CallbackBool; + CMOCK_glfwSetWindowTitle_CALLBACK glfwSetWindowTitle_CallbackFunctionPointer; + int glfwSetWindowTitle_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetWindowTitle_CallInstance; + char glfwSetWindowIcon_IgnoreBool; + char glfwSetWindowIcon_CallbackBool; + CMOCK_glfwSetWindowIcon_CALLBACK glfwSetWindowIcon_CallbackFunctionPointer; + int glfwSetWindowIcon_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetWindowIcon_CallInstance; + char glfwGetWindowPos_IgnoreBool; + char glfwGetWindowPos_CallbackBool; + CMOCK_glfwGetWindowPos_CALLBACK glfwGetWindowPos_CallbackFunctionPointer; + int glfwGetWindowPos_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetWindowPos_CallInstance; + char glfwSetWindowPos_IgnoreBool; + char glfwSetWindowPos_CallbackBool; + CMOCK_glfwSetWindowPos_CALLBACK glfwSetWindowPos_CallbackFunctionPointer; + int glfwSetWindowPos_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetWindowPos_CallInstance; + char glfwGetWindowSize_IgnoreBool; + char glfwGetWindowSize_CallbackBool; + CMOCK_glfwGetWindowSize_CALLBACK glfwGetWindowSize_CallbackFunctionPointer; + int glfwGetWindowSize_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetWindowSize_CallInstance; + char glfwSetWindowSizeLimits_IgnoreBool; + char glfwSetWindowSizeLimits_CallbackBool; + CMOCK_glfwSetWindowSizeLimits_CALLBACK glfwSetWindowSizeLimits_CallbackFunctionPointer; + int glfwSetWindowSizeLimits_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetWindowSizeLimits_CallInstance; + char glfwSetWindowAspectRatio_IgnoreBool; + char glfwSetWindowAspectRatio_CallbackBool; + CMOCK_glfwSetWindowAspectRatio_CALLBACK glfwSetWindowAspectRatio_CallbackFunctionPointer; + int glfwSetWindowAspectRatio_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetWindowAspectRatio_CallInstance; + char glfwSetWindowSize_IgnoreBool; + char glfwSetWindowSize_CallbackBool; + CMOCK_glfwSetWindowSize_CALLBACK glfwSetWindowSize_CallbackFunctionPointer; + int glfwSetWindowSize_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetWindowSize_CallInstance; + char glfwGetFramebufferSize_IgnoreBool; + char glfwGetFramebufferSize_CallbackBool; + CMOCK_glfwGetFramebufferSize_CALLBACK glfwGetFramebufferSize_CallbackFunctionPointer; + int glfwGetFramebufferSize_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetFramebufferSize_CallInstance; + char glfwGetWindowFrameSize_IgnoreBool; + char glfwGetWindowFrameSize_CallbackBool; + CMOCK_glfwGetWindowFrameSize_CALLBACK glfwGetWindowFrameSize_CallbackFunctionPointer; + int glfwGetWindowFrameSize_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetWindowFrameSize_CallInstance; + char glfwGetWindowContentScale_IgnoreBool; + char glfwGetWindowContentScale_CallbackBool; + CMOCK_glfwGetWindowContentScale_CALLBACK glfwGetWindowContentScale_CallbackFunctionPointer; + int glfwGetWindowContentScale_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetWindowContentScale_CallInstance; + char glfwGetWindowOpacity_IgnoreBool; + float glfwGetWindowOpacity_FinalReturn; + char glfwGetWindowOpacity_CallbackBool; + CMOCK_glfwGetWindowOpacity_CALLBACK glfwGetWindowOpacity_CallbackFunctionPointer; + int glfwGetWindowOpacity_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetWindowOpacity_CallInstance; + char glfwSetWindowOpacity_IgnoreBool; + char glfwSetWindowOpacity_CallbackBool; + CMOCK_glfwSetWindowOpacity_CALLBACK glfwSetWindowOpacity_CallbackFunctionPointer; + int glfwSetWindowOpacity_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetWindowOpacity_CallInstance; + char glfwIconifyWindow_IgnoreBool; + char glfwIconifyWindow_CallbackBool; + CMOCK_glfwIconifyWindow_CALLBACK glfwIconifyWindow_CallbackFunctionPointer; + int glfwIconifyWindow_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwIconifyWindow_CallInstance; + char glfwRestoreWindow_IgnoreBool; + char glfwRestoreWindow_CallbackBool; + CMOCK_glfwRestoreWindow_CALLBACK glfwRestoreWindow_CallbackFunctionPointer; + int glfwRestoreWindow_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwRestoreWindow_CallInstance; + char glfwMaximizeWindow_IgnoreBool; + char glfwMaximizeWindow_CallbackBool; + CMOCK_glfwMaximizeWindow_CALLBACK glfwMaximizeWindow_CallbackFunctionPointer; + int glfwMaximizeWindow_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwMaximizeWindow_CallInstance; + char glfwShowWindow_IgnoreBool; + char glfwShowWindow_CallbackBool; + CMOCK_glfwShowWindow_CALLBACK glfwShowWindow_CallbackFunctionPointer; + int glfwShowWindow_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwShowWindow_CallInstance; + char glfwHideWindow_IgnoreBool; + char glfwHideWindow_CallbackBool; + CMOCK_glfwHideWindow_CALLBACK glfwHideWindow_CallbackFunctionPointer; + int glfwHideWindow_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwHideWindow_CallInstance; + char glfwFocusWindow_IgnoreBool; + char glfwFocusWindow_CallbackBool; + CMOCK_glfwFocusWindow_CALLBACK glfwFocusWindow_CallbackFunctionPointer; + int glfwFocusWindow_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwFocusWindow_CallInstance; + char glfwRequestWindowAttention_IgnoreBool; + char glfwRequestWindowAttention_CallbackBool; + CMOCK_glfwRequestWindowAttention_CALLBACK glfwRequestWindowAttention_CallbackFunctionPointer; + int glfwRequestWindowAttention_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwRequestWindowAttention_CallInstance; + char glfwGetWindowMonitor_IgnoreBool; + GLFWmonitor* glfwGetWindowMonitor_FinalReturn; + char glfwGetWindowMonitor_CallbackBool; + CMOCK_glfwGetWindowMonitor_CALLBACK glfwGetWindowMonitor_CallbackFunctionPointer; + int glfwGetWindowMonitor_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetWindowMonitor_CallInstance; + char glfwSetWindowMonitor_IgnoreBool; + char glfwSetWindowMonitor_CallbackBool; + CMOCK_glfwSetWindowMonitor_CALLBACK glfwSetWindowMonitor_CallbackFunctionPointer; + int glfwSetWindowMonitor_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetWindowMonitor_CallInstance; + char glfwGetWindowAttrib_IgnoreBool; + int glfwGetWindowAttrib_FinalReturn; + char glfwGetWindowAttrib_CallbackBool; + CMOCK_glfwGetWindowAttrib_CALLBACK glfwGetWindowAttrib_CallbackFunctionPointer; + int glfwGetWindowAttrib_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetWindowAttrib_CallInstance; + char glfwSetWindowAttrib_IgnoreBool; + char glfwSetWindowAttrib_CallbackBool; + CMOCK_glfwSetWindowAttrib_CALLBACK glfwSetWindowAttrib_CallbackFunctionPointer; + int glfwSetWindowAttrib_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetWindowAttrib_CallInstance; + char glfwSetWindowUserPointer_IgnoreBool; + char glfwSetWindowUserPointer_CallbackBool; + CMOCK_glfwSetWindowUserPointer_CALLBACK glfwSetWindowUserPointer_CallbackFunctionPointer; + int glfwSetWindowUserPointer_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetWindowUserPointer_CallInstance; + char glfwGetWindowUserPointer_IgnoreBool; + void* glfwGetWindowUserPointer_FinalReturn; + char glfwGetWindowUserPointer_CallbackBool; + CMOCK_glfwGetWindowUserPointer_CALLBACK glfwGetWindowUserPointer_CallbackFunctionPointer; + int glfwGetWindowUserPointer_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetWindowUserPointer_CallInstance; + char glfwSetWindowPosCallback_IgnoreBool; + GLFWwindowposfun glfwSetWindowPosCallback_FinalReturn; + char glfwSetWindowPosCallback_CallbackBool; + CMOCK_glfwSetWindowPosCallback_CALLBACK glfwSetWindowPosCallback_CallbackFunctionPointer; + int glfwSetWindowPosCallback_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetWindowPosCallback_CallInstance; + char glfwSetWindowSizeCallback_IgnoreBool; + GLFWwindowsizefun glfwSetWindowSizeCallback_FinalReturn; + char glfwSetWindowSizeCallback_CallbackBool; + CMOCK_glfwSetWindowSizeCallback_CALLBACK glfwSetWindowSizeCallback_CallbackFunctionPointer; + int glfwSetWindowSizeCallback_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetWindowSizeCallback_CallInstance; + char glfwSetWindowCloseCallback_IgnoreBool; + GLFWwindowclosefun glfwSetWindowCloseCallback_FinalReturn; + char glfwSetWindowCloseCallback_CallbackBool; + CMOCK_glfwSetWindowCloseCallback_CALLBACK glfwSetWindowCloseCallback_CallbackFunctionPointer; + int glfwSetWindowCloseCallback_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetWindowCloseCallback_CallInstance; + char glfwSetWindowRefreshCallback_IgnoreBool; + GLFWwindowrefreshfun glfwSetWindowRefreshCallback_FinalReturn; + char glfwSetWindowRefreshCallback_CallbackBool; + CMOCK_glfwSetWindowRefreshCallback_CALLBACK glfwSetWindowRefreshCallback_CallbackFunctionPointer; + int glfwSetWindowRefreshCallback_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetWindowRefreshCallback_CallInstance; + char glfwSetWindowFocusCallback_IgnoreBool; + GLFWwindowfocusfun glfwSetWindowFocusCallback_FinalReturn; + char glfwSetWindowFocusCallback_CallbackBool; + CMOCK_glfwSetWindowFocusCallback_CALLBACK glfwSetWindowFocusCallback_CallbackFunctionPointer; + int glfwSetWindowFocusCallback_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetWindowFocusCallback_CallInstance; + char glfwSetWindowIconifyCallback_IgnoreBool; + GLFWwindowiconifyfun glfwSetWindowIconifyCallback_FinalReturn; + char glfwSetWindowIconifyCallback_CallbackBool; + CMOCK_glfwSetWindowIconifyCallback_CALLBACK glfwSetWindowIconifyCallback_CallbackFunctionPointer; + int glfwSetWindowIconifyCallback_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetWindowIconifyCallback_CallInstance; + char glfwSetWindowMaximizeCallback_IgnoreBool; + GLFWwindowmaximizefun glfwSetWindowMaximizeCallback_FinalReturn; + char glfwSetWindowMaximizeCallback_CallbackBool; + CMOCK_glfwSetWindowMaximizeCallback_CALLBACK glfwSetWindowMaximizeCallback_CallbackFunctionPointer; + int glfwSetWindowMaximizeCallback_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetWindowMaximizeCallback_CallInstance; + char glfwSetFramebufferSizeCallback_IgnoreBool; + GLFWframebuffersizefun glfwSetFramebufferSizeCallback_FinalReturn; + char glfwSetFramebufferSizeCallback_CallbackBool; + CMOCK_glfwSetFramebufferSizeCallback_CALLBACK glfwSetFramebufferSizeCallback_CallbackFunctionPointer; + int glfwSetFramebufferSizeCallback_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetFramebufferSizeCallback_CallInstance; + char glfwSetWindowContentScaleCallback_IgnoreBool; + GLFWwindowcontentscalefun glfwSetWindowContentScaleCallback_FinalReturn; + char glfwSetWindowContentScaleCallback_CallbackBool; + CMOCK_glfwSetWindowContentScaleCallback_CALLBACK glfwSetWindowContentScaleCallback_CallbackFunctionPointer; + int glfwSetWindowContentScaleCallback_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetWindowContentScaleCallback_CallInstance; + char glfwPollEvents_IgnoreBool; + char glfwPollEvents_CallbackBool; + CMOCK_glfwPollEvents_CALLBACK glfwPollEvents_CallbackFunctionPointer; + int glfwPollEvents_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwPollEvents_CallInstance; + char glfwWaitEvents_IgnoreBool; + char glfwWaitEvents_CallbackBool; + CMOCK_glfwWaitEvents_CALLBACK glfwWaitEvents_CallbackFunctionPointer; + int glfwWaitEvents_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwWaitEvents_CallInstance; + char glfwWaitEventsTimeout_IgnoreBool; + char glfwWaitEventsTimeout_CallbackBool; + CMOCK_glfwWaitEventsTimeout_CALLBACK glfwWaitEventsTimeout_CallbackFunctionPointer; + int glfwWaitEventsTimeout_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwWaitEventsTimeout_CallInstance; + char glfwPostEmptyEvent_IgnoreBool; + char glfwPostEmptyEvent_CallbackBool; + CMOCK_glfwPostEmptyEvent_CALLBACK glfwPostEmptyEvent_CallbackFunctionPointer; + int glfwPostEmptyEvent_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwPostEmptyEvent_CallInstance; + char glfwGetInputMode_IgnoreBool; + int glfwGetInputMode_FinalReturn; + char glfwGetInputMode_CallbackBool; + CMOCK_glfwGetInputMode_CALLBACK glfwGetInputMode_CallbackFunctionPointer; + int glfwGetInputMode_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetInputMode_CallInstance; + char glfwSetInputMode_IgnoreBool; + char glfwSetInputMode_CallbackBool; + CMOCK_glfwSetInputMode_CALLBACK glfwSetInputMode_CallbackFunctionPointer; + int glfwSetInputMode_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetInputMode_CallInstance; + char glfwRawMouseMotionSupported_IgnoreBool; + int glfwRawMouseMotionSupported_FinalReturn; + char glfwRawMouseMotionSupported_CallbackBool; + CMOCK_glfwRawMouseMotionSupported_CALLBACK glfwRawMouseMotionSupported_CallbackFunctionPointer; + int glfwRawMouseMotionSupported_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwRawMouseMotionSupported_CallInstance; + char glfwGetKeyName_IgnoreBool; + const char* glfwGetKeyName_FinalReturn; + char glfwGetKeyName_CallbackBool; + CMOCK_glfwGetKeyName_CALLBACK glfwGetKeyName_CallbackFunctionPointer; + int glfwGetKeyName_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetKeyName_CallInstance; + char glfwGetKeyScancode_IgnoreBool; + int glfwGetKeyScancode_FinalReturn; + char glfwGetKeyScancode_CallbackBool; + CMOCK_glfwGetKeyScancode_CALLBACK glfwGetKeyScancode_CallbackFunctionPointer; + int glfwGetKeyScancode_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetKeyScancode_CallInstance; + char glfwGetKey_IgnoreBool; + int glfwGetKey_FinalReturn; + char glfwGetKey_CallbackBool; + CMOCK_glfwGetKey_CALLBACK glfwGetKey_CallbackFunctionPointer; + int glfwGetKey_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetKey_CallInstance; + char glfwGetMouseButton_IgnoreBool; + int glfwGetMouseButton_FinalReturn; + char glfwGetMouseButton_CallbackBool; + CMOCK_glfwGetMouseButton_CALLBACK glfwGetMouseButton_CallbackFunctionPointer; + int glfwGetMouseButton_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetMouseButton_CallInstance; + char glfwGetCursorPos_IgnoreBool; + char glfwGetCursorPos_CallbackBool; + CMOCK_glfwGetCursorPos_CALLBACK glfwGetCursorPos_CallbackFunctionPointer; + int glfwGetCursorPos_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetCursorPos_CallInstance; + char glfwSetCursorPos_IgnoreBool; + char glfwSetCursorPos_CallbackBool; + CMOCK_glfwSetCursorPos_CALLBACK glfwSetCursorPos_CallbackFunctionPointer; + int glfwSetCursorPos_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetCursorPos_CallInstance; + char glfwCreateCursor_IgnoreBool; + GLFWcursor* glfwCreateCursor_FinalReturn; + char glfwCreateCursor_CallbackBool; + CMOCK_glfwCreateCursor_CALLBACK glfwCreateCursor_CallbackFunctionPointer; + int glfwCreateCursor_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwCreateCursor_CallInstance; + char glfwCreateStandardCursor_IgnoreBool; + GLFWcursor* glfwCreateStandardCursor_FinalReturn; + char glfwCreateStandardCursor_CallbackBool; + CMOCK_glfwCreateStandardCursor_CALLBACK glfwCreateStandardCursor_CallbackFunctionPointer; + int glfwCreateStandardCursor_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwCreateStandardCursor_CallInstance; + char glfwDestroyCursor_IgnoreBool; + char glfwDestroyCursor_CallbackBool; + CMOCK_glfwDestroyCursor_CALLBACK glfwDestroyCursor_CallbackFunctionPointer; + int glfwDestroyCursor_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwDestroyCursor_CallInstance; + char glfwSetCursor_IgnoreBool; + char glfwSetCursor_CallbackBool; + CMOCK_glfwSetCursor_CALLBACK glfwSetCursor_CallbackFunctionPointer; + int glfwSetCursor_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetCursor_CallInstance; + char glfwSetKeyCallback_IgnoreBool; + GLFWkeyfun glfwSetKeyCallback_FinalReturn; + char glfwSetKeyCallback_CallbackBool; + CMOCK_glfwSetKeyCallback_CALLBACK glfwSetKeyCallback_CallbackFunctionPointer; + int glfwSetKeyCallback_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetKeyCallback_CallInstance; + char glfwSetCharCallback_IgnoreBool; + GLFWcharfun glfwSetCharCallback_FinalReturn; + char glfwSetCharCallback_CallbackBool; + CMOCK_glfwSetCharCallback_CALLBACK glfwSetCharCallback_CallbackFunctionPointer; + int glfwSetCharCallback_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetCharCallback_CallInstance; + char glfwSetCharModsCallback_IgnoreBool; + GLFWcharmodsfun glfwSetCharModsCallback_FinalReturn; + char glfwSetCharModsCallback_CallbackBool; + CMOCK_glfwSetCharModsCallback_CALLBACK glfwSetCharModsCallback_CallbackFunctionPointer; + int glfwSetCharModsCallback_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetCharModsCallback_CallInstance; + char glfwSetMouseButtonCallback_IgnoreBool; + GLFWmousebuttonfun glfwSetMouseButtonCallback_FinalReturn; + char glfwSetMouseButtonCallback_CallbackBool; + CMOCK_glfwSetMouseButtonCallback_CALLBACK glfwSetMouseButtonCallback_CallbackFunctionPointer; + int glfwSetMouseButtonCallback_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetMouseButtonCallback_CallInstance; + char glfwSetCursorPosCallback_IgnoreBool; + GLFWcursorposfun glfwSetCursorPosCallback_FinalReturn; + char glfwSetCursorPosCallback_CallbackBool; + CMOCK_glfwSetCursorPosCallback_CALLBACK glfwSetCursorPosCallback_CallbackFunctionPointer; + int glfwSetCursorPosCallback_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetCursorPosCallback_CallInstance; + char glfwSetCursorEnterCallback_IgnoreBool; + GLFWcursorenterfun glfwSetCursorEnterCallback_FinalReturn; + char glfwSetCursorEnterCallback_CallbackBool; + CMOCK_glfwSetCursorEnterCallback_CALLBACK glfwSetCursorEnterCallback_CallbackFunctionPointer; + int glfwSetCursorEnterCallback_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetCursorEnterCallback_CallInstance; + char glfwSetScrollCallback_IgnoreBool; + GLFWscrollfun glfwSetScrollCallback_FinalReturn; + char glfwSetScrollCallback_CallbackBool; + CMOCK_glfwSetScrollCallback_CALLBACK glfwSetScrollCallback_CallbackFunctionPointer; + int glfwSetScrollCallback_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetScrollCallback_CallInstance; + char glfwSetDropCallback_IgnoreBool; + GLFWdropfun glfwSetDropCallback_FinalReturn; + char glfwSetDropCallback_CallbackBool; + CMOCK_glfwSetDropCallback_CALLBACK glfwSetDropCallback_CallbackFunctionPointer; + int glfwSetDropCallback_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetDropCallback_CallInstance; + char glfwJoystickPresent_IgnoreBool; + int glfwJoystickPresent_FinalReturn; + char glfwJoystickPresent_CallbackBool; + CMOCK_glfwJoystickPresent_CALLBACK glfwJoystickPresent_CallbackFunctionPointer; + int glfwJoystickPresent_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwJoystickPresent_CallInstance; + char glfwGetJoystickAxes_IgnoreBool; + const float* glfwGetJoystickAxes_FinalReturn; + char glfwGetJoystickAxes_CallbackBool; + CMOCK_glfwGetJoystickAxes_CALLBACK glfwGetJoystickAxes_CallbackFunctionPointer; + int glfwGetJoystickAxes_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetJoystickAxes_CallInstance; + char glfwGetJoystickButtons_IgnoreBool; + const unsigned char* glfwGetJoystickButtons_FinalReturn; + char glfwGetJoystickButtons_CallbackBool; + CMOCK_glfwGetJoystickButtons_CALLBACK glfwGetJoystickButtons_CallbackFunctionPointer; + int glfwGetJoystickButtons_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetJoystickButtons_CallInstance; + char glfwGetJoystickHats_IgnoreBool; + const unsigned char* glfwGetJoystickHats_FinalReturn; + char glfwGetJoystickHats_CallbackBool; + CMOCK_glfwGetJoystickHats_CALLBACK glfwGetJoystickHats_CallbackFunctionPointer; + int glfwGetJoystickHats_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetJoystickHats_CallInstance; + char glfwGetJoystickName_IgnoreBool; + const char* glfwGetJoystickName_FinalReturn; + char glfwGetJoystickName_CallbackBool; + CMOCK_glfwGetJoystickName_CALLBACK glfwGetJoystickName_CallbackFunctionPointer; + int glfwGetJoystickName_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetJoystickName_CallInstance; + char glfwGetJoystickGUID_IgnoreBool; + const char* glfwGetJoystickGUID_FinalReturn; + char glfwGetJoystickGUID_CallbackBool; + CMOCK_glfwGetJoystickGUID_CALLBACK glfwGetJoystickGUID_CallbackFunctionPointer; + int glfwGetJoystickGUID_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetJoystickGUID_CallInstance; + char glfwSetJoystickUserPointer_IgnoreBool; + char glfwSetJoystickUserPointer_CallbackBool; + CMOCK_glfwSetJoystickUserPointer_CALLBACK glfwSetJoystickUserPointer_CallbackFunctionPointer; + int glfwSetJoystickUserPointer_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetJoystickUserPointer_CallInstance; + char glfwGetJoystickUserPointer_IgnoreBool; + void* glfwGetJoystickUserPointer_FinalReturn; + char glfwGetJoystickUserPointer_CallbackBool; + CMOCK_glfwGetJoystickUserPointer_CALLBACK glfwGetJoystickUserPointer_CallbackFunctionPointer; + int glfwGetJoystickUserPointer_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetJoystickUserPointer_CallInstance; + char glfwJoystickIsGamepad_IgnoreBool; + int glfwJoystickIsGamepad_FinalReturn; + char glfwJoystickIsGamepad_CallbackBool; + CMOCK_glfwJoystickIsGamepad_CALLBACK glfwJoystickIsGamepad_CallbackFunctionPointer; + int glfwJoystickIsGamepad_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwJoystickIsGamepad_CallInstance; + char glfwSetJoystickCallback_IgnoreBool; + GLFWjoystickfun glfwSetJoystickCallback_FinalReturn; + char glfwSetJoystickCallback_CallbackBool; + CMOCK_glfwSetJoystickCallback_CALLBACK glfwSetJoystickCallback_CallbackFunctionPointer; + int glfwSetJoystickCallback_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetJoystickCallback_CallInstance; + char glfwUpdateGamepadMappings_IgnoreBool; + int glfwUpdateGamepadMappings_FinalReturn; + char glfwUpdateGamepadMappings_CallbackBool; + CMOCK_glfwUpdateGamepadMappings_CALLBACK glfwUpdateGamepadMappings_CallbackFunctionPointer; + int glfwUpdateGamepadMappings_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwUpdateGamepadMappings_CallInstance; + char glfwGetGamepadName_IgnoreBool; + const char* glfwGetGamepadName_FinalReturn; + char glfwGetGamepadName_CallbackBool; + CMOCK_glfwGetGamepadName_CALLBACK glfwGetGamepadName_CallbackFunctionPointer; + int glfwGetGamepadName_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetGamepadName_CallInstance; + char glfwGetGamepadState_IgnoreBool; + int glfwGetGamepadState_FinalReturn; + char glfwGetGamepadState_CallbackBool; + CMOCK_glfwGetGamepadState_CALLBACK glfwGetGamepadState_CallbackFunctionPointer; + int glfwGetGamepadState_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetGamepadState_CallInstance; + char glfwSetClipboardString_IgnoreBool; + char glfwSetClipboardString_CallbackBool; + CMOCK_glfwSetClipboardString_CALLBACK glfwSetClipboardString_CallbackFunctionPointer; + int glfwSetClipboardString_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetClipboardString_CallInstance; + char glfwGetClipboardString_IgnoreBool; + const char* glfwGetClipboardString_FinalReturn; + char glfwGetClipboardString_CallbackBool; + CMOCK_glfwGetClipboardString_CALLBACK glfwGetClipboardString_CallbackFunctionPointer; + int glfwGetClipboardString_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetClipboardString_CallInstance; + char glfwGetTime_IgnoreBool; + double glfwGetTime_FinalReturn; + char glfwGetTime_CallbackBool; + CMOCK_glfwGetTime_CALLBACK glfwGetTime_CallbackFunctionPointer; + int glfwGetTime_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetTime_CallInstance; + char glfwSetTime_IgnoreBool; + char glfwSetTime_CallbackBool; + CMOCK_glfwSetTime_CALLBACK glfwSetTime_CallbackFunctionPointer; + int glfwSetTime_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSetTime_CallInstance; + char glfwGetTimerValue_IgnoreBool; + uint64_t glfwGetTimerValue_FinalReturn; + char glfwGetTimerValue_CallbackBool; + CMOCK_glfwGetTimerValue_CALLBACK glfwGetTimerValue_CallbackFunctionPointer; + int glfwGetTimerValue_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetTimerValue_CallInstance; + char glfwGetTimerFrequency_IgnoreBool; + uint64_t glfwGetTimerFrequency_FinalReturn; + char glfwGetTimerFrequency_CallbackBool; + CMOCK_glfwGetTimerFrequency_CALLBACK glfwGetTimerFrequency_CallbackFunctionPointer; + int glfwGetTimerFrequency_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetTimerFrequency_CallInstance; + char glfwMakeContextCurrent_IgnoreBool; + char glfwMakeContextCurrent_CallbackBool; + CMOCK_glfwMakeContextCurrent_CALLBACK glfwMakeContextCurrent_CallbackFunctionPointer; + int glfwMakeContextCurrent_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwMakeContextCurrent_CallInstance; + char glfwGetCurrentContext_IgnoreBool; + GLFWwindow* glfwGetCurrentContext_FinalReturn; + char glfwGetCurrentContext_CallbackBool; + CMOCK_glfwGetCurrentContext_CALLBACK glfwGetCurrentContext_CallbackFunctionPointer; + int glfwGetCurrentContext_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetCurrentContext_CallInstance; + char glfwSwapBuffers_IgnoreBool; + char glfwSwapBuffers_CallbackBool; + CMOCK_glfwSwapBuffers_CALLBACK glfwSwapBuffers_CallbackFunctionPointer; + int glfwSwapBuffers_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSwapBuffers_CallInstance; + char glfwSwapInterval_IgnoreBool; + char glfwSwapInterval_CallbackBool; + CMOCK_glfwSwapInterval_CALLBACK glfwSwapInterval_CallbackFunctionPointer; + int glfwSwapInterval_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwSwapInterval_CallInstance; + char glfwExtensionSupported_IgnoreBool; + int glfwExtensionSupported_FinalReturn; + char glfwExtensionSupported_CallbackBool; + CMOCK_glfwExtensionSupported_CALLBACK glfwExtensionSupported_CallbackFunctionPointer; + int glfwExtensionSupported_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwExtensionSupported_CallInstance; + char glfwGetProcAddress_IgnoreBool; + GLFWglproc glfwGetProcAddress_FinalReturn; + char glfwGetProcAddress_CallbackBool; + CMOCK_glfwGetProcAddress_CALLBACK glfwGetProcAddress_CallbackFunctionPointer; + int glfwGetProcAddress_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetProcAddress_CallInstance; + char glfwVulkanSupported_IgnoreBool; + int glfwVulkanSupported_FinalReturn; + char glfwVulkanSupported_CallbackBool; + CMOCK_glfwVulkanSupported_CALLBACK glfwVulkanSupported_CallbackFunctionPointer; + int glfwVulkanSupported_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwVulkanSupported_CallInstance; + char glfwGetRequiredInstanceExtensions_IgnoreBool; + const char** glfwGetRequiredInstanceExtensions_FinalReturn; + char glfwGetRequiredInstanceExtensions_CallbackBool; + CMOCK_glfwGetRequiredInstanceExtensions_CALLBACK glfwGetRequiredInstanceExtensions_CallbackFunctionPointer; + int glfwGetRequiredInstanceExtensions_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetRequiredInstanceExtensions_CallInstance; + char glfwGetInstanceProcAddress_IgnoreBool; + GLFWvkproc glfwGetInstanceProcAddress_FinalReturn; + char glfwGetInstanceProcAddress_CallbackBool; + CMOCK_glfwGetInstanceProcAddress_CALLBACK glfwGetInstanceProcAddress_CallbackFunctionPointer; + int glfwGetInstanceProcAddress_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetInstanceProcAddress_CallInstance; + char glfwGetPhysicalDevicePresentationSupport_IgnoreBool; + int glfwGetPhysicalDevicePresentationSupport_FinalReturn; + char glfwGetPhysicalDevicePresentationSupport_CallbackBool; + CMOCK_glfwGetPhysicalDevicePresentationSupport_CALLBACK glfwGetPhysicalDevicePresentationSupport_CallbackFunctionPointer; + int glfwGetPhysicalDevicePresentationSupport_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwGetPhysicalDevicePresentationSupport_CallInstance; + char glfwCreateWindowSurface_IgnoreBool; + VkResult glfwCreateWindowSurface_FinalReturn; + char glfwCreateWindowSurface_CallbackBool; + CMOCK_glfwCreateWindowSurface_CALLBACK glfwCreateWindowSurface_CallbackFunctionPointer; + int glfwCreateWindowSurface_CallbackCalls; + CMOCK_MEM_INDEX_TYPE glfwCreateWindowSurface_CallInstance; +} Mock; + +extern jmp_buf AbortFrame; + +void Mockglfw3_Verify(void) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_MEM_INDEX_TYPE call_instance; + call_instance = Mock.glfwInit_CallInstance; + if (Mock.glfwInit_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwInit); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwInit_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwTerminate_CallInstance; + if (Mock.glfwTerminate_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwTerminate); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwTerminate_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwInitHint_CallInstance; + if (Mock.glfwInitHint_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwInitHint); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwInitHint_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetVersion_CallInstance; + if (Mock.glfwGetVersion_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetVersion); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetVersion_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetVersionString_CallInstance; + if (Mock.glfwGetVersionString_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetVersionString); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetVersionString_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetError_CallInstance; + if (Mock.glfwGetError_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetError); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetError_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetErrorCallback_CallInstance; + if (Mock.glfwSetErrorCallback_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetErrorCallback); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetErrorCallback_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetMonitors_CallInstance; + if (Mock.glfwGetMonitors_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetMonitors); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetMonitors_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetPrimaryMonitor_CallInstance; + if (Mock.glfwGetPrimaryMonitor_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetPrimaryMonitor); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetPrimaryMonitor_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetMonitorPos_CallInstance; + if (Mock.glfwGetMonitorPos_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetMonitorPos); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetMonitorPos_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetMonitorWorkarea_CallInstance; + if (Mock.glfwGetMonitorWorkarea_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetMonitorWorkarea); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetMonitorWorkarea_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetMonitorPhysicalSize_CallInstance; + if (Mock.glfwGetMonitorPhysicalSize_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetMonitorPhysicalSize); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetMonitorPhysicalSize_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetMonitorContentScale_CallInstance; + if (Mock.glfwGetMonitorContentScale_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetMonitorContentScale); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetMonitorContentScale_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetMonitorName_CallInstance; + if (Mock.glfwGetMonitorName_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetMonitorName); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetMonitorName_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetMonitorUserPointer_CallInstance; + if (Mock.glfwSetMonitorUserPointer_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetMonitorUserPointer); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetMonitorUserPointer_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetMonitorUserPointer_CallInstance; + if (Mock.glfwGetMonitorUserPointer_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetMonitorUserPointer); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetMonitorUserPointer_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetMonitorCallback_CallInstance; + if (Mock.glfwSetMonitorCallback_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetMonitorCallback); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetMonitorCallback_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetVideoModes_CallInstance; + if (Mock.glfwGetVideoModes_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetVideoModes); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetVideoModes_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetVideoMode_CallInstance; + if (Mock.glfwGetVideoMode_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetVideoMode); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetVideoMode_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetGamma_CallInstance; + if (Mock.glfwSetGamma_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetGamma); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetGamma_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetGammaRamp_CallInstance; + if (Mock.glfwGetGammaRamp_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetGammaRamp); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetGammaRamp_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetGammaRamp_CallInstance; + if (Mock.glfwSetGammaRamp_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetGammaRamp); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetGammaRamp_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwDefaultWindowHints_CallInstance; + if (Mock.glfwDefaultWindowHints_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwDefaultWindowHints); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwDefaultWindowHints_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwWindowHint_CallInstance; + if (Mock.glfwWindowHint_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwWindowHint); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwWindowHint_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwWindowHintString_CallInstance; + if (Mock.glfwWindowHintString_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwWindowHintString); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwWindowHintString_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwCreateWindow_CallInstance; + if (Mock.glfwCreateWindow_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwCreateWindow); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwCreateWindow_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwDestroyWindow_CallInstance; + if (Mock.glfwDestroyWindow_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwDestroyWindow); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwDestroyWindow_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwWindowShouldClose_CallInstance; + if (Mock.glfwWindowShouldClose_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwWindowShouldClose); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwWindowShouldClose_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetWindowShouldClose_CallInstance; + if (Mock.glfwSetWindowShouldClose_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetWindowShouldClose); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetWindowShouldClose_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetWindowTitle_CallInstance; + if (Mock.glfwSetWindowTitle_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetWindowTitle); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetWindowTitle_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetWindowIcon_CallInstance; + if (Mock.glfwSetWindowIcon_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetWindowIcon); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetWindowIcon_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetWindowPos_CallInstance; + if (Mock.glfwGetWindowPos_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetWindowPos); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetWindowPos_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetWindowPos_CallInstance; + if (Mock.glfwSetWindowPos_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetWindowPos); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetWindowPos_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetWindowSize_CallInstance; + if (Mock.glfwGetWindowSize_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetWindowSize); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetWindowSize_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetWindowSizeLimits_CallInstance; + if (Mock.glfwSetWindowSizeLimits_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetWindowSizeLimits); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetWindowSizeLimits_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetWindowAspectRatio_CallInstance; + if (Mock.glfwSetWindowAspectRatio_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetWindowAspectRatio); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetWindowAspectRatio_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetWindowSize_CallInstance; + if (Mock.glfwSetWindowSize_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetWindowSize); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetWindowSize_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetFramebufferSize_CallInstance; + if (Mock.glfwGetFramebufferSize_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetFramebufferSize); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetFramebufferSize_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetWindowFrameSize_CallInstance; + if (Mock.glfwGetWindowFrameSize_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetWindowFrameSize); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetWindowFrameSize_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetWindowContentScale_CallInstance; + if (Mock.glfwGetWindowContentScale_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetWindowContentScale); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetWindowContentScale_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetWindowOpacity_CallInstance; + if (Mock.glfwGetWindowOpacity_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetWindowOpacity); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetWindowOpacity_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetWindowOpacity_CallInstance; + if (Mock.glfwSetWindowOpacity_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetWindowOpacity); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetWindowOpacity_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwIconifyWindow_CallInstance; + if (Mock.glfwIconifyWindow_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwIconifyWindow); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwIconifyWindow_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwRestoreWindow_CallInstance; + if (Mock.glfwRestoreWindow_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwRestoreWindow); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwRestoreWindow_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwMaximizeWindow_CallInstance; + if (Mock.glfwMaximizeWindow_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwMaximizeWindow); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwMaximizeWindow_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwShowWindow_CallInstance; + if (Mock.glfwShowWindow_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwShowWindow); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwShowWindow_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwHideWindow_CallInstance; + if (Mock.glfwHideWindow_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwHideWindow); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwHideWindow_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwFocusWindow_CallInstance; + if (Mock.glfwFocusWindow_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwFocusWindow); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwFocusWindow_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwRequestWindowAttention_CallInstance; + if (Mock.glfwRequestWindowAttention_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwRequestWindowAttention); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwRequestWindowAttention_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetWindowMonitor_CallInstance; + if (Mock.glfwGetWindowMonitor_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetWindowMonitor); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetWindowMonitor_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetWindowMonitor_CallInstance; + if (Mock.glfwSetWindowMonitor_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetWindowMonitor); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetWindowMonitor_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetWindowAttrib_CallInstance; + if (Mock.glfwGetWindowAttrib_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetWindowAttrib); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetWindowAttrib_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetWindowAttrib_CallInstance; + if (Mock.glfwSetWindowAttrib_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetWindowAttrib); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetWindowAttrib_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetWindowUserPointer_CallInstance; + if (Mock.glfwSetWindowUserPointer_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetWindowUserPointer); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetWindowUserPointer_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetWindowUserPointer_CallInstance; + if (Mock.glfwGetWindowUserPointer_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetWindowUserPointer); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetWindowUserPointer_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetWindowPosCallback_CallInstance; + if (Mock.glfwSetWindowPosCallback_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetWindowPosCallback); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetWindowPosCallback_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetWindowSizeCallback_CallInstance; + if (Mock.glfwSetWindowSizeCallback_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetWindowSizeCallback); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetWindowSizeCallback_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetWindowCloseCallback_CallInstance; + if (Mock.glfwSetWindowCloseCallback_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetWindowCloseCallback); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetWindowCloseCallback_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetWindowRefreshCallback_CallInstance; + if (Mock.glfwSetWindowRefreshCallback_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetWindowRefreshCallback); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetWindowRefreshCallback_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetWindowFocusCallback_CallInstance; + if (Mock.glfwSetWindowFocusCallback_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetWindowFocusCallback); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetWindowFocusCallback_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetWindowIconifyCallback_CallInstance; + if (Mock.glfwSetWindowIconifyCallback_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetWindowIconifyCallback); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetWindowIconifyCallback_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetWindowMaximizeCallback_CallInstance; + if (Mock.glfwSetWindowMaximizeCallback_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetWindowMaximizeCallback); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetWindowMaximizeCallback_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetFramebufferSizeCallback_CallInstance; + if (Mock.glfwSetFramebufferSizeCallback_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetFramebufferSizeCallback); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetFramebufferSizeCallback_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetWindowContentScaleCallback_CallInstance; + if (Mock.glfwSetWindowContentScaleCallback_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetWindowContentScaleCallback); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetWindowContentScaleCallback_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwPollEvents_CallInstance; + if (Mock.glfwPollEvents_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwPollEvents); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwPollEvents_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwWaitEvents_CallInstance; + if (Mock.glfwWaitEvents_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwWaitEvents); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwWaitEvents_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwWaitEventsTimeout_CallInstance; + if (Mock.glfwWaitEventsTimeout_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwWaitEventsTimeout); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwWaitEventsTimeout_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwPostEmptyEvent_CallInstance; + if (Mock.glfwPostEmptyEvent_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwPostEmptyEvent); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwPostEmptyEvent_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetInputMode_CallInstance; + if (Mock.glfwGetInputMode_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetInputMode); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetInputMode_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetInputMode_CallInstance; + if (Mock.glfwSetInputMode_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetInputMode); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetInputMode_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwRawMouseMotionSupported_CallInstance; + if (Mock.glfwRawMouseMotionSupported_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwRawMouseMotionSupported); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwRawMouseMotionSupported_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetKeyName_CallInstance; + if (Mock.glfwGetKeyName_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetKeyName); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetKeyName_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetKeyScancode_CallInstance; + if (Mock.glfwGetKeyScancode_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetKeyScancode); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetKeyScancode_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetKey_CallInstance; + if (Mock.glfwGetKey_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetKey); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetKey_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetMouseButton_CallInstance; + if (Mock.glfwGetMouseButton_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetMouseButton); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetMouseButton_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetCursorPos_CallInstance; + if (Mock.glfwGetCursorPos_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetCursorPos); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetCursorPos_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetCursorPos_CallInstance; + if (Mock.glfwSetCursorPos_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetCursorPos); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetCursorPos_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwCreateCursor_CallInstance; + if (Mock.glfwCreateCursor_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwCreateCursor); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwCreateCursor_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwCreateStandardCursor_CallInstance; + if (Mock.glfwCreateStandardCursor_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwCreateStandardCursor); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwCreateStandardCursor_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwDestroyCursor_CallInstance; + if (Mock.glfwDestroyCursor_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwDestroyCursor); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwDestroyCursor_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetCursor_CallInstance; + if (Mock.glfwSetCursor_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetCursor); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetCursor_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetKeyCallback_CallInstance; + if (Mock.glfwSetKeyCallback_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetKeyCallback); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetKeyCallback_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetCharCallback_CallInstance; + if (Mock.glfwSetCharCallback_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetCharCallback); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetCharCallback_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetCharModsCallback_CallInstance; + if (Mock.glfwSetCharModsCallback_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetCharModsCallback); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetCharModsCallback_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetMouseButtonCallback_CallInstance; + if (Mock.glfwSetMouseButtonCallback_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetMouseButtonCallback); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetMouseButtonCallback_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetCursorPosCallback_CallInstance; + if (Mock.glfwSetCursorPosCallback_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetCursorPosCallback); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetCursorPosCallback_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetCursorEnterCallback_CallInstance; + if (Mock.glfwSetCursorEnterCallback_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetCursorEnterCallback); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetCursorEnterCallback_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetScrollCallback_CallInstance; + if (Mock.glfwSetScrollCallback_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetScrollCallback); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetScrollCallback_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetDropCallback_CallInstance; + if (Mock.glfwSetDropCallback_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetDropCallback); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetDropCallback_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwJoystickPresent_CallInstance; + if (Mock.glfwJoystickPresent_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwJoystickPresent); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwJoystickPresent_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetJoystickAxes_CallInstance; + if (Mock.glfwGetJoystickAxes_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetJoystickAxes); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetJoystickAxes_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetJoystickButtons_CallInstance; + if (Mock.glfwGetJoystickButtons_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetJoystickButtons); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetJoystickButtons_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetJoystickHats_CallInstance; + if (Mock.glfwGetJoystickHats_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetJoystickHats); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetJoystickHats_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetJoystickName_CallInstance; + if (Mock.glfwGetJoystickName_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetJoystickName); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetJoystickName_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetJoystickGUID_CallInstance; + if (Mock.glfwGetJoystickGUID_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetJoystickGUID); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetJoystickGUID_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetJoystickUserPointer_CallInstance; + if (Mock.glfwSetJoystickUserPointer_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetJoystickUserPointer); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetJoystickUserPointer_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetJoystickUserPointer_CallInstance; + if (Mock.glfwGetJoystickUserPointer_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetJoystickUserPointer); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetJoystickUserPointer_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwJoystickIsGamepad_CallInstance; + if (Mock.glfwJoystickIsGamepad_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwJoystickIsGamepad); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwJoystickIsGamepad_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetJoystickCallback_CallInstance; + if (Mock.glfwSetJoystickCallback_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetJoystickCallback); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetJoystickCallback_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwUpdateGamepadMappings_CallInstance; + if (Mock.glfwUpdateGamepadMappings_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwUpdateGamepadMappings); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwUpdateGamepadMappings_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetGamepadName_CallInstance; + if (Mock.glfwGetGamepadName_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetGamepadName); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetGamepadName_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetGamepadState_CallInstance; + if (Mock.glfwGetGamepadState_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetGamepadState); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetGamepadState_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetClipboardString_CallInstance; + if (Mock.glfwSetClipboardString_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetClipboardString); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetClipboardString_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetClipboardString_CallInstance; + if (Mock.glfwGetClipboardString_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetClipboardString); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetClipboardString_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetTime_CallInstance; + if (Mock.glfwGetTime_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetTime); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetTime_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSetTime_CallInstance; + if (Mock.glfwSetTime_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSetTime); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSetTime_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetTimerValue_CallInstance; + if (Mock.glfwGetTimerValue_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetTimerValue); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetTimerValue_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetTimerFrequency_CallInstance; + if (Mock.glfwGetTimerFrequency_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetTimerFrequency); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetTimerFrequency_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwMakeContextCurrent_CallInstance; + if (Mock.glfwMakeContextCurrent_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwMakeContextCurrent); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwMakeContextCurrent_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetCurrentContext_CallInstance; + if (Mock.glfwGetCurrentContext_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetCurrentContext); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetCurrentContext_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSwapBuffers_CallInstance; + if (Mock.glfwSwapBuffers_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSwapBuffers); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSwapBuffers_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwSwapInterval_CallInstance; + if (Mock.glfwSwapInterval_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwSwapInterval); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwSwapInterval_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwExtensionSupported_CallInstance; + if (Mock.glfwExtensionSupported_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwExtensionSupported); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwExtensionSupported_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetProcAddress_CallInstance; + if (Mock.glfwGetProcAddress_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetProcAddress); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetProcAddress_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwVulkanSupported_CallInstance; + if (Mock.glfwVulkanSupported_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwVulkanSupported); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwVulkanSupported_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetRequiredInstanceExtensions_CallInstance; + if (Mock.glfwGetRequiredInstanceExtensions_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetRequiredInstanceExtensions); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetRequiredInstanceExtensions_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetInstanceProcAddress_CallInstance; + if (Mock.glfwGetInstanceProcAddress_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetInstanceProcAddress); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetInstanceProcAddress_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwGetPhysicalDevicePresentationSupport_CallInstance; + if (Mock.glfwGetPhysicalDevicePresentationSupport_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwGetPhysicalDevicePresentationSupport); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwGetPhysicalDevicePresentationSupport_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.glfwCreateWindowSurface_CallInstance; + if (Mock.glfwCreateWindowSurface_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_glfwCreateWindowSurface); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.glfwCreateWindowSurface_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } +} + +void Mockglfw3_Init(void) +{ + Mockglfw3_Destroy(); +} + +void Mockglfw3_Destroy(void) +{ + CMock_Guts_MemFreeAll(); + memset(&Mock, 0, sizeof(Mock)); +} + +int glfwInit(void) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwInit_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwInit); + cmock_call_instance = (CMOCK_glfwInit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwInit_CallInstance); + Mock.glfwInit_CallInstance = CMock_Guts_MemNext(Mock.glfwInit_CallInstance); + if (Mock.glfwInit_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwInit_FinalReturn; + Mock.glfwInit_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwInit_CallbackBool && + Mock.glfwInit_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.glfwInit_CallbackFunctionPointer(Mock.glfwInit_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (Mock.glfwInit_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwInit_CallbackFunctionPointer(Mock.glfwInit_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void glfwInit_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwInit_CALL_INSTANCE)); + CMOCK_glfwInit_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwInit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwInit_CallInstance = CMock_Guts_MemChain(Mock.glfwInit_CallInstance, cmock_guts_index); + Mock.glfwInit_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwInit_IgnoreBool = (char)1; +} + +void glfwInit_CMockStopIgnore(void) +{ + if(Mock.glfwInit_IgnoreBool) + Mock.glfwInit_CallInstance = CMock_Guts_MemNext(Mock.glfwInit_CallInstance); + Mock.glfwInit_IgnoreBool = (char)0; +} + +void glfwInit_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwInit_CALL_INSTANCE)); + CMOCK_glfwInit_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwInit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwInit_CallInstance = CMock_Guts_MemChain(Mock.glfwInit_CallInstance, cmock_guts_index); + Mock.glfwInit_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwInit_AddCallback(CMOCK_glfwInit_CALLBACK Callback) +{ + Mock.glfwInit_IgnoreBool = (char)0; + Mock.glfwInit_CallbackBool = (char)1; + Mock.glfwInit_CallbackFunctionPointer = Callback; +} + +void glfwInit_Stub(CMOCK_glfwInit_CALLBACK Callback) +{ + Mock.glfwInit_IgnoreBool = (char)0; + Mock.glfwInit_CallbackBool = (char)0; + Mock.glfwInit_CallbackFunctionPointer = Callback; +} + +void glfwTerminate(void) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwTerminate_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwTerminate); + cmock_call_instance = (CMOCK_glfwTerminate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwTerminate_CallInstance); + Mock.glfwTerminate_CallInstance = CMock_Guts_MemNext(Mock.glfwTerminate_CallInstance); + if (Mock.glfwTerminate_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwTerminate_CallbackBool && + Mock.glfwTerminate_CallbackFunctionPointer != NULL) + { + Mock.glfwTerminate_CallbackFunctionPointer(Mock.glfwTerminate_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (Mock.glfwTerminate_CallbackFunctionPointer != NULL) + { + Mock.glfwTerminate_CallbackFunctionPointer(Mock.glfwTerminate_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void glfwTerminate_CMockIgnore(void) +{ + Mock.glfwTerminate_IgnoreBool = (char)1; +} + +void glfwTerminate_CMockStopIgnore(void) +{ + Mock.glfwTerminate_IgnoreBool = (char)0; +} + +void glfwTerminate_CMockExpect(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwTerminate_CALL_INSTANCE)); + CMOCK_glfwTerminate_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwTerminate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwTerminate_CallInstance = CMock_Guts_MemChain(Mock.glfwTerminate_CallInstance, cmock_guts_index); + Mock.glfwTerminate_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; +} + +void glfwTerminate_AddCallback(CMOCK_glfwTerminate_CALLBACK Callback) +{ + Mock.glfwTerminate_IgnoreBool = (char)0; + Mock.glfwTerminate_CallbackBool = (char)1; + Mock.glfwTerminate_CallbackFunctionPointer = Callback; +} + +void glfwTerminate_Stub(CMOCK_glfwTerminate_CALLBACK Callback) +{ + Mock.glfwTerminate_IgnoreBool = (char)0; + Mock.glfwTerminate_CallbackBool = (char)0; + Mock.glfwTerminate_CallbackFunctionPointer = Callback; +} + +void glfwInitHint(int hint, int value) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwInitHint_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwInitHint); + cmock_call_instance = (CMOCK_glfwInitHint_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwInitHint_CallInstance); + Mock.glfwInitHint_CallInstance = CMock_Guts_MemNext(Mock.glfwInitHint_CallInstance); + if (Mock.glfwInitHint_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwInitHint_CallbackBool && + Mock.glfwInitHint_CallbackFunctionPointer != NULL) + { + Mock.glfwInitHint_CallbackFunctionPointer(hint, value, Mock.glfwInitHint_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_hint) + { + UNITY_SET_DETAILS(CMockString_glfwInitHint,CMockString_hint); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_hint, hint, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_value) + { + UNITY_SET_DETAILS(CMockString_glfwInitHint,CMockString_value); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_value, value, cmock_line, CMockStringMismatch); + } + if (Mock.glfwInitHint_CallbackFunctionPointer != NULL) + { + Mock.glfwInitHint_CallbackFunctionPointer(hint, value, Mock.glfwInitHint_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwInitHint(CMOCK_glfwInitHint_CALL_INSTANCE* cmock_call_instance, int hint, int value); +void CMockExpectParameters_glfwInitHint(CMOCK_glfwInitHint_CALL_INSTANCE* cmock_call_instance, int hint, int value) +{ + cmock_call_instance->Expected_hint = hint; + cmock_call_instance->IgnoreArg_hint = 0; + cmock_call_instance->Expected_value = value; + cmock_call_instance->IgnoreArg_value = 0; +} + +void glfwInitHint_CMockIgnore(void) +{ + Mock.glfwInitHint_IgnoreBool = (char)1; +} + +void glfwInitHint_CMockStopIgnore(void) +{ + Mock.glfwInitHint_IgnoreBool = (char)0; +} + +void glfwInitHint_CMockExpect(UNITY_LINE_TYPE cmock_line, int hint, int value) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwInitHint_CALL_INSTANCE)); + CMOCK_glfwInitHint_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwInitHint_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwInitHint_CallInstance = CMock_Guts_MemChain(Mock.glfwInitHint_CallInstance, cmock_guts_index); + Mock.glfwInitHint_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwInitHint(cmock_call_instance, hint, value); +} + +void glfwInitHint_AddCallback(CMOCK_glfwInitHint_CALLBACK Callback) +{ + Mock.glfwInitHint_IgnoreBool = (char)0; + Mock.glfwInitHint_CallbackBool = (char)1; + Mock.glfwInitHint_CallbackFunctionPointer = Callback; +} + +void glfwInitHint_Stub(CMOCK_glfwInitHint_CALLBACK Callback) +{ + Mock.glfwInitHint_IgnoreBool = (char)0; + Mock.glfwInitHint_CallbackBool = (char)0; + Mock.glfwInitHint_CallbackFunctionPointer = Callback; +} + +void glfwInitHint_CMockIgnoreArg_hint(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwInitHint_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwInitHint_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwInitHint_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_hint = 1; +} + +void glfwInitHint_CMockIgnoreArg_value(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwInitHint_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwInitHint_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwInitHint_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_value = 1; +} + +void glfwGetVersion(int* major, int* minor, int* rev) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetVersion_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetVersion); + cmock_call_instance = (CMOCK_glfwGetVersion_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetVersion_CallInstance); + Mock.glfwGetVersion_CallInstance = CMock_Guts_MemNext(Mock.glfwGetVersion_CallInstance); + if (Mock.glfwGetVersion_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwGetVersion_CallbackBool && + Mock.glfwGetVersion_CallbackFunctionPointer != NULL) + { + Mock.glfwGetVersion_CallbackFunctionPointer(major, minor, rev, Mock.glfwGetVersion_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_major) + { + UNITY_SET_DETAILS(CMockString_glfwGetVersion,CMockString_major); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_major, major, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_minor) + { + UNITY_SET_DETAILS(CMockString_glfwGetVersion,CMockString_minor); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_minor, minor, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_rev) + { + UNITY_SET_DETAILS(CMockString_glfwGetVersion,CMockString_rev); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_rev, rev, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetVersion_CallbackFunctionPointer != NULL) + { + Mock.glfwGetVersion_CallbackFunctionPointer(major, minor, rev, Mock.glfwGetVersion_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwGetVersion(CMOCK_glfwGetVersion_CALL_INSTANCE* cmock_call_instance, int* major, int* minor, int* rev); +void CMockExpectParameters_glfwGetVersion(CMOCK_glfwGetVersion_CALL_INSTANCE* cmock_call_instance, int* major, int* minor, int* rev) +{ + cmock_call_instance->Expected_major = major; + cmock_call_instance->IgnoreArg_major = 0; + cmock_call_instance->Expected_minor = minor; + cmock_call_instance->IgnoreArg_minor = 0; + cmock_call_instance->Expected_rev = rev; + cmock_call_instance->IgnoreArg_rev = 0; +} + +void glfwGetVersion_CMockIgnore(void) +{ + Mock.glfwGetVersion_IgnoreBool = (char)1; +} + +void glfwGetVersion_CMockStopIgnore(void) +{ + Mock.glfwGetVersion_IgnoreBool = (char)0; +} + +void glfwGetVersion_CMockExpect(UNITY_LINE_TYPE cmock_line, int* major, int* minor, int* rev) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetVersion_CALL_INSTANCE)); + CMOCK_glfwGetVersion_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetVersion_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetVersion_CallInstance = CMock_Guts_MemChain(Mock.glfwGetVersion_CallInstance, cmock_guts_index); + Mock.glfwGetVersion_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetVersion(cmock_call_instance, major, minor, rev); +} + +void glfwGetVersion_AddCallback(CMOCK_glfwGetVersion_CALLBACK Callback) +{ + Mock.glfwGetVersion_IgnoreBool = (char)0; + Mock.glfwGetVersion_CallbackBool = (char)1; + Mock.glfwGetVersion_CallbackFunctionPointer = Callback; +} + +void glfwGetVersion_Stub(CMOCK_glfwGetVersion_CALLBACK Callback) +{ + Mock.glfwGetVersion_IgnoreBool = (char)0; + Mock.glfwGetVersion_CallbackBool = (char)0; + Mock.glfwGetVersion_CallbackFunctionPointer = Callback; +} + +void glfwGetVersion_CMockIgnoreArg_major(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetVersion_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetVersion_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetVersion_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_major = 1; +} + +void glfwGetVersion_CMockIgnoreArg_minor(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetVersion_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetVersion_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetVersion_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_minor = 1; +} + +void glfwGetVersion_CMockIgnoreArg_rev(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetVersion_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetVersion_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetVersion_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_rev = 1; +} + +const char* glfwGetVersionString(void) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetVersionString_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetVersionString); + cmock_call_instance = (CMOCK_glfwGetVersionString_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetVersionString_CallInstance); + Mock.glfwGetVersionString_CallInstance = CMock_Guts_MemNext(Mock.glfwGetVersionString_CallInstance); + if (Mock.glfwGetVersionString_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetVersionString_FinalReturn; + Mock.glfwGetVersionString_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetVersionString_CallbackBool && + Mock.glfwGetVersionString_CallbackFunctionPointer != NULL) + { + const char* cmock_cb_ret = Mock.glfwGetVersionString_CallbackFunctionPointer(Mock.glfwGetVersionString_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (Mock.glfwGetVersionString_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetVersionString_CallbackFunctionPointer(Mock.glfwGetVersionString_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void glfwGetVersionString_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, const char* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetVersionString_CALL_INSTANCE)); + CMOCK_glfwGetVersionString_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetVersionString_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetVersionString_CallInstance = CMock_Guts_MemChain(Mock.glfwGetVersionString_CallInstance, cmock_guts_index); + Mock.glfwGetVersionString_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetVersionString_IgnoreBool = (char)1; +} + +void glfwGetVersionString_CMockStopIgnore(void) +{ + if(Mock.glfwGetVersionString_IgnoreBool) + Mock.glfwGetVersionString_CallInstance = CMock_Guts_MemNext(Mock.glfwGetVersionString_CallInstance); + Mock.glfwGetVersionString_IgnoreBool = (char)0; +} + +void glfwGetVersionString_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, const char* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetVersionString_CALL_INSTANCE)); + CMOCK_glfwGetVersionString_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetVersionString_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetVersionString_CallInstance = CMock_Guts_MemChain(Mock.glfwGetVersionString_CallInstance, cmock_guts_index); + Mock.glfwGetVersionString_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwGetVersionString_AddCallback(CMOCK_glfwGetVersionString_CALLBACK Callback) +{ + Mock.glfwGetVersionString_IgnoreBool = (char)0; + Mock.glfwGetVersionString_CallbackBool = (char)1; + Mock.glfwGetVersionString_CallbackFunctionPointer = Callback; +} + +void glfwGetVersionString_Stub(CMOCK_glfwGetVersionString_CALLBACK Callback) +{ + Mock.glfwGetVersionString_IgnoreBool = (char)0; + Mock.glfwGetVersionString_CallbackBool = (char)0; + Mock.glfwGetVersionString_CallbackFunctionPointer = Callback; +} + +int glfwGetError(const char** description) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetError_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetError); + cmock_call_instance = (CMOCK_glfwGetError_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetError_CallInstance); + Mock.glfwGetError_CallInstance = CMock_Guts_MemNext(Mock.glfwGetError_CallInstance); + if (Mock.glfwGetError_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetError_FinalReturn; + Mock.glfwGetError_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetError_CallbackBool && + Mock.glfwGetError_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.glfwGetError_CallbackFunctionPointer(description, Mock.glfwGetError_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_description) + { + UNITY_SET_DETAILS(CMockString_glfwGetError,CMockString_description); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_description, description, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetError_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetError_CallbackFunctionPointer(description, Mock.glfwGetError_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwGetError(CMOCK_glfwGetError_CALL_INSTANCE* cmock_call_instance, const char** description); +void CMockExpectParameters_glfwGetError(CMOCK_glfwGetError_CALL_INSTANCE* cmock_call_instance, const char** description) +{ + cmock_call_instance->Expected_description = description; + cmock_call_instance->IgnoreArg_description = 0; +} + +void glfwGetError_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetError_CALL_INSTANCE)); + CMOCK_glfwGetError_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetError_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetError_CallInstance = CMock_Guts_MemChain(Mock.glfwGetError_CallInstance, cmock_guts_index); + Mock.glfwGetError_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetError_IgnoreBool = (char)1; +} + +void glfwGetError_CMockStopIgnore(void) +{ + if(Mock.glfwGetError_IgnoreBool) + Mock.glfwGetError_CallInstance = CMock_Guts_MemNext(Mock.glfwGetError_CallInstance); + Mock.glfwGetError_IgnoreBool = (char)0; +} + +void glfwGetError_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, const char** description, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetError_CALL_INSTANCE)); + CMOCK_glfwGetError_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetError_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetError_CallInstance = CMock_Guts_MemChain(Mock.glfwGetError_CallInstance, cmock_guts_index); + Mock.glfwGetError_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetError(cmock_call_instance, description); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwGetError_AddCallback(CMOCK_glfwGetError_CALLBACK Callback) +{ + Mock.glfwGetError_IgnoreBool = (char)0; + Mock.glfwGetError_CallbackBool = (char)1; + Mock.glfwGetError_CallbackFunctionPointer = Callback; +} + +void glfwGetError_Stub(CMOCK_glfwGetError_CALLBACK Callback) +{ + Mock.glfwGetError_IgnoreBool = (char)0; + Mock.glfwGetError_CallbackBool = (char)0; + Mock.glfwGetError_CallbackFunctionPointer = Callback; +} + +void glfwGetError_CMockIgnoreArg_description(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetError_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetError_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetError_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_description = 1; +} + +GLFWerrorfun glfwSetErrorCallback(GLFWerrorfun callback) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetErrorCallback_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetErrorCallback); + cmock_call_instance = (CMOCK_glfwSetErrorCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetErrorCallback_CallInstance); + Mock.glfwSetErrorCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetErrorCallback_CallInstance); + if (Mock.glfwSetErrorCallback_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwSetErrorCallback_FinalReturn; + memcpy((void*)(&Mock.glfwSetErrorCallback_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(GLFWerrorfun[sizeof(cmock_call_instance->ReturnVal) == sizeof(GLFWerrorfun) ? 1 : -1])); /* add GLFWerrorfun to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwSetErrorCallback_CallbackBool && + Mock.glfwSetErrorCallback_CallbackFunctionPointer != NULL) + { + GLFWerrorfun cmock_cb_ret = Mock.glfwSetErrorCallback_CallbackFunctionPointer(callback, Mock.glfwSetErrorCallback_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_callback) + { + UNITY_SET_DETAILS(CMockString_glfwSetErrorCallback,CMockString_callback); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), sizeof(GLFWerrorfun), cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetErrorCallback_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwSetErrorCallback_CallbackFunctionPointer(callback, Mock.glfwSetErrorCallback_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwSetErrorCallback(CMOCK_glfwSetErrorCallback_CALL_INSTANCE* cmock_call_instance, GLFWerrorfun callback); +void CMockExpectParameters_glfwSetErrorCallback(CMOCK_glfwSetErrorCallback_CALL_INSTANCE* cmock_call_instance, GLFWerrorfun callback) +{ + memcpy((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), + sizeof(GLFWerrorfun[sizeof(callback) == sizeof(GLFWerrorfun) ? 1 : -1])); /* add GLFWerrorfun to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_callback = 0; +} + +void glfwSetErrorCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWerrorfun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetErrorCallback_CALL_INSTANCE)); + CMOCK_glfwSetErrorCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetErrorCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetErrorCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetErrorCallback_CallInstance, cmock_guts_index); + Mock.glfwSetErrorCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwSetErrorCallback_IgnoreBool = (char)1; +} + +void glfwSetErrorCallback_CMockStopIgnore(void) +{ + if(Mock.glfwSetErrorCallback_IgnoreBool) + Mock.glfwSetErrorCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetErrorCallback_CallInstance); + Mock.glfwSetErrorCallback_IgnoreBool = (char)0; +} + +void glfwSetErrorCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWerrorfun callback, GLFWerrorfun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetErrorCallback_CALL_INSTANCE)); + CMOCK_glfwSetErrorCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetErrorCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetErrorCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetErrorCallback_CallInstance, cmock_guts_index); + Mock.glfwSetErrorCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetErrorCallback(cmock_call_instance, callback); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(GLFWerrorfun[sizeof(cmock_to_return) == sizeof(GLFWerrorfun) ? 1 : -1])); /* add GLFWerrorfun to :treat_as_array if this causes an error */ +} + +void glfwSetErrorCallback_AddCallback(CMOCK_glfwSetErrorCallback_CALLBACK Callback) +{ + Mock.glfwSetErrorCallback_IgnoreBool = (char)0; + Mock.glfwSetErrorCallback_CallbackBool = (char)1; + Mock.glfwSetErrorCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetErrorCallback_Stub(CMOCK_glfwSetErrorCallback_CALLBACK Callback) +{ + Mock.glfwSetErrorCallback_IgnoreBool = (char)0; + Mock.glfwSetErrorCallback_CallbackBool = (char)0; + Mock.glfwSetErrorCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetErrorCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetErrorCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetErrorCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetErrorCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_callback = 1; +} + +GLFWmonitor** glfwGetMonitors(int* count) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetMonitors_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetMonitors); + cmock_call_instance = (CMOCK_glfwGetMonitors_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetMonitors_CallInstance); + Mock.glfwGetMonitors_CallInstance = CMock_Guts_MemNext(Mock.glfwGetMonitors_CallInstance); + if (Mock.glfwGetMonitors_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetMonitors_FinalReturn; + Mock.glfwGetMonitors_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetMonitors_CallbackBool && + Mock.glfwGetMonitors_CallbackFunctionPointer != NULL) + { + GLFWmonitor** cmock_cb_ret = Mock.glfwGetMonitors_CallbackFunctionPointer(count, Mock.glfwGetMonitors_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_count) + { + UNITY_SET_DETAILS(CMockString_glfwGetMonitors,CMockString_count); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_count, count, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetMonitors_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetMonitors_CallbackFunctionPointer(count, Mock.glfwGetMonitors_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwGetMonitors(CMOCK_glfwGetMonitors_CALL_INSTANCE* cmock_call_instance, int* count); +void CMockExpectParameters_glfwGetMonitors(CMOCK_glfwGetMonitors_CALL_INSTANCE* cmock_call_instance, int* count) +{ + cmock_call_instance->Expected_count = count; + cmock_call_instance->IgnoreArg_count = 0; +} + +void glfwGetMonitors_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWmonitor** cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetMonitors_CALL_INSTANCE)); + CMOCK_glfwGetMonitors_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMonitors_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetMonitors_CallInstance = CMock_Guts_MemChain(Mock.glfwGetMonitors_CallInstance, cmock_guts_index); + Mock.glfwGetMonitors_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetMonitors_IgnoreBool = (char)1; +} + +void glfwGetMonitors_CMockStopIgnore(void) +{ + if(Mock.glfwGetMonitors_IgnoreBool) + Mock.glfwGetMonitors_CallInstance = CMock_Guts_MemNext(Mock.glfwGetMonitors_CallInstance); + Mock.glfwGetMonitors_IgnoreBool = (char)0; +} + +void glfwGetMonitors_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int* count, GLFWmonitor** cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetMonitors_CALL_INSTANCE)); + CMOCK_glfwGetMonitors_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMonitors_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetMonitors_CallInstance = CMock_Guts_MemChain(Mock.glfwGetMonitors_CallInstance, cmock_guts_index); + Mock.glfwGetMonitors_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetMonitors(cmock_call_instance, count); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwGetMonitors_AddCallback(CMOCK_glfwGetMonitors_CALLBACK Callback) +{ + Mock.glfwGetMonitors_IgnoreBool = (char)0; + Mock.glfwGetMonitors_CallbackBool = (char)1; + Mock.glfwGetMonitors_CallbackFunctionPointer = Callback; +} + +void glfwGetMonitors_Stub(CMOCK_glfwGetMonitors_CALLBACK Callback) +{ + Mock.glfwGetMonitors_IgnoreBool = (char)0; + Mock.glfwGetMonitors_CallbackBool = (char)0; + Mock.glfwGetMonitors_CallbackFunctionPointer = Callback; +} + +void glfwGetMonitors_CMockIgnoreArg_count(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetMonitors_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMonitors_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetMonitors_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_count = 1; +} + +GLFWmonitor* glfwGetPrimaryMonitor(void) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetPrimaryMonitor_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetPrimaryMonitor); + cmock_call_instance = (CMOCK_glfwGetPrimaryMonitor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetPrimaryMonitor_CallInstance); + Mock.glfwGetPrimaryMonitor_CallInstance = CMock_Guts_MemNext(Mock.glfwGetPrimaryMonitor_CallInstance); + if (Mock.glfwGetPrimaryMonitor_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetPrimaryMonitor_FinalReturn; + Mock.glfwGetPrimaryMonitor_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetPrimaryMonitor_CallbackBool && + Mock.glfwGetPrimaryMonitor_CallbackFunctionPointer != NULL) + { + GLFWmonitor* cmock_cb_ret = Mock.glfwGetPrimaryMonitor_CallbackFunctionPointer(Mock.glfwGetPrimaryMonitor_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (Mock.glfwGetPrimaryMonitor_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetPrimaryMonitor_CallbackFunctionPointer(Mock.glfwGetPrimaryMonitor_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void glfwGetPrimaryMonitor_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWmonitor* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetPrimaryMonitor_CALL_INSTANCE)); + CMOCK_glfwGetPrimaryMonitor_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetPrimaryMonitor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetPrimaryMonitor_CallInstance = CMock_Guts_MemChain(Mock.glfwGetPrimaryMonitor_CallInstance, cmock_guts_index); + Mock.glfwGetPrimaryMonitor_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetPrimaryMonitor_IgnoreBool = (char)1; +} + +void glfwGetPrimaryMonitor_CMockStopIgnore(void) +{ + if(Mock.glfwGetPrimaryMonitor_IgnoreBool) + Mock.glfwGetPrimaryMonitor_CallInstance = CMock_Guts_MemNext(Mock.glfwGetPrimaryMonitor_CallInstance); + Mock.glfwGetPrimaryMonitor_IgnoreBool = (char)0; +} + +void glfwGetPrimaryMonitor_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWmonitor* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetPrimaryMonitor_CALL_INSTANCE)); + CMOCK_glfwGetPrimaryMonitor_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetPrimaryMonitor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetPrimaryMonitor_CallInstance = CMock_Guts_MemChain(Mock.glfwGetPrimaryMonitor_CallInstance, cmock_guts_index); + Mock.glfwGetPrimaryMonitor_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwGetPrimaryMonitor_AddCallback(CMOCK_glfwGetPrimaryMonitor_CALLBACK Callback) +{ + Mock.glfwGetPrimaryMonitor_IgnoreBool = (char)0; + Mock.glfwGetPrimaryMonitor_CallbackBool = (char)1; + Mock.glfwGetPrimaryMonitor_CallbackFunctionPointer = Callback; +} + +void glfwGetPrimaryMonitor_Stub(CMOCK_glfwGetPrimaryMonitor_CALLBACK Callback) +{ + Mock.glfwGetPrimaryMonitor_IgnoreBool = (char)0; + Mock.glfwGetPrimaryMonitor_CallbackBool = (char)0; + Mock.glfwGetPrimaryMonitor_CallbackFunctionPointer = Callback; +} + +void glfwGetMonitorPos(GLFWmonitor* monitor, int* xpos, int* ypos) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetMonitorPos_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetMonitorPos); + cmock_call_instance = (CMOCK_glfwGetMonitorPos_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetMonitorPos_CallInstance); + Mock.glfwGetMonitorPos_CallInstance = CMock_Guts_MemNext(Mock.glfwGetMonitorPos_CallInstance); + if (Mock.glfwGetMonitorPos_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwGetMonitorPos_CallbackBool && + Mock.glfwGetMonitorPos_CallbackFunctionPointer != NULL) + { + Mock.glfwGetMonitorPos_CallbackFunctionPointer(monitor, xpos, ypos, Mock.glfwGetMonitorPos_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_monitor) + { + UNITY_SET_DETAILS(CMockString_glfwGetMonitorPos,CMockString_monitor); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_monitor, monitor, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_xpos) + { + UNITY_SET_DETAILS(CMockString_glfwGetMonitorPos,CMockString_xpos); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_xpos, xpos, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_ypos) + { + UNITY_SET_DETAILS(CMockString_glfwGetMonitorPos,CMockString_ypos); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_ypos, ypos, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetMonitorPos_CallbackFunctionPointer != NULL) + { + Mock.glfwGetMonitorPos_CallbackFunctionPointer(monitor, xpos, ypos, Mock.glfwGetMonitorPos_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwGetMonitorPos(CMOCK_glfwGetMonitorPos_CALL_INSTANCE* cmock_call_instance, GLFWmonitor* monitor, int* xpos, int* ypos); +void CMockExpectParameters_glfwGetMonitorPos(CMOCK_glfwGetMonitorPos_CALL_INSTANCE* cmock_call_instance, GLFWmonitor* monitor, int* xpos, int* ypos) +{ + cmock_call_instance->Expected_monitor = monitor; + cmock_call_instance->IgnoreArg_monitor = 0; + cmock_call_instance->Expected_xpos = xpos; + cmock_call_instance->IgnoreArg_xpos = 0; + cmock_call_instance->Expected_ypos = ypos; + cmock_call_instance->IgnoreArg_ypos = 0; +} + +void glfwGetMonitorPos_CMockIgnore(void) +{ + Mock.glfwGetMonitorPos_IgnoreBool = (char)1; +} + +void glfwGetMonitorPos_CMockStopIgnore(void) +{ + Mock.glfwGetMonitorPos_IgnoreBool = (char)0; +} + +void glfwGetMonitorPos_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWmonitor* monitor, int* xpos, int* ypos) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetMonitorPos_CALL_INSTANCE)); + CMOCK_glfwGetMonitorPos_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMonitorPos_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetMonitorPos_CallInstance = CMock_Guts_MemChain(Mock.glfwGetMonitorPos_CallInstance, cmock_guts_index); + Mock.glfwGetMonitorPos_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetMonitorPos(cmock_call_instance, monitor, xpos, ypos); +} + +void glfwGetMonitorPos_AddCallback(CMOCK_glfwGetMonitorPos_CALLBACK Callback) +{ + Mock.glfwGetMonitorPos_IgnoreBool = (char)0; + Mock.glfwGetMonitorPos_CallbackBool = (char)1; + Mock.glfwGetMonitorPos_CallbackFunctionPointer = Callback; +} + +void glfwGetMonitorPos_Stub(CMOCK_glfwGetMonitorPos_CALLBACK Callback) +{ + Mock.glfwGetMonitorPos_IgnoreBool = (char)0; + Mock.glfwGetMonitorPos_CallbackBool = (char)0; + Mock.glfwGetMonitorPos_CallbackFunctionPointer = Callback; +} + +void glfwGetMonitorPos_CMockIgnoreArg_monitor(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetMonitorPos_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMonitorPos_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetMonitorPos_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_monitor = 1; +} + +void glfwGetMonitorPos_CMockIgnoreArg_xpos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetMonitorPos_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMonitorPos_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetMonitorPos_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_xpos = 1; +} + +void glfwGetMonitorPos_CMockIgnoreArg_ypos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetMonitorPos_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMonitorPos_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetMonitorPos_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_ypos = 1; +} + +void glfwGetMonitorWorkarea(GLFWmonitor* monitor, int* xpos, int* ypos, int* width, int* height) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetMonitorWorkarea_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetMonitorWorkarea); + cmock_call_instance = (CMOCK_glfwGetMonitorWorkarea_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetMonitorWorkarea_CallInstance); + Mock.glfwGetMonitorWorkarea_CallInstance = CMock_Guts_MemNext(Mock.glfwGetMonitorWorkarea_CallInstance); + if (Mock.glfwGetMonitorWorkarea_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwGetMonitorWorkarea_CallbackBool && + Mock.glfwGetMonitorWorkarea_CallbackFunctionPointer != NULL) + { + Mock.glfwGetMonitorWorkarea_CallbackFunctionPointer(monitor, xpos, ypos, width, height, Mock.glfwGetMonitorWorkarea_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_monitor) + { + UNITY_SET_DETAILS(CMockString_glfwGetMonitorWorkarea,CMockString_monitor); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_monitor, monitor, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_xpos) + { + UNITY_SET_DETAILS(CMockString_glfwGetMonitorWorkarea,CMockString_xpos); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_xpos, xpos, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_ypos) + { + UNITY_SET_DETAILS(CMockString_glfwGetMonitorWorkarea,CMockString_ypos); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_ypos, ypos, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_width) + { + UNITY_SET_DETAILS(CMockString_glfwGetMonitorWorkarea,CMockString_width); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_width, width, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_height) + { + UNITY_SET_DETAILS(CMockString_glfwGetMonitorWorkarea,CMockString_height); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_height, height, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetMonitorWorkarea_CallbackFunctionPointer != NULL) + { + Mock.glfwGetMonitorWorkarea_CallbackFunctionPointer(monitor, xpos, ypos, width, height, Mock.glfwGetMonitorWorkarea_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwGetMonitorWorkarea(CMOCK_glfwGetMonitorWorkarea_CALL_INSTANCE* cmock_call_instance, GLFWmonitor* monitor, int* xpos, int* ypos, int* width, int* height); +void CMockExpectParameters_glfwGetMonitorWorkarea(CMOCK_glfwGetMonitorWorkarea_CALL_INSTANCE* cmock_call_instance, GLFWmonitor* monitor, int* xpos, int* ypos, int* width, int* height) +{ + cmock_call_instance->Expected_monitor = monitor; + cmock_call_instance->IgnoreArg_monitor = 0; + cmock_call_instance->Expected_xpos = xpos; + cmock_call_instance->IgnoreArg_xpos = 0; + cmock_call_instance->Expected_ypos = ypos; + cmock_call_instance->IgnoreArg_ypos = 0; + cmock_call_instance->Expected_width = width; + cmock_call_instance->IgnoreArg_width = 0; + cmock_call_instance->Expected_height = height; + cmock_call_instance->IgnoreArg_height = 0; +} + +void glfwGetMonitorWorkarea_CMockIgnore(void) +{ + Mock.glfwGetMonitorWorkarea_IgnoreBool = (char)1; +} + +void glfwGetMonitorWorkarea_CMockStopIgnore(void) +{ + Mock.glfwGetMonitorWorkarea_IgnoreBool = (char)0; +} + +void glfwGetMonitorWorkarea_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWmonitor* monitor, int* xpos, int* ypos, int* width, int* height) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetMonitorWorkarea_CALL_INSTANCE)); + CMOCK_glfwGetMonitorWorkarea_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMonitorWorkarea_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetMonitorWorkarea_CallInstance = CMock_Guts_MemChain(Mock.glfwGetMonitorWorkarea_CallInstance, cmock_guts_index); + Mock.glfwGetMonitorWorkarea_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetMonitorWorkarea(cmock_call_instance, monitor, xpos, ypos, width, height); +} + +void glfwGetMonitorWorkarea_AddCallback(CMOCK_glfwGetMonitorWorkarea_CALLBACK Callback) +{ + Mock.glfwGetMonitorWorkarea_IgnoreBool = (char)0; + Mock.glfwGetMonitorWorkarea_CallbackBool = (char)1; + Mock.glfwGetMonitorWorkarea_CallbackFunctionPointer = Callback; +} + +void glfwGetMonitorWorkarea_Stub(CMOCK_glfwGetMonitorWorkarea_CALLBACK Callback) +{ + Mock.glfwGetMonitorWorkarea_IgnoreBool = (char)0; + Mock.glfwGetMonitorWorkarea_CallbackBool = (char)0; + Mock.glfwGetMonitorWorkarea_CallbackFunctionPointer = Callback; +} + +void glfwGetMonitorWorkarea_CMockIgnoreArg_monitor(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetMonitorWorkarea_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMonitorWorkarea_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetMonitorWorkarea_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_monitor = 1; +} + +void glfwGetMonitorWorkarea_CMockIgnoreArg_xpos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetMonitorWorkarea_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMonitorWorkarea_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetMonitorWorkarea_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_xpos = 1; +} + +void glfwGetMonitorWorkarea_CMockIgnoreArg_ypos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetMonitorWorkarea_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMonitorWorkarea_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetMonitorWorkarea_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_ypos = 1; +} + +void glfwGetMonitorWorkarea_CMockIgnoreArg_width(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetMonitorWorkarea_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMonitorWorkarea_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetMonitorWorkarea_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_width = 1; +} + +void glfwGetMonitorWorkarea_CMockIgnoreArg_height(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetMonitorWorkarea_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMonitorWorkarea_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetMonitorWorkarea_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_height = 1; +} + +void glfwGetMonitorPhysicalSize(GLFWmonitor* monitor, int* widthMM, int* heightMM) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetMonitorPhysicalSize_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetMonitorPhysicalSize); + cmock_call_instance = (CMOCK_glfwGetMonitorPhysicalSize_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetMonitorPhysicalSize_CallInstance); + Mock.glfwGetMonitorPhysicalSize_CallInstance = CMock_Guts_MemNext(Mock.glfwGetMonitorPhysicalSize_CallInstance); + if (Mock.glfwGetMonitorPhysicalSize_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwGetMonitorPhysicalSize_CallbackBool && + Mock.glfwGetMonitorPhysicalSize_CallbackFunctionPointer != NULL) + { + Mock.glfwGetMonitorPhysicalSize_CallbackFunctionPointer(monitor, widthMM, heightMM, Mock.glfwGetMonitorPhysicalSize_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_monitor) + { + UNITY_SET_DETAILS(CMockString_glfwGetMonitorPhysicalSize,CMockString_monitor); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_monitor, monitor, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_widthMM) + { + UNITY_SET_DETAILS(CMockString_glfwGetMonitorPhysicalSize,CMockString_widthMM); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_widthMM, widthMM, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_heightMM) + { + UNITY_SET_DETAILS(CMockString_glfwGetMonitorPhysicalSize,CMockString_heightMM); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_heightMM, heightMM, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetMonitorPhysicalSize_CallbackFunctionPointer != NULL) + { + Mock.glfwGetMonitorPhysicalSize_CallbackFunctionPointer(monitor, widthMM, heightMM, Mock.glfwGetMonitorPhysicalSize_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwGetMonitorPhysicalSize(CMOCK_glfwGetMonitorPhysicalSize_CALL_INSTANCE* cmock_call_instance, GLFWmonitor* monitor, int* widthMM, int* heightMM); +void CMockExpectParameters_glfwGetMonitorPhysicalSize(CMOCK_glfwGetMonitorPhysicalSize_CALL_INSTANCE* cmock_call_instance, GLFWmonitor* monitor, int* widthMM, int* heightMM) +{ + cmock_call_instance->Expected_monitor = monitor; + cmock_call_instance->IgnoreArg_monitor = 0; + cmock_call_instance->Expected_widthMM = widthMM; + cmock_call_instance->IgnoreArg_widthMM = 0; + cmock_call_instance->Expected_heightMM = heightMM; + cmock_call_instance->IgnoreArg_heightMM = 0; +} + +void glfwGetMonitorPhysicalSize_CMockIgnore(void) +{ + Mock.glfwGetMonitorPhysicalSize_IgnoreBool = (char)1; +} + +void glfwGetMonitorPhysicalSize_CMockStopIgnore(void) +{ + Mock.glfwGetMonitorPhysicalSize_IgnoreBool = (char)0; +} + +void glfwGetMonitorPhysicalSize_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWmonitor* monitor, int* widthMM, int* heightMM) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetMonitorPhysicalSize_CALL_INSTANCE)); + CMOCK_glfwGetMonitorPhysicalSize_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMonitorPhysicalSize_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetMonitorPhysicalSize_CallInstance = CMock_Guts_MemChain(Mock.glfwGetMonitorPhysicalSize_CallInstance, cmock_guts_index); + Mock.glfwGetMonitorPhysicalSize_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetMonitorPhysicalSize(cmock_call_instance, monitor, widthMM, heightMM); +} + +void glfwGetMonitorPhysicalSize_AddCallback(CMOCK_glfwGetMonitorPhysicalSize_CALLBACK Callback) +{ + Mock.glfwGetMonitorPhysicalSize_IgnoreBool = (char)0; + Mock.glfwGetMonitorPhysicalSize_CallbackBool = (char)1; + Mock.glfwGetMonitorPhysicalSize_CallbackFunctionPointer = Callback; +} + +void glfwGetMonitorPhysicalSize_Stub(CMOCK_glfwGetMonitorPhysicalSize_CALLBACK Callback) +{ + Mock.glfwGetMonitorPhysicalSize_IgnoreBool = (char)0; + Mock.glfwGetMonitorPhysicalSize_CallbackBool = (char)0; + Mock.glfwGetMonitorPhysicalSize_CallbackFunctionPointer = Callback; +} + +void glfwGetMonitorPhysicalSize_CMockIgnoreArg_monitor(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetMonitorPhysicalSize_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMonitorPhysicalSize_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetMonitorPhysicalSize_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_monitor = 1; +} + +void glfwGetMonitorPhysicalSize_CMockIgnoreArg_widthMM(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetMonitorPhysicalSize_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMonitorPhysicalSize_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetMonitorPhysicalSize_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_widthMM = 1; +} + +void glfwGetMonitorPhysicalSize_CMockIgnoreArg_heightMM(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetMonitorPhysicalSize_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMonitorPhysicalSize_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetMonitorPhysicalSize_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_heightMM = 1; +} + +void glfwGetMonitorContentScale(GLFWmonitor* monitor, float* xscale, float* yscale) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetMonitorContentScale_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetMonitorContentScale); + cmock_call_instance = (CMOCK_glfwGetMonitorContentScale_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetMonitorContentScale_CallInstance); + Mock.glfwGetMonitorContentScale_CallInstance = CMock_Guts_MemNext(Mock.glfwGetMonitorContentScale_CallInstance); + if (Mock.glfwGetMonitorContentScale_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwGetMonitorContentScale_CallbackBool && + Mock.glfwGetMonitorContentScale_CallbackFunctionPointer != NULL) + { + Mock.glfwGetMonitorContentScale_CallbackFunctionPointer(monitor, xscale, yscale, Mock.glfwGetMonitorContentScale_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_monitor) + { + UNITY_SET_DETAILS(CMockString_glfwGetMonitorContentScale,CMockString_monitor); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_monitor, monitor, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_xscale) + { + UNITY_SET_DETAILS(CMockString_glfwGetMonitorContentScale,CMockString_xscale); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_xscale, xscale, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_yscale) + { + UNITY_SET_DETAILS(CMockString_glfwGetMonitorContentScale,CMockString_yscale); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_yscale, yscale, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetMonitorContentScale_CallbackFunctionPointer != NULL) + { + Mock.glfwGetMonitorContentScale_CallbackFunctionPointer(monitor, xscale, yscale, Mock.glfwGetMonitorContentScale_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwGetMonitorContentScale(CMOCK_glfwGetMonitorContentScale_CALL_INSTANCE* cmock_call_instance, GLFWmonitor* monitor, float* xscale, float* yscale); +void CMockExpectParameters_glfwGetMonitorContentScale(CMOCK_glfwGetMonitorContentScale_CALL_INSTANCE* cmock_call_instance, GLFWmonitor* monitor, float* xscale, float* yscale) +{ + cmock_call_instance->Expected_monitor = monitor; + cmock_call_instance->IgnoreArg_monitor = 0; + cmock_call_instance->Expected_xscale = xscale; + cmock_call_instance->IgnoreArg_xscale = 0; + cmock_call_instance->Expected_yscale = yscale; + cmock_call_instance->IgnoreArg_yscale = 0; +} + +void glfwGetMonitorContentScale_CMockIgnore(void) +{ + Mock.glfwGetMonitorContentScale_IgnoreBool = (char)1; +} + +void glfwGetMonitorContentScale_CMockStopIgnore(void) +{ + Mock.glfwGetMonitorContentScale_IgnoreBool = (char)0; +} + +void glfwGetMonitorContentScale_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWmonitor* monitor, float* xscale, float* yscale) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetMonitorContentScale_CALL_INSTANCE)); + CMOCK_glfwGetMonitorContentScale_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMonitorContentScale_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetMonitorContentScale_CallInstance = CMock_Guts_MemChain(Mock.glfwGetMonitorContentScale_CallInstance, cmock_guts_index); + Mock.glfwGetMonitorContentScale_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetMonitorContentScale(cmock_call_instance, monitor, xscale, yscale); +} + +void glfwGetMonitorContentScale_AddCallback(CMOCK_glfwGetMonitorContentScale_CALLBACK Callback) +{ + Mock.glfwGetMonitorContentScale_IgnoreBool = (char)0; + Mock.glfwGetMonitorContentScale_CallbackBool = (char)1; + Mock.glfwGetMonitorContentScale_CallbackFunctionPointer = Callback; +} + +void glfwGetMonitorContentScale_Stub(CMOCK_glfwGetMonitorContentScale_CALLBACK Callback) +{ + Mock.glfwGetMonitorContentScale_IgnoreBool = (char)0; + Mock.glfwGetMonitorContentScale_CallbackBool = (char)0; + Mock.glfwGetMonitorContentScale_CallbackFunctionPointer = Callback; +} + +void glfwGetMonitorContentScale_CMockIgnoreArg_monitor(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetMonitorContentScale_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMonitorContentScale_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetMonitorContentScale_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_monitor = 1; +} + +void glfwGetMonitorContentScale_CMockIgnoreArg_xscale(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetMonitorContentScale_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMonitorContentScale_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetMonitorContentScale_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_xscale = 1; +} + +void glfwGetMonitorContentScale_CMockIgnoreArg_yscale(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetMonitorContentScale_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMonitorContentScale_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetMonitorContentScale_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_yscale = 1; +} + +const char* glfwGetMonitorName(GLFWmonitor* monitor) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetMonitorName_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetMonitorName); + cmock_call_instance = (CMOCK_glfwGetMonitorName_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetMonitorName_CallInstance); + Mock.glfwGetMonitorName_CallInstance = CMock_Guts_MemNext(Mock.glfwGetMonitorName_CallInstance); + if (Mock.glfwGetMonitorName_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetMonitorName_FinalReturn; + Mock.glfwGetMonitorName_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetMonitorName_CallbackBool && + Mock.glfwGetMonitorName_CallbackFunctionPointer != NULL) + { + const char* cmock_cb_ret = Mock.glfwGetMonitorName_CallbackFunctionPointer(monitor, Mock.glfwGetMonitorName_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_monitor) + { + UNITY_SET_DETAILS(CMockString_glfwGetMonitorName,CMockString_monitor); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_monitor, monitor, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetMonitorName_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetMonitorName_CallbackFunctionPointer(monitor, Mock.glfwGetMonitorName_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwGetMonitorName(CMOCK_glfwGetMonitorName_CALL_INSTANCE* cmock_call_instance, GLFWmonitor* monitor); +void CMockExpectParameters_glfwGetMonitorName(CMOCK_glfwGetMonitorName_CALL_INSTANCE* cmock_call_instance, GLFWmonitor* monitor) +{ + cmock_call_instance->Expected_monitor = monitor; + cmock_call_instance->IgnoreArg_monitor = 0; +} + +void glfwGetMonitorName_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, const char* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetMonitorName_CALL_INSTANCE)); + CMOCK_glfwGetMonitorName_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMonitorName_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetMonitorName_CallInstance = CMock_Guts_MemChain(Mock.glfwGetMonitorName_CallInstance, cmock_guts_index); + Mock.glfwGetMonitorName_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetMonitorName_IgnoreBool = (char)1; +} + +void glfwGetMonitorName_CMockStopIgnore(void) +{ + if(Mock.glfwGetMonitorName_IgnoreBool) + Mock.glfwGetMonitorName_CallInstance = CMock_Guts_MemNext(Mock.glfwGetMonitorName_CallInstance); + Mock.glfwGetMonitorName_IgnoreBool = (char)0; +} + +void glfwGetMonitorName_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWmonitor* monitor, const char* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetMonitorName_CALL_INSTANCE)); + CMOCK_glfwGetMonitorName_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMonitorName_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetMonitorName_CallInstance = CMock_Guts_MemChain(Mock.glfwGetMonitorName_CallInstance, cmock_guts_index); + Mock.glfwGetMonitorName_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetMonitorName(cmock_call_instance, monitor); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwGetMonitorName_AddCallback(CMOCK_glfwGetMonitorName_CALLBACK Callback) +{ + Mock.glfwGetMonitorName_IgnoreBool = (char)0; + Mock.glfwGetMonitorName_CallbackBool = (char)1; + Mock.glfwGetMonitorName_CallbackFunctionPointer = Callback; +} + +void glfwGetMonitorName_Stub(CMOCK_glfwGetMonitorName_CALLBACK Callback) +{ + Mock.glfwGetMonitorName_IgnoreBool = (char)0; + Mock.glfwGetMonitorName_CallbackBool = (char)0; + Mock.glfwGetMonitorName_CallbackFunctionPointer = Callback; +} + +void glfwGetMonitorName_CMockIgnoreArg_monitor(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetMonitorName_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMonitorName_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetMonitorName_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_monitor = 1; +} + +void glfwSetMonitorUserPointer(GLFWmonitor* monitor, void* pointer) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetMonitorUserPointer_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetMonitorUserPointer); + cmock_call_instance = (CMOCK_glfwSetMonitorUserPointer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetMonitorUserPointer_CallInstance); + Mock.glfwSetMonitorUserPointer_CallInstance = CMock_Guts_MemNext(Mock.glfwSetMonitorUserPointer_CallInstance); + if (Mock.glfwSetMonitorUserPointer_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwSetMonitorUserPointer_CallbackBool && + Mock.glfwSetMonitorUserPointer_CallbackFunctionPointer != NULL) + { + Mock.glfwSetMonitorUserPointer_CallbackFunctionPointer(monitor, pointer, Mock.glfwSetMonitorUserPointer_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_monitor) + { + UNITY_SET_DETAILS(CMockString_glfwSetMonitorUserPointer,CMockString_monitor); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_monitor, monitor, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pointer) + { + UNITY_SET_DETAILS(CMockString_glfwSetMonitorUserPointer,CMockString_pointer); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_pointer, pointer, cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetMonitorUserPointer_CallbackFunctionPointer != NULL) + { + Mock.glfwSetMonitorUserPointer_CallbackFunctionPointer(monitor, pointer, Mock.glfwSetMonitorUserPointer_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwSetMonitorUserPointer(CMOCK_glfwSetMonitorUserPointer_CALL_INSTANCE* cmock_call_instance, GLFWmonitor* monitor, void* pointer); +void CMockExpectParameters_glfwSetMonitorUserPointer(CMOCK_glfwSetMonitorUserPointer_CALL_INSTANCE* cmock_call_instance, GLFWmonitor* monitor, void* pointer) +{ + cmock_call_instance->Expected_monitor = monitor; + cmock_call_instance->IgnoreArg_monitor = 0; + cmock_call_instance->Expected_pointer = pointer; + cmock_call_instance->IgnoreArg_pointer = 0; +} + +void glfwSetMonitorUserPointer_CMockIgnore(void) +{ + Mock.glfwSetMonitorUserPointer_IgnoreBool = (char)1; +} + +void glfwSetMonitorUserPointer_CMockStopIgnore(void) +{ + Mock.glfwSetMonitorUserPointer_IgnoreBool = (char)0; +} + +void glfwSetMonitorUserPointer_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWmonitor* monitor, void* pointer) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetMonitorUserPointer_CALL_INSTANCE)); + CMOCK_glfwSetMonitorUserPointer_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetMonitorUserPointer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetMonitorUserPointer_CallInstance = CMock_Guts_MemChain(Mock.glfwSetMonitorUserPointer_CallInstance, cmock_guts_index); + Mock.glfwSetMonitorUserPointer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetMonitorUserPointer(cmock_call_instance, monitor, pointer); +} + +void glfwSetMonitorUserPointer_AddCallback(CMOCK_glfwSetMonitorUserPointer_CALLBACK Callback) +{ + Mock.glfwSetMonitorUserPointer_IgnoreBool = (char)0; + Mock.glfwSetMonitorUserPointer_CallbackBool = (char)1; + Mock.glfwSetMonitorUserPointer_CallbackFunctionPointer = Callback; +} + +void glfwSetMonitorUserPointer_Stub(CMOCK_glfwSetMonitorUserPointer_CALLBACK Callback) +{ + Mock.glfwSetMonitorUserPointer_IgnoreBool = (char)0; + Mock.glfwSetMonitorUserPointer_CallbackBool = (char)0; + Mock.glfwSetMonitorUserPointer_CallbackFunctionPointer = Callback; +} + +void glfwSetMonitorUserPointer_CMockIgnoreArg_monitor(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetMonitorUserPointer_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetMonitorUserPointer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetMonitorUserPointer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_monitor = 1; +} + +void glfwSetMonitorUserPointer_CMockIgnoreArg_pointer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetMonitorUserPointer_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetMonitorUserPointer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetMonitorUserPointer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pointer = 1; +} + +void* glfwGetMonitorUserPointer(GLFWmonitor* monitor) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetMonitorUserPointer_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetMonitorUserPointer); + cmock_call_instance = (CMOCK_glfwGetMonitorUserPointer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetMonitorUserPointer_CallInstance); + Mock.glfwGetMonitorUserPointer_CallInstance = CMock_Guts_MemNext(Mock.glfwGetMonitorUserPointer_CallInstance); + if (Mock.glfwGetMonitorUserPointer_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetMonitorUserPointer_FinalReturn; + Mock.glfwGetMonitorUserPointer_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetMonitorUserPointer_CallbackBool && + Mock.glfwGetMonitorUserPointer_CallbackFunctionPointer != NULL) + { + void* cmock_cb_ret = Mock.glfwGetMonitorUserPointer_CallbackFunctionPointer(monitor, Mock.glfwGetMonitorUserPointer_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_monitor) + { + UNITY_SET_DETAILS(CMockString_glfwGetMonitorUserPointer,CMockString_monitor); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_monitor, monitor, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetMonitorUserPointer_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetMonitorUserPointer_CallbackFunctionPointer(monitor, Mock.glfwGetMonitorUserPointer_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwGetMonitorUserPointer(CMOCK_glfwGetMonitorUserPointer_CALL_INSTANCE* cmock_call_instance, GLFWmonitor* monitor); +void CMockExpectParameters_glfwGetMonitorUserPointer(CMOCK_glfwGetMonitorUserPointer_CALL_INSTANCE* cmock_call_instance, GLFWmonitor* monitor) +{ + cmock_call_instance->Expected_monitor = monitor; + cmock_call_instance->IgnoreArg_monitor = 0; +} + +void glfwGetMonitorUserPointer_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, void* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetMonitorUserPointer_CALL_INSTANCE)); + CMOCK_glfwGetMonitorUserPointer_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMonitorUserPointer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetMonitorUserPointer_CallInstance = CMock_Guts_MemChain(Mock.glfwGetMonitorUserPointer_CallInstance, cmock_guts_index); + Mock.glfwGetMonitorUserPointer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetMonitorUserPointer_IgnoreBool = (char)1; +} + +void glfwGetMonitorUserPointer_CMockStopIgnore(void) +{ + if(Mock.glfwGetMonitorUserPointer_IgnoreBool) + Mock.glfwGetMonitorUserPointer_CallInstance = CMock_Guts_MemNext(Mock.glfwGetMonitorUserPointer_CallInstance); + Mock.glfwGetMonitorUserPointer_IgnoreBool = (char)0; +} + +void glfwGetMonitorUserPointer_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWmonitor* monitor, void* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetMonitorUserPointer_CALL_INSTANCE)); + CMOCK_glfwGetMonitorUserPointer_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMonitorUserPointer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetMonitorUserPointer_CallInstance = CMock_Guts_MemChain(Mock.glfwGetMonitorUserPointer_CallInstance, cmock_guts_index); + Mock.glfwGetMonitorUserPointer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetMonitorUserPointer(cmock_call_instance, monitor); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwGetMonitorUserPointer_AddCallback(CMOCK_glfwGetMonitorUserPointer_CALLBACK Callback) +{ + Mock.glfwGetMonitorUserPointer_IgnoreBool = (char)0; + Mock.glfwGetMonitorUserPointer_CallbackBool = (char)1; + Mock.glfwGetMonitorUserPointer_CallbackFunctionPointer = Callback; +} + +void glfwGetMonitorUserPointer_Stub(CMOCK_glfwGetMonitorUserPointer_CALLBACK Callback) +{ + Mock.glfwGetMonitorUserPointer_IgnoreBool = (char)0; + Mock.glfwGetMonitorUserPointer_CallbackBool = (char)0; + Mock.glfwGetMonitorUserPointer_CallbackFunctionPointer = Callback; +} + +void glfwGetMonitorUserPointer_CMockIgnoreArg_monitor(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetMonitorUserPointer_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMonitorUserPointer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetMonitorUserPointer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_monitor = 1; +} + +GLFWmonitorfun glfwSetMonitorCallback(GLFWmonitorfun callback) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetMonitorCallback_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetMonitorCallback); + cmock_call_instance = (CMOCK_glfwSetMonitorCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetMonitorCallback_CallInstance); + Mock.glfwSetMonitorCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetMonitorCallback_CallInstance); + if (Mock.glfwSetMonitorCallback_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwSetMonitorCallback_FinalReturn; + memcpy((void*)(&Mock.glfwSetMonitorCallback_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(GLFWmonitorfun[sizeof(cmock_call_instance->ReturnVal) == sizeof(GLFWmonitorfun) ? 1 : -1])); /* add GLFWmonitorfun to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwSetMonitorCallback_CallbackBool && + Mock.glfwSetMonitorCallback_CallbackFunctionPointer != NULL) + { + GLFWmonitorfun cmock_cb_ret = Mock.glfwSetMonitorCallback_CallbackFunctionPointer(callback, Mock.glfwSetMonitorCallback_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_callback) + { + UNITY_SET_DETAILS(CMockString_glfwSetMonitorCallback,CMockString_callback); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), sizeof(GLFWmonitorfun), cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetMonitorCallback_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwSetMonitorCallback_CallbackFunctionPointer(callback, Mock.glfwSetMonitorCallback_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwSetMonitorCallback(CMOCK_glfwSetMonitorCallback_CALL_INSTANCE* cmock_call_instance, GLFWmonitorfun callback); +void CMockExpectParameters_glfwSetMonitorCallback(CMOCK_glfwSetMonitorCallback_CALL_INSTANCE* cmock_call_instance, GLFWmonitorfun callback) +{ + memcpy((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), + sizeof(GLFWmonitorfun[sizeof(callback) == sizeof(GLFWmonitorfun) ? 1 : -1])); /* add GLFWmonitorfun to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_callback = 0; +} + +void glfwSetMonitorCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWmonitorfun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetMonitorCallback_CALL_INSTANCE)); + CMOCK_glfwSetMonitorCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetMonitorCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetMonitorCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetMonitorCallback_CallInstance, cmock_guts_index); + Mock.glfwSetMonitorCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwSetMonitorCallback_IgnoreBool = (char)1; +} + +void glfwSetMonitorCallback_CMockStopIgnore(void) +{ + if(Mock.glfwSetMonitorCallback_IgnoreBool) + Mock.glfwSetMonitorCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetMonitorCallback_CallInstance); + Mock.glfwSetMonitorCallback_IgnoreBool = (char)0; +} + +void glfwSetMonitorCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWmonitorfun callback, GLFWmonitorfun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetMonitorCallback_CALL_INSTANCE)); + CMOCK_glfwSetMonitorCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetMonitorCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetMonitorCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetMonitorCallback_CallInstance, cmock_guts_index); + Mock.glfwSetMonitorCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetMonitorCallback(cmock_call_instance, callback); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(GLFWmonitorfun[sizeof(cmock_to_return) == sizeof(GLFWmonitorfun) ? 1 : -1])); /* add GLFWmonitorfun to :treat_as_array if this causes an error */ +} + +void glfwSetMonitorCallback_AddCallback(CMOCK_glfwSetMonitorCallback_CALLBACK Callback) +{ + Mock.glfwSetMonitorCallback_IgnoreBool = (char)0; + Mock.glfwSetMonitorCallback_CallbackBool = (char)1; + Mock.glfwSetMonitorCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetMonitorCallback_Stub(CMOCK_glfwSetMonitorCallback_CALLBACK Callback) +{ + Mock.glfwSetMonitorCallback_IgnoreBool = (char)0; + Mock.glfwSetMonitorCallback_CallbackBool = (char)0; + Mock.glfwSetMonitorCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetMonitorCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetMonitorCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetMonitorCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetMonitorCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_callback = 1; +} + +const GLFWvidmode* glfwGetVideoModes(GLFWmonitor* monitor, int* count) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetVideoModes_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetVideoModes); + cmock_call_instance = (CMOCK_glfwGetVideoModes_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetVideoModes_CallInstance); + Mock.glfwGetVideoModes_CallInstance = CMock_Guts_MemNext(Mock.glfwGetVideoModes_CallInstance); + if (Mock.glfwGetVideoModes_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetVideoModes_FinalReturn; + Mock.glfwGetVideoModes_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetVideoModes_CallbackBool && + Mock.glfwGetVideoModes_CallbackFunctionPointer != NULL) + { + const GLFWvidmode* cmock_cb_ret = Mock.glfwGetVideoModes_CallbackFunctionPointer(monitor, count, Mock.glfwGetVideoModes_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_monitor) + { + UNITY_SET_DETAILS(CMockString_glfwGetVideoModes,CMockString_monitor); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_monitor, monitor, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_count) + { + UNITY_SET_DETAILS(CMockString_glfwGetVideoModes,CMockString_count); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_count, count, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetVideoModes_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetVideoModes_CallbackFunctionPointer(monitor, count, Mock.glfwGetVideoModes_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwGetVideoModes(CMOCK_glfwGetVideoModes_CALL_INSTANCE* cmock_call_instance, GLFWmonitor* monitor, int* count); +void CMockExpectParameters_glfwGetVideoModes(CMOCK_glfwGetVideoModes_CALL_INSTANCE* cmock_call_instance, GLFWmonitor* monitor, int* count) +{ + cmock_call_instance->Expected_monitor = monitor; + cmock_call_instance->IgnoreArg_monitor = 0; + cmock_call_instance->Expected_count = count; + cmock_call_instance->IgnoreArg_count = 0; +} + +void glfwGetVideoModes_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, const GLFWvidmode* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetVideoModes_CALL_INSTANCE)); + CMOCK_glfwGetVideoModes_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetVideoModes_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetVideoModes_CallInstance = CMock_Guts_MemChain(Mock.glfwGetVideoModes_CallInstance, cmock_guts_index); + Mock.glfwGetVideoModes_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetVideoModes_IgnoreBool = (char)1; +} + +void glfwGetVideoModes_CMockStopIgnore(void) +{ + if(Mock.glfwGetVideoModes_IgnoreBool) + Mock.glfwGetVideoModes_CallInstance = CMock_Guts_MemNext(Mock.glfwGetVideoModes_CallInstance); + Mock.glfwGetVideoModes_IgnoreBool = (char)0; +} + +void glfwGetVideoModes_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWmonitor* monitor, int* count, const GLFWvidmode* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetVideoModes_CALL_INSTANCE)); + CMOCK_glfwGetVideoModes_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetVideoModes_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetVideoModes_CallInstance = CMock_Guts_MemChain(Mock.glfwGetVideoModes_CallInstance, cmock_guts_index); + Mock.glfwGetVideoModes_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetVideoModes(cmock_call_instance, monitor, count); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwGetVideoModes_AddCallback(CMOCK_glfwGetVideoModes_CALLBACK Callback) +{ + Mock.glfwGetVideoModes_IgnoreBool = (char)0; + Mock.glfwGetVideoModes_CallbackBool = (char)1; + Mock.glfwGetVideoModes_CallbackFunctionPointer = Callback; +} + +void glfwGetVideoModes_Stub(CMOCK_glfwGetVideoModes_CALLBACK Callback) +{ + Mock.glfwGetVideoModes_IgnoreBool = (char)0; + Mock.glfwGetVideoModes_CallbackBool = (char)0; + Mock.glfwGetVideoModes_CallbackFunctionPointer = Callback; +} + +void glfwGetVideoModes_CMockIgnoreArg_monitor(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetVideoModes_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetVideoModes_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetVideoModes_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_monitor = 1; +} + +void glfwGetVideoModes_CMockIgnoreArg_count(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetVideoModes_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetVideoModes_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetVideoModes_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_count = 1; +} + +const GLFWvidmode* glfwGetVideoMode(GLFWmonitor* monitor) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetVideoMode_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetVideoMode); + cmock_call_instance = (CMOCK_glfwGetVideoMode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetVideoMode_CallInstance); + Mock.glfwGetVideoMode_CallInstance = CMock_Guts_MemNext(Mock.glfwGetVideoMode_CallInstance); + if (Mock.glfwGetVideoMode_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetVideoMode_FinalReturn; + Mock.glfwGetVideoMode_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetVideoMode_CallbackBool && + Mock.glfwGetVideoMode_CallbackFunctionPointer != NULL) + { + const GLFWvidmode* cmock_cb_ret = Mock.glfwGetVideoMode_CallbackFunctionPointer(monitor, Mock.glfwGetVideoMode_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_monitor) + { + UNITY_SET_DETAILS(CMockString_glfwGetVideoMode,CMockString_monitor); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_monitor, monitor, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetVideoMode_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetVideoMode_CallbackFunctionPointer(monitor, Mock.glfwGetVideoMode_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwGetVideoMode(CMOCK_glfwGetVideoMode_CALL_INSTANCE* cmock_call_instance, GLFWmonitor* monitor); +void CMockExpectParameters_glfwGetVideoMode(CMOCK_glfwGetVideoMode_CALL_INSTANCE* cmock_call_instance, GLFWmonitor* monitor) +{ + cmock_call_instance->Expected_monitor = monitor; + cmock_call_instance->IgnoreArg_monitor = 0; +} + +void glfwGetVideoMode_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, const GLFWvidmode* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetVideoMode_CALL_INSTANCE)); + CMOCK_glfwGetVideoMode_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetVideoMode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetVideoMode_CallInstance = CMock_Guts_MemChain(Mock.glfwGetVideoMode_CallInstance, cmock_guts_index); + Mock.glfwGetVideoMode_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetVideoMode_IgnoreBool = (char)1; +} + +void glfwGetVideoMode_CMockStopIgnore(void) +{ + if(Mock.glfwGetVideoMode_IgnoreBool) + Mock.glfwGetVideoMode_CallInstance = CMock_Guts_MemNext(Mock.glfwGetVideoMode_CallInstance); + Mock.glfwGetVideoMode_IgnoreBool = (char)0; +} + +void glfwGetVideoMode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWmonitor* monitor, const GLFWvidmode* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetVideoMode_CALL_INSTANCE)); + CMOCK_glfwGetVideoMode_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetVideoMode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetVideoMode_CallInstance = CMock_Guts_MemChain(Mock.glfwGetVideoMode_CallInstance, cmock_guts_index); + Mock.glfwGetVideoMode_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetVideoMode(cmock_call_instance, monitor); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwGetVideoMode_AddCallback(CMOCK_glfwGetVideoMode_CALLBACK Callback) +{ + Mock.glfwGetVideoMode_IgnoreBool = (char)0; + Mock.glfwGetVideoMode_CallbackBool = (char)1; + Mock.glfwGetVideoMode_CallbackFunctionPointer = Callback; +} + +void glfwGetVideoMode_Stub(CMOCK_glfwGetVideoMode_CALLBACK Callback) +{ + Mock.glfwGetVideoMode_IgnoreBool = (char)0; + Mock.glfwGetVideoMode_CallbackBool = (char)0; + Mock.glfwGetVideoMode_CallbackFunctionPointer = Callback; +} + +void glfwGetVideoMode_CMockIgnoreArg_monitor(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetVideoMode_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetVideoMode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetVideoMode_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_monitor = 1; +} + +void glfwSetGamma(GLFWmonitor* monitor, float gamma) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetGamma_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetGamma); + cmock_call_instance = (CMOCK_glfwSetGamma_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetGamma_CallInstance); + Mock.glfwSetGamma_CallInstance = CMock_Guts_MemNext(Mock.glfwSetGamma_CallInstance); + if (Mock.glfwSetGamma_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwSetGamma_CallbackBool && + Mock.glfwSetGamma_CallbackFunctionPointer != NULL) + { + Mock.glfwSetGamma_CallbackFunctionPointer(monitor, gamma, Mock.glfwSetGamma_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_monitor) + { + UNITY_SET_DETAILS(CMockString_glfwSetGamma,CMockString_monitor); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_monitor, monitor, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_gamma) + { + UNITY_SET_DETAILS(CMockString_glfwSetGamma,CMockString_gamma); + UNITY_TEST_ASSERT_EQUAL_FLOAT(cmock_call_instance->Expected_gamma, gamma, cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetGamma_CallbackFunctionPointer != NULL) + { + Mock.glfwSetGamma_CallbackFunctionPointer(monitor, gamma, Mock.glfwSetGamma_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwSetGamma(CMOCK_glfwSetGamma_CALL_INSTANCE* cmock_call_instance, GLFWmonitor* monitor, float gamma); +void CMockExpectParameters_glfwSetGamma(CMOCK_glfwSetGamma_CALL_INSTANCE* cmock_call_instance, GLFWmonitor* monitor, float gamma) +{ + cmock_call_instance->Expected_monitor = monitor; + cmock_call_instance->IgnoreArg_monitor = 0; + cmock_call_instance->Expected_gamma = gamma; + cmock_call_instance->IgnoreArg_gamma = 0; +} + +void glfwSetGamma_CMockIgnore(void) +{ + Mock.glfwSetGamma_IgnoreBool = (char)1; +} + +void glfwSetGamma_CMockStopIgnore(void) +{ + Mock.glfwSetGamma_IgnoreBool = (char)0; +} + +void glfwSetGamma_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWmonitor* monitor, float gamma) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetGamma_CALL_INSTANCE)); + CMOCK_glfwSetGamma_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetGamma_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetGamma_CallInstance = CMock_Guts_MemChain(Mock.glfwSetGamma_CallInstance, cmock_guts_index); + Mock.glfwSetGamma_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetGamma(cmock_call_instance, monitor, gamma); +} + +void glfwSetGamma_AddCallback(CMOCK_glfwSetGamma_CALLBACK Callback) +{ + Mock.glfwSetGamma_IgnoreBool = (char)0; + Mock.glfwSetGamma_CallbackBool = (char)1; + Mock.glfwSetGamma_CallbackFunctionPointer = Callback; +} + +void glfwSetGamma_Stub(CMOCK_glfwSetGamma_CALLBACK Callback) +{ + Mock.glfwSetGamma_IgnoreBool = (char)0; + Mock.glfwSetGamma_CallbackBool = (char)0; + Mock.glfwSetGamma_CallbackFunctionPointer = Callback; +} + +void glfwSetGamma_CMockIgnoreArg_monitor(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetGamma_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetGamma_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetGamma_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_monitor = 1; +} + +void glfwSetGamma_CMockIgnoreArg_gamma(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetGamma_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetGamma_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetGamma_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_gamma = 1; +} + +const GLFWgammaramp* glfwGetGammaRamp(GLFWmonitor* monitor) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetGammaRamp_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetGammaRamp); + cmock_call_instance = (CMOCK_glfwGetGammaRamp_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetGammaRamp_CallInstance); + Mock.glfwGetGammaRamp_CallInstance = CMock_Guts_MemNext(Mock.glfwGetGammaRamp_CallInstance); + if (Mock.glfwGetGammaRamp_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetGammaRamp_FinalReturn; + Mock.glfwGetGammaRamp_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetGammaRamp_CallbackBool && + Mock.glfwGetGammaRamp_CallbackFunctionPointer != NULL) + { + const GLFWgammaramp* cmock_cb_ret = Mock.glfwGetGammaRamp_CallbackFunctionPointer(monitor, Mock.glfwGetGammaRamp_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_monitor) + { + UNITY_SET_DETAILS(CMockString_glfwGetGammaRamp,CMockString_monitor); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_monitor, monitor, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetGammaRamp_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetGammaRamp_CallbackFunctionPointer(monitor, Mock.glfwGetGammaRamp_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwGetGammaRamp(CMOCK_glfwGetGammaRamp_CALL_INSTANCE* cmock_call_instance, GLFWmonitor* monitor); +void CMockExpectParameters_glfwGetGammaRamp(CMOCK_glfwGetGammaRamp_CALL_INSTANCE* cmock_call_instance, GLFWmonitor* monitor) +{ + cmock_call_instance->Expected_monitor = monitor; + cmock_call_instance->IgnoreArg_monitor = 0; +} + +void glfwGetGammaRamp_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, const GLFWgammaramp* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetGammaRamp_CALL_INSTANCE)); + CMOCK_glfwGetGammaRamp_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetGammaRamp_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetGammaRamp_CallInstance = CMock_Guts_MemChain(Mock.glfwGetGammaRamp_CallInstance, cmock_guts_index); + Mock.glfwGetGammaRamp_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetGammaRamp_IgnoreBool = (char)1; +} + +void glfwGetGammaRamp_CMockStopIgnore(void) +{ + if(Mock.glfwGetGammaRamp_IgnoreBool) + Mock.glfwGetGammaRamp_CallInstance = CMock_Guts_MemNext(Mock.glfwGetGammaRamp_CallInstance); + Mock.glfwGetGammaRamp_IgnoreBool = (char)0; +} + +void glfwGetGammaRamp_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWmonitor* monitor, const GLFWgammaramp* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetGammaRamp_CALL_INSTANCE)); + CMOCK_glfwGetGammaRamp_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetGammaRamp_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetGammaRamp_CallInstance = CMock_Guts_MemChain(Mock.glfwGetGammaRamp_CallInstance, cmock_guts_index); + Mock.glfwGetGammaRamp_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetGammaRamp(cmock_call_instance, monitor); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwGetGammaRamp_AddCallback(CMOCK_glfwGetGammaRamp_CALLBACK Callback) +{ + Mock.glfwGetGammaRamp_IgnoreBool = (char)0; + Mock.glfwGetGammaRamp_CallbackBool = (char)1; + Mock.glfwGetGammaRamp_CallbackFunctionPointer = Callback; +} + +void glfwGetGammaRamp_Stub(CMOCK_glfwGetGammaRamp_CALLBACK Callback) +{ + Mock.glfwGetGammaRamp_IgnoreBool = (char)0; + Mock.glfwGetGammaRamp_CallbackBool = (char)0; + Mock.glfwGetGammaRamp_CallbackFunctionPointer = Callback; +} + +void glfwGetGammaRamp_CMockIgnoreArg_monitor(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetGammaRamp_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetGammaRamp_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetGammaRamp_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_monitor = 1; +} + +void glfwSetGammaRamp(GLFWmonitor* monitor, const GLFWgammaramp* ramp) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetGammaRamp_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetGammaRamp); + cmock_call_instance = (CMOCK_glfwSetGammaRamp_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetGammaRamp_CallInstance); + Mock.glfwSetGammaRamp_CallInstance = CMock_Guts_MemNext(Mock.glfwSetGammaRamp_CallInstance); + if (Mock.glfwSetGammaRamp_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwSetGammaRamp_CallbackBool && + Mock.glfwSetGammaRamp_CallbackFunctionPointer != NULL) + { + Mock.glfwSetGammaRamp_CallbackFunctionPointer(monitor, ramp, Mock.glfwSetGammaRamp_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_monitor) + { + UNITY_SET_DETAILS(CMockString_glfwSetGammaRamp,CMockString_monitor); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_monitor, monitor, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_ramp) + { + UNITY_SET_DETAILS(CMockString_glfwSetGammaRamp,CMockString_ramp); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_ramp, ramp, cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetGammaRamp_CallbackFunctionPointer != NULL) + { + Mock.glfwSetGammaRamp_CallbackFunctionPointer(monitor, ramp, Mock.glfwSetGammaRamp_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwSetGammaRamp(CMOCK_glfwSetGammaRamp_CALL_INSTANCE* cmock_call_instance, GLFWmonitor* monitor, const GLFWgammaramp* ramp); +void CMockExpectParameters_glfwSetGammaRamp(CMOCK_glfwSetGammaRamp_CALL_INSTANCE* cmock_call_instance, GLFWmonitor* monitor, const GLFWgammaramp* ramp) +{ + cmock_call_instance->Expected_monitor = monitor; + cmock_call_instance->IgnoreArg_monitor = 0; + cmock_call_instance->Expected_ramp = ramp; + cmock_call_instance->IgnoreArg_ramp = 0; +} + +void glfwSetGammaRamp_CMockIgnore(void) +{ + Mock.glfwSetGammaRamp_IgnoreBool = (char)1; +} + +void glfwSetGammaRamp_CMockStopIgnore(void) +{ + Mock.glfwSetGammaRamp_IgnoreBool = (char)0; +} + +void glfwSetGammaRamp_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWmonitor* monitor, const GLFWgammaramp* ramp) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetGammaRamp_CALL_INSTANCE)); + CMOCK_glfwSetGammaRamp_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetGammaRamp_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetGammaRamp_CallInstance = CMock_Guts_MemChain(Mock.glfwSetGammaRamp_CallInstance, cmock_guts_index); + Mock.glfwSetGammaRamp_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetGammaRamp(cmock_call_instance, monitor, ramp); +} + +void glfwSetGammaRamp_AddCallback(CMOCK_glfwSetGammaRamp_CALLBACK Callback) +{ + Mock.glfwSetGammaRamp_IgnoreBool = (char)0; + Mock.glfwSetGammaRamp_CallbackBool = (char)1; + Mock.glfwSetGammaRamp_CallbackFunctionPointer = Callback; +} + +void glfwSetGammaRamp_Stub(CMOCK_glfwSetGammaRamp_CALLBACK Callback) +{ + Mock.glfwSetGammaRamp_IgnoreBool = (char)0; + Mock.glfwSetGammaRamp_CallbackBool = (char)0; + Mock.glfwSetGammaRamp_CallbackFunctionPointer = Callback; +} + +void glfwSetGammaRamp_CMockIgnoreArg_monitor(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetGammaRamp_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetGammaRamp_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetGammaRamp_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_monitor = 1; +} + +void glfwSetGammaRamp_CMockIgnoreArg_ramp(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetGammaRamp_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetGammaRamp_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetGammaRamp_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_ramp = 1; +} + +void glfwDefaultWindowHints(void) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwDefaultWindowHints_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwDefaultWindowHints); + cmock_call_instance = (CMOCK_glfwDefaultWindowHints_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwDefaultWindowHints_CallInstance); + Mock.glfwDefaultWindowHints_CallInstance = CMock_Guts_MemNext(Mock.glfwDefaultWindowHints_CallInstance); + if (Mock.glfwDefaultWindowHints_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwDefaultWindowHints_CallbackBool && + Mock.glfwDefaultWindowHints_CallbackFunctionPointer != NULL) + { + Mock.glfwDefaultWindowHints_CallbackFunctionPointer(Mock.glfwDefaultWindowHints_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (Mock.glfwDefaultWindowHints_CallbackFunctionPointer != NULL) + { + Mock.glfwDefaultWindowHints_CallbackFunctionPointer(Mock.glfwDefaultWindowHints_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void glfwDefaultWindowHints_CMockIgnore(void) +{ + Mock.glfwDefaultWindowHints_IgnoreBool = (char)1; +} + +void glfwDefaultWindowHints_CMockStopIgnore(void) +{ + Mock.glfwDefaultWindowHints_IgnoreBool = (char)0; +} + +void glfwDefaultWindowHints_CMockExpect(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwDefaultWindowHints_CALL_INSTANCE)); + CMOCK_glfwDefaultWindowHints_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwDefaultWindowHints_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwDefaultWindowHints_CallInstance = CMock_Guts_MemChain(Mock.glfwDefaultWindowHints_CallInstance, cmock_guts_index); + Mock.glfwDefaultWindowHints_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; +} + +void glfwDefaultWindowHints_AddCallback(CMOCK_glfwDefaultWindowHints_CALLBACK Callback) +{ + Mock.glfwDefaultWindowHints_IgnoreBool = (char)0; + Mock.glfwDefaultWindowHints_CallbackBool = (char)1; + Mock.glfwDefaultWindowHints_CallbackFunctionPointer = Callback; +} + +void glfwDefaultWindowHints_Stub(CMOCK_glfwDefaultWindowHints_CALLBACK Callback) +{ + Mock.glfwDefaultWindowHints_IgnoreBool = (char)0; + Mock.glfwDefaultWindowHints_CallbackBool = (char)0; + Mock.glfwDefaultWindowHints_CallbackFunctionPointer = Callback; +} + +void glfwWindowHint(int hint, int value) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwWindowHint_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwWindowHint); + cmock_call_instance = (CMOCK_glfwWindowHint_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwWindowHint_CallInstance); + Mock.glfwWindowHint_CallInstance = CMock_Guts_MemNext(Mock.glfwWindowHint_CallInstance); + if (Mock.glfwWindowHint_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwWindowHint_CallbackBool && + Mock.glfwWindowHint_CallbackFunctionPointer != NULL) + { + Mock.glfwWindowHint_CallbackFunctionPointer(hint, value, Mock.glfwWindowHint_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_hint) + { + UNITY_SET_DETAILS(CMockString_glfwWindowHint,CMockString_hint); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_hint, hint, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_value) + { + UNITY_SET_DETAILS(CMockString_glfwWindowHint,CMockString_value); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_value, value, cmock_line, CMockStringMismatch); + } + if (Mock.glfwWindowHint_CallbackFunctionPointer != NULL) + { + Mock.glfwWindowHint_CallbackFunctionPointer(hint, value, Mock.glfwWindowHint_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwWindowHint(CMOCK_glfwWindowHint_CALL_INSTANCE* cmock_call_instance, int hint, int value); +void CMockExpectParameters_glfwWindowHint(CMOCK_glfwWindowHint_CALL_INSTANCE* cmock_call_instance, int hint, int value) +{ + cmock_call_instance->Expected_hint = hint; + cmock_call_instance->IgnoreArg_hint = 0; + cmock_call_instance->Expected_value = value; + cmock_call_instance->IgnoreArg_value = 0; +} + +void glfwWindowHint_CMockIgnore(void) +{ + Mock.glfwWindowHint_IgnoreBool = (char)1; +} + +void glfwWindowHint_CMockStopIgnore(void) +{ + Mock.glfwWindowHint_IgnoreBool = (char)0; +} + +void glfwWindowHint_CMockExpect(UNITY_LINE_TYPE cmock_line, int hint, int value) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwWindowHint_CALL_INSTANCE)); + CMOCK_glfwWindowHint_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwWindowHint_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwWindowHint_CallInstance = CMock_Guts_MemChain(Mock.glfwWindowHint_CallInstance, cmock_guts_index); + Mock.glfwWindowHint_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwWindowHint(cmock_call_instance, hint, value); +} + +void glfwWindowHint_AddCallback(CMOCK_glfwWindowHint_CALLBACK Callback) +{ + Mock.glfwWindowHint_IgnoreBool = (char)0; + Mock.glfwWindowHint_CallbackBool = (char)1; + Mock.glfwWindowHint_CallbackFunctionPointer = Callback; +} + +void glfwWindowHint_Stub(CMOCK_glfwWindowHint_CALLBACK Callback) +{ + Mock.glfwWindowHint_IgnoreBool = (char)0; + Mock.glfwWindowHint_CallbackBool = (char)0; + Mock.glfwWindowHint_CallbackFunctionPointer = Callback; +} + +void glfwWindowHint_CMockIgnoreArg_hint(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwWindowHint_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwWindowHint_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwWindowHint_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_hint = 1; +} + +void glfwWindowHint_CMockIgnoreArg_value(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwWindowHint_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwWindowHint_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwWindowHint_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_value = 1; +} + +void glfwWindowHintString(int hint, const char* value) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwWindowHintString_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwWindowHintString); + cmock_call_instance = (CMOCK_glfwWindowHintString_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwWindowHintString_CallInstance); + Mock.glfwWindowHintString_CallInstance = CMock_Guts_MemNext(Mock.glfwWindowHintString_CallInstance); + if (Mock.glfwWindowHintString_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwWindowHintString_CallbackBool && + Mock.glfwWindowHintString_CallbackFunctionPointer != NULL) + { + Mock.glfwWindowHintString_CallbackFunctionPointer(hint, value, Mock.glfwWindowHintString_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_hint) + { + UNITY_SET_DETAILS(CMockString_glfwWindowHintString,CMockString_hint); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_hint, hint, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_value) + { + UNITY_SET_DETAILS(CMockString_glfwWindowHintString,CMockString_value); + UNITY_TEST_ASSERT_EQUAL_STRING(cmock_call_instance->Expected_value, value, cmock_line, CMockStringMismatch); + } + if (Mock.glfwWindowHintString_CallbackFunctionPointer != NULL) + { + Mock.glfwWindowHintString_CallbackFunctionPointer(hint, value, Mock.glfwWindowHintString_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwWindowHintString(CMOCK_glfwWindowHintString_CALL_INSTANCE* cmock_call_instance, int hint, const char* value); +void CMockExpectParameters_glfwWindowHintString(CMOCK_glfwWindowHintString_CALL_INSTANCE* cmock_call_instance, int hint, const char* value) +{ + cmock_call_instance->Expected_hint = hint; + cmock_call_instance->IgnoreArg_hint = 0; + cmock_call_instance->Expected_value = value; + cmock_call_instance->IgnoreArg_value = 0; +} + +void glfwWindowHintString_CMockIgnore(void) +{ + Mock.glfwWindowHintString_IgnoreBool = (char)1; +} + +void glfwWindowHintString_CMockStopIgnore(void) +{ + Mock.glfwWindowHintString_IgnoreBool = (char)0; +} + +void glfwWindowHintString_CMockExpect(UNITY_LINE_TYPE cmock_line, int hint, const char* value) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwWindowHintString_CALL_INSTANCE)); + CMOCK_glfwWindowHintString_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwWindowHintString_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwWindowHintString_CallInstance = CMock_Guts_MemChain(Mock.glfwWindowHintString_CallInstance, cmock_guts_index); + Mock.glfwWindowHintString_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwWindowHintString(cmock_call_instance, hint, value); +} + +void glfwWindowHintString_AddCallback(CMOCK_glfwWindowHintString_CALLBACK Callback) +{ + Mock.glfwWindowHintString_IgnoreBool = (char)0; + Mock.glfwWindowHintString_CallbackBool = (char)1; + Mock.glfwWindowHintString_CallbackFunctionPointer = Callback; +} + +void glfwWindowHintString_Stub(CMOCK_glfwWindowHintString_CALLBACK Callback) +{ + Mock.glfwWindowHintString_IgnoreBool = (char)0; + Mock.glfwWindowHintString_CallbackBool = (char)0; + Mock.glfwWindowHintString_CallbackFunctionPointer = Callback; +} + +void glfwWindowHintString_CMockIgnoreArg_hint(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwWindowHintString_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwWindowHintString_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwWindowHintString_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_hint = 1; +} + +void glfwWindowHintString_CMockIgnoreArg_value(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwWindowHintString_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwWindowHintString_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwWindowHintString_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_value = 1; +} + +GLFWwindow* glfwCreateWindow(int width, int height, const char* title, GLFWmonitor* monitor, GLFWwindow* share) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwCreateWindow_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwCreateWindow); + cmock_call_instance = (CMOCK_glfwCreateWindow_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwCreateWindow_CallInstance); + Mock.glfwCreateWindow_CallInstance = CMock_Guts_MemNext(Mock.glfwCreateWindow_CallInstance); + if (Mock.glfwCreateWindow_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwCreateWindow_FinalReturn; + Mock.glfwCreateWindow_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwCreateWindow_CallbackBool && + Mock.glfwCreateWindow_CallbackFunctionPointer != NULL) + { + GLFWwindow* cmock_cb_ret = Mock.glfwCreateWindow_CallbackFunctionPointer(width, height, title, monitor, share, Mock.glfwCreateWindow_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_width) + { + UNITY_SET_DETAILS(CMockString_glfwCreateWindow,CMockString_width); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_width, width, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_height) + { + UNITY_SET_DETAILS(CMockString_glfwCreateWindow,CMockString_height); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_height, height, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_title) + { + UNITY_SET_DETAILS(CMockString_glfwCreateWindow,CMockString_title); + UNITY_TEST_ASSERT_EQUAL_STRING(cmock_call_instance->Expected_title, title, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_monitor) + { + UNITY_SET_DETAILS(CMockString_glfwCreateWindow,CMockString_monitor); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_monitor, monitor, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_share) + { + UNITY_SET_DETAILS(CMockString_glfwCreateWindow,CMockString_share); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_share, share, cmock_line, CMockStringMismatch); + } + if (Mock.glfwCreateWindow_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwCreateWindow_CallbackFunctionPointer(width, height, title, monitor, share, Mock.glfwCreateWindow_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwCreateWindow(CMOCK_glfwCreateWindow_CALL_INSTANCE* cmock_call_instance, int width, int height, const char* title, GLFWmonitor* monitor, GLFWwindow* share); +void CMockExpectParameters_glfwCreateWindow(CMOCK_glfwCreateWindow_CALL_INSTANCE* cmock_call_instance, int width, int height, const char* title, GLFWmonitor* monitor, GLFWwindow* share) +{ + cmock_call_instance->Expected_width = width; + cmock_call_instance->IgnoreArg_width = 0; + cmock_call_instance->Expected_height = height; + cmock_call_instance->IgnoreArg_height = 0; + cmock_call_instance->Expected_title = title; + cmock_call_instance->IgnoreArg_title = 0; + cmock_call_instance->Expected_monitor = monitor; + cmock_call_instance->IgnoreArg_monitor = 0; + cmock_call_instance->Expected_share = share; + cmock_call_instance->IgnoreArg_share = 0; +} + +void glfwCreateWindow_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwCreateWindow_CALL_INSTANCE)); + CMOCK_glfwCreateWindow_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwCreateWindow_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwCreateWindow_CallInstance = CMock_Guts_MemChain(Mock.glfwCreateWindow_CallInstance, cmock_guts_index); + Mock.glfwCreateWindow_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwCreateWindow_IgnoreBool = (char)1; +} + +void glfwCreateWindow_CMockStopIgnore(void) +{ + if(Mock.glfwCreateWindow_IgnoreBool) + Mock.glfwCreateWindow_CallInstance = CMock_Guts_MemNext(Mock.glfwCreateWindow_CallInstance); + Mock.glfwCreateWindow_IgnoreBool = (char)0; +} + +void glfwCreateWindow_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int width, int height, const char* title, GLFWmonitor* monitor, GLFWwindow* share, GLFWwindow* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwCreateWindow_CALL_INSTANCE)); + CMOCK_glfwCreateWindow_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwCreateWindow_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwCreateWindow_CallInstance = CMock_Guts_MemChain(Mock.glfwCreateWindow_CallInstance, cmock_guts_index); + Mock.glfwCreateWindow_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwCreateWindow(cmock_call_instance, width, height, title, monitor, share); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwCreateWindow_AddCallback(CMOCK_glfwCreateWindow_CALLBACK Callback) +{ + Mock.glfwCreateWindow_IgnoreBool = (char)0; + Mock.glfwCreateWindow_CallbackBool = (char)1; + Mock.glfwCreateWindow_CallbackFunctionPointer = Callback; +} + +void glfwCreateWindow_Stub(CMOCK_glfwCreateWindow_CALLBACK Callback) +{ + Mock.glfwCreateWindow_IgnoreBool = (char)0; + Mock.glfwCreateWindow_CallbackBool = (char)0; + Mock.glfwCreateWindow_CallbackFunctionPointer = Callback; +} + +void glfwCreateWindow_CMockIgnoreArg_width(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwCreateWindow_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwCreateWindow_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwCreateWindow_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_width = 1; +} + +void glfwCreateWindow_CMockIgnoreArg_height(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwCreateWindow_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwCreateWindow_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwCreateWindow_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_height = 1; +} + +void glfwCreateWindow_CMockIgnoreArg_title(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwCreateWindow_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwCreateWindow_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwCreateWindow_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_title = 1; +} + +void glfwCreateWindow_CMockIgnoreArg_monitor(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwCreateWindow_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwCreateWindow_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwCreateWindow_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_monitor = 1; +} + +void glfwCreateWindow_CMockIgnoreArg_share(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwCreateWindow_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwCreateWindow_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwCreateWindow_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_share = 1; +} + +void glfwDestroyWindow(GLFWwindow* window) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwDestroyWindow_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwDestroyWindow); + cmock_call_instance = (CMOCK_glfwDestroyWindow_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwDestroyWindow_CallInstance); + Mock.glfwDestroyWindow_CallInstance = CMock_Guts_MemNext(Mock.glfwDestroyWindow_CallInstance); + if (Mock.glfwDestroyWindow_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwDestroyWindow_CallbackBool && + Mock.glfwDestroyWindow_CallbackFunctionPointer != NULL) + { + Mock.glfwDestroyWindow_CallbackFunctionPointer(window, Mock.glfwDestroyWindow_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwDestroyWindow,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (Mock.glfwDestroyWindow_CallbackFunctionPointer != NULL) + { + Mock.glfwDestroyWindow_CallbackFunctionPointer(window, Mock.glfwDestroyWindow_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwDestroyWindow(CMOCK_glfwDestroyWindow_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window); +void CMockExpectParameters_glfwDestroyWindow(CMOCK_glfwDestroyWindow_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; +} + +void glfwDestroyWindow_CMockIgnore(void) +{ + Mock.glfwDestroyWindow_IgnoreBool = (char)1; +} + +void glfwDestroyWindow_CMockStopIgnore(void) +{ + Mock.glfwDestroyWindow_IgnoreBool = (char)0; +} + +void glfwDestroyWindow_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwDestroyWindow_CALL_INSTANCE)); + CMOCK_glfwDestroyWindow_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwDestroyWindow_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwDestroyWindow_CallInstance = CMock_Guts_MemChain(Mock.glfwDestroyWindow_CallInstance, cmock_guts_index); + Mock.glfwDestroyWindow_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwDestroyWindow(cmock_call_instance, window); +} + +void glfwDestroyWindow_AddCallback(CMOCK_glfwDestroyWindow_CALLBACK Callback) +{ + Mock.glfwDestroyWindow_IgnoreBool = (char)0; + Mock.glfwDestroyWindow_CallbackBool = (char)1; + Mock.glfwDestroyWindow_CallbackFunctionPointer = Callback; +} + +void glfwDestroyWindow_Stub(CMOCK_glfwDestroyWindow_CALLBACK Callback) +{ + Mock.glfwDestroyWindow_IgnoreBool = (char)0; + Mock.glfwDestroyWindow_CallbackBool = (char)0; + Mock.glfwDestroyWindow_CallbackFunctionPointer = Callback; +} + +void glfwDestroyWindow_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwDestroyWindow_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwDestroyWindow_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwDestroyWindow_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +int glfwWindowShouldClose(GLFWwindow* window) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwWindowShouldClose_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwWindowShouldClose); + cmock_call_instance = (CMOCK_glfwWindowShouldClose_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwWindowShouldClose_CallInstance); + Mock.glfwWindowShouldClose_CallInstance = CMock_Guts_MemNext(Mock.glfwWindowShouldClose_CallInstance); + if (Mock.glfwWindowShouldClose_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwWindowShouldClose_FinalReturn; + Mock.glfwWindowShouldClose_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwWindowShouldClose_CallbackBool && + Mock.glfwWindowShouldClose_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.glfwWindowShouldClose_CallbackFunctionPointer(window, Mock.glfwWindowShouldClose_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwWindowShouldClose,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (Mock.glfwWindowShouldClose_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwWindowShouldClose_CallbackFunctionPointer(window, Mock.glfwWindowShouldClose_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwWindowShouldClose(CMOCK_glfwWindowShouldClose_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window); +void CMockExpectParameters_glfwWindowShouldClose(CMOCK_glfwWindowShouldClose_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; +} + +void glfwWindowShouldClose_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwWindowShouldClose_CALL_INSTANCE)); + CMOCK_glfwWindowShouldClose_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwWindowShouldClose_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwWindowShouldClose_CallInstance = CMock_Guts_MemChain(Mock.glfwWindowShouldClose_CallInstance, cmock_guts_index); + Mock.glfwWindowShouldClose_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwWindowShouldClose_IgnoreBool = (char)1; +} + +void glfwWindowShouldClose_CMockStopIgnore(void) +{ + if(Mock.glfwWindowShouldClose_IgnoreBool) + Mock.glfwWindowShouldClose_CallInstance = CMock_Guts_MemNext(Mock.glfwWindowShouldClose_CallInstance); + Mock.glfwWindowShouldClose_IgnoreBool = (char)0; +} + +void glfwWindowShouldClose_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwWindowShouldClose_CALL_INSTANCE)); + CMOCK_glfwWindowShouldClose_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwWindowShouldClose_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwWindowShouldClose_CallInstance = CMock_Guts_MemChain(Mock.glfwWindowShouldClose_CallInstance, cmock_guts_index); + Mock.glfwWindowShouldClose_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwWindowShouldClose(cmock_call_instance, window); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwWindowShouldClose_AddCallback(CMOCK_glfwWindowShouldClose_CALLBACK Callback) +{ + Mock.glfwWindowShouldClose_IgnoreBool = (char)0; + Mock.glfwWindowShouldClose_CallbackBool = (char)1; + Mock.glfwWindowShouldClose_CallbackFunctionPointer = Callback; +} + +void glfwWindowShouldClose_Stub(CMOCK_glfwWindowShouldClose_CALLBACK Callback) +{ + Mock.glfwWindowShouldClose_IgnoreBool = (char)0; + Mock.glfwWindowShouldClose_CallbackBool = (char)0; + Mock.glfwWindowShouldClose_CallbackFunctionPointer = Callback; +} + +void glfwWindowShouldClose_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwWindowShouldClose_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwWindowShouldClose_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwWindowShouldClose_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetWindowShouldClose(GLFWwindow* window, int value) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetWindowShouldClose_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetWindowShouldClose); + cmock_call_instance = (CMOCK_glfwSetWindowShouldClose_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetWindowShouldClose_CallInstance); + Mock.glfwSetWindowShouldClose_CallInstance = CMock_Guts_MemNext(Mock.glfwSetWindowShouldClose_CallInstance); + if (Mock.glfwSetWindowShouldClose_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwSetWindowShouldClose_CallbackBool && + Mock.glfwSetWindowShouldClose_CallbackFunctionPointer != NULL) + { + Mock.glfwSetWindowShouldClose_CallbackFunctionPointer(window, value, Mock.glfwSetWindowShouldClose_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowShouldClose,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_value) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowShouldClose,CMockString_value); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_value, value, cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetWindowShouldClose_CallbackFunctionPointer != NULL) + { + Mock.glfwSetWindowShouldClose_CallbackFunctionPointer(window, value, Mock.glfwSetWindowShouldClose_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwSetWindowShouldClose(CMOCK_glfwSetWindowShouldClose_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int value); +void CMockExpectParameters_glfwSetWindowShouldClose(CMOCK_glfwSetWindowShouldClose_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int value) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + cmock_call_instance->Expected_value = value; + cmock_call_instance->IgnoreArg_value = 0; +} + +void glfwSetWindowShouldClose_CMockIgnore(void) +{ + Mock.glfwSetWindowShouldClose_IgnoreBool = (char)1; +} + +void glfwSetWindowShouldClose_CMockStopIgnore(void) +{ + Mock.glfwSetWindowShouldClose_IgnoreBool = (char)0; +} + +void glfwSetWindowShouldClose_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int value) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetWindowShouldClose_CALL_INSTANCE)); + CMOCK_glfwSetWindowShouldClose_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowShouldClose_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetWindowShouldClose_CallInstance = CMock_Guts_MemChain(Mock.glfwSetWindowShouldClose_CallInstance, cmock_guts_index); + Mock.glfwSetWindowShouldClose_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetWindowShouldClose(cmock_call_instance, window, value); +} + +void glfwSetWindowShouldClose_AddCallback(CMOCK_glfwSetWindowShouldClose_CALLBACK Callback) +{ + Mock.glfwSetWindowShouldClose_IgnoreBool = (char)0; + Mock.glfwSetWindowShouldClose_CallbackBool = (char)1; + Mock.glfwSetWindowShouldClose_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowShouldClose_Stub(CMOCK_glfwSetWindowShouldClose_CALLBACK Callback) +{ + Mock.glfwSetWindowShouldClose_IgnoreBool = (char)0; + Mock.glfwSetWindowShouldClose_CallbackBool = (char)0; + Mock.glfwSetWindowShouldClose_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowShouldClose_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowShouldClose_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowShouldClose_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowShouldClose_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetWindowShouldClose_CMockIgnoreArg_value(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowShouldClose_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowShouldClose_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowShouldClose_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_value = 1; +} + +void glfwSetWindowTitle(GLFWwindow* window, const char* title) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetWindowTitle_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetWindowTitle); + cmock_call_instance = (CMOCK_glfwSetWindowTitle_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetWindowTitle_CallInstance); + Mock.glfwSetWindowTitle_CallInstance = CMock_Guts_MemNext(Mock.glfwSetWindowTitle_CallInstance); + if (Mock.glfwSetWindowTitle_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwSetWindowTitle_CallbackBool && + Mock.glfwSetWindowTitle_CallbackFunctionPointer != NULL) + { + Mock.glfwSetWindowTitle_CallbackFunctionPointer(window, title, Mock.glfwSetWindowTitle_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowTitle,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_title) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowTitle,CMockString_title); + UNITY_TEST_ASSERT_EQUAL_STRING(cmock_call_instance->Expected_title, title, cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetWindowTitle_CallbackFunctionPointer != NULL) + { + Mock.glfwSetWindowTitle_CallbackFunctionPointer(window, title, Mock.glfwSetWindowTitle_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwSetWindowTitle(CMOCK_glfwSetWindowTitle_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, const char* title); +void CMockExpectParameters_glfwSetWindowTitle(CMOCK_glfwSetWindowTitle_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, const char* title) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + cmock_call_instance->Expected_title = title; + cmock_call_instance->IgnoreArg_title = 0; +} + +void glfwSetWindowTitle_CMockIgnore(void) +{ + Mock.glfwSetWindowTitle_IgnoreBool = (char)1; +} + +void glfwSetWindowTitle_CMockStopIgnore(void) +{ + Mock.glfwSetWindowTitle_IgnoreBool = (char)0; +} + +void glfwSetWindowTitle_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, const char* title) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetWindowTitle_CALL_INSTANCE)); + CMOCK_glfwSetWindowTitle_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowTitle_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetWindowTitle_CallInstance = CMock_Guts_MemChain(Mock.glfwSetWindowTitle_CallInstance, cmock_guts_index); + Mock.glfwSetWindowTitle_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetWindowTitle(cmock_call_instance, window, title); +} + +void glfwSetWindowTitle_AddCallback(CMOCK_glfwSetWindowTitle_CALLBACK Callback) +{ + Mock.glfwSetWindowTitle_IgnoreBool = (char)0; + Mock.glfwSetWindowTitle_CallbackBool = (char)1; + Mock.glfwSetWindowTitle_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowTitle_Stub(CMOCK_glfwSetWindowTitle_CALLBACK Callback) +{ + Mock.glfwSetWindowTitle_IgnoreBool = (char)0; + Mock.glfwSetWindowTitle_CallbackBool = (char)0; + Mock.glfwSetWindowTitle_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowTitle_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowTitle_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowTitle_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowTitle_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetWindowTitle_CMockIgnoreArg_title(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowTitle_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowTitle_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowTitle_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_title = 1; +} + +void glfwSetWindowIcon(GLFWwindow* window, int count, const GLFWimage* images) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetWindowIcon_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetWindowIcon); + cmock_call_instance = (CMOCK_glfwSetWindowIcon_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetWindowIcon_CallInstance); + Mock.glfwSetWindowIcon_CallInstance = CMock_Guts_MemNext(Mock.glfwSetWindowIcon_CallInstance); + if (Mock.glfwSetWindowIcon_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwSetWindowIcon_CallbackBool && + Mock.glfwSetWindowIcon_CallbackFunctionPointer != NULL) + { + Mock.glfwSetWindowIcon_CallbackFunctionPointer(window, count, images, Mock.glfwSetWindowIcon_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowIcon,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_count) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowIcon,CMockString_count); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_count, count, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_images) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowIcon,CMockString_images); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_images, images, cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetWindowIcon_CallbackFunctionPointer != NULL) + { + Mock.glfwSetWindowIcon_CallbackFunctionPointer(window, count, images, Mock.glfwSetWindowIcon_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwSetWindowIcon(CMOCK_glfwSetWindowIcon_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int count, const GLFWimage* images); +void CMockExpectParameters_glfwSetWindowIcon(CMOCK_glfwSetWindowIcon_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int count, const GLFWimage* images) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + cmock_call_instance->Expected_count = count; + cmock_call_instance->IgnoreArg_count = 0; + cmock_call_instance->Expected_images = images; + cmock_call_instance->IgnoreArg_images = 0; +} + +void glfwSetWindowIcon_CMockIgnore(void) +{ + Mock.glfwSetWindowIcon_IgnoreBool = (char)1; +} + +void glfwSetWindowIcon_CMockStopIgnore(void) +{ + Mock.glfwSetWindowIcon_IgnoreBool = (char)0; +} + +void glfwSetWindowIcon_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int count, const GLFWimage* images) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetWindowIcon_CALL_INSTANCE)); + CMOCK_glfwSetWindowIcon_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowIcon_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetWindowIcon_CallInstance = CMock_Guts_MemChain(Mock.glfwSetWindowIcon_CallInstance, cmock_guts_index); + Mock.glfwSetWindowIcon_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetWindowIcon(cmock_call_instance, window, count, images); +} + +void glfwSetWindowIcon_AddCallback(CMOCK_glfwSetWindowIcon_CALLBACK Callback) +{ + Mock.glfwSetWindowIcon_IgnoreBool = (char)0; + Mock.glfwSetWindowIcon_CallbackBool = (char)1; + Mock.glfwSetWindowIcon_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowIcon_Stub(CMOCK_glfwSetWindowIcon_CALLBACK Callback) +{ + Mock.glfwSetWindowIcon_IgnoreBool = (char)0; + Mock.glfwSetWindowIcon_CallbackBool = (char)0; + Mock.glfwSetWindowIcon_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowIcon_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowIcon_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowIcon_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowIcon_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetWindowIcon_CMockIgnoreArg_count(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowIcon_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowIcon_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowIcon_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_count = 1; +} + +void glfwSetWindowIcon_CMockIgnoreArg_images(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowIcon_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowIcon_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowIcon_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_images = 1; +} + +void glfwGetWindowPos(GLFWwindow* window, int* xpos, int* ypos) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetWindowPos_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetWindowPos); + cmock_call_instance = (CMOCK_glfwGetWindowPos_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetWindowPos_CallInstance); + Mock.glfwGetWindowPos_CallInstance = CMock_Guts_MemNext(Mock.glfwGetWindowPos_CallInstance); + if (Mock.glfwGetWindowPos_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwGetWindowPos_CallbackBool && + Mock.glfwGetWindowPos_CallbackFunctionPointer != NULL) + { + Mock.glfwGetWindowPos_CallbackFunctionPointer(window, xpos, ypos, Mock.glfwGetWindowPos_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwGetWindowPos,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_xpos) + { + UNITY_SET_DETAILS(CMockString_glfwGetWindowPos,CMockString_xpos); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_xpos, xpos, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_ypos) + { + UNITY_SET_DETAILS(CMockString_glfwGetWindowPos,CMockString_ypos); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_ypos, ypos, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetWindowPos_CallbackFunctionPointer != NULL) + { + Mock.glfwGetWindowPos_CallbackFunctionPointer(window, xpos, ypos, Mock.glfwGetWindowPos_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwGetWindowPos(CMOCK_glfwGetWindowPos_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int* xpos, int* ypos); +void CMockExpectParameters_glfwGetWindowPos(CMOCK_glfwGetWindowPos_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int* xpos, int* ypos) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + cmock_call_instance->Expected_xpos = xpos; + cmock_call_instance->IgnoreArg_xpos = 0; + cmock_call_instance->Expected_ypos = ypos; + cmock_call_instance->IgnoreArg_ypos = 0; +} + +void glfwGetWindowPos_CMockIgnore(void) +{ + Mock.glfwGetWindowPos_IgnoreBool = (char)1; +} + +void glfwGetWindowPos_CMockStopIgnore(void) +{ + Mock.glfwGetWindowPos_IgnoreBool = (char)0; +} + +void glfwGetWindowPos_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int* xpos, int* ypos) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetWindowPos_CALL_INSTANCE)); + CMOCK_glfwGetWindowPos_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowPos_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetWindowPos_CallInstance = CMock_Guts_MemChain(Mock.glfwGetWindowPos_CallInstance, cmock_guts_index); + Mock.glfwGetWindowPos_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetWindowPos(cmock_call_instance, window, xpos, ypos); +} + +void glfwGetWindowPos_AddCallback(CMOCK_glfwGetWindowPos_CALLBACK Callback) +{ + Mock.glfwGetWindowPos_IgnoreBool = (char)0; + Mock.glfwGetWindowPos_CallbackBool = (char)1; + Mock.glfwGetWindowPos_CallbackFunctionPointer = Callback; +} + +void glfwGetWindowPos_Stub(CMOCK_glfwGetWindowPos_CALLBACK Callback) +{ + Mock.glfwGetWindowPos_IgnoreBool = (char)0; + Mock.glfwGetWindowPos_CallbackBool = (char)0; + Mock.glfwGetWindowPos_CallbackFunctionPointer = Callback; +} + +void glfwGetWindowPos_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetWindowPos_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowPos_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetWindowPos_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwGetWindowPos_CMockIgnoreArg_xpos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetWindowPos_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowPos_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetWindowPos_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_xpos = 1; +} + +void glfwGetWindowPos_CMockIgnoreArg_ypos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetWindowPos_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowPos_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetWindowPos_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_ypos = 1; +} + +void glfwSetWindowPos(GLFWwindow* window, int xpos, int ypos) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetWindowPos_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetWindowPos); + cmock_call_instance = (CMOCK_glfwSetWindowPos_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetWindowPos_CallInstance); + Mock.glfwSetWindowPos_CallInstance = CMock_Guts_MemNext(Mock.glfwSetWindowPos_CallInstance); + if (Mock.glfwSetWindowPos_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwSetWindowPos_CallbackBool && + Mock.glfwSetWindowPos_CallbackFunctionPointer != NULL) + { + Mock.glfwSetWindowPos_CallbackFunctionPointer(window, xpos, ypos, Mock.glfwSetWindowPos_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowPos,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_xpos) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowPos,CMockString_xpos); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_xpos, xpos, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_ypos) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowPos,CMockString_ypos); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_ypos, ypos, cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetWindowPos_CallbackFunctionPointer != NULL) + { + Mock.glfwSetWindowPos_CallbackFunctionPointer(window, xpos, ypos, Mock.glfwSetWindowPos_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwSetWindowPos(CMOCK_glfwSetWindowPos_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int xpos, int ypos); +void CMockExpectParameters_glfwSetWindowPos(CMOCK_glfwSetWindowPos_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int xpos, int ypos) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + cmock_call_instance->Expected_xpos = xpos; + cmock_call_instance->IgnoreArg_xpos = 0; + cmock_call_instance->Expected_ypos = ypos; + cmock_call_instance->IgnoreArg_ypos = 0; +} + +void glfwSetWindowPos_CMockIgnore(void) +{ + Mock.glfwSetWindowPos_IgnoreBool = (char)1; +} + +void glfwSetWindowPos_CMockStopIgnore(void) +{ + Mock.glfwSetWindowPos_IgnoreBool = (char)0; +} + +void glfwSetWindowPos_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int xpos, int ypos) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetWindowPos_CALL_INSTANCE)); + CMOCK_glfwSetWindowPos_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowPos_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetWindowPos_CallInstance = CMock_Guts_MemChain(Mock.glfwSetWindowPos_CallInstance, cmock_guts_index); + Mock.glfwSetWindowPos_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetWindowPos(cmock_call_instance, window, xpos, ypos); +} + +void glfwSetWindowPos_AddCallback(CMOCK_glfwSetWindowPos_CALLBACK Callback) +{ + Mock.glfwSetWindowPos_IgnoreBool = (char)0; + Mock.glfwSetWindowPos_CallbackBool = (char)1; + Mock.glfwSetWindowPos_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowPos_Stub(CMOCK_glfwSetWindowPos_CALLBACK Callback) +{ + Mock.glfwSetWindowPos_IgnoreBool = (char)0; + Mock.glfwSetWindowPos_CallbackBool = (char)0; + Mock.glfwSetWindowPos_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowPos_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowPos_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowPos_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowPos_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetWindowPos_CMockIgnoreArg_xpos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowPos_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowPos_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowPos_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_xpos = 1; +} + +void glfwSetWindowPos_CMockIgnoreArg_ypos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowPos_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowPos_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowPos_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_ypos = 1; +} + +void glfwGetWindowSize(GLFWwindow* window, int* width, int* height) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetWindowSize_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetWindowSize); + cmock_call_instance = (CMOCK_glfwGetWindowSize_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetWindowSize_CallInstance); + Mock.glfwGetWindowSize_CallInstance = CMock_Guts_MemNext(Mock.glfwGetWindowSize_CallInstance); + if (Mock.glfwGetWindowSize_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwGetWindowSize_CallbackBool && + Mock.glfwGetWindowSize_CallbackFunctionPointer != NULL) + { + Mock.glfwGetWindowSize_CallbackFunctionPointer(window, width, height, Mock.glfwGetWindowSize_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwGetWindowSize,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_width) + { + UNITY_SET_DETAILS(CMockString_glfwGetWindowSize,CMockString_width); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_width, width, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_height) + { + UNITY_SET_DETAILS(CMockString_glfwGetWindowSize,CMockString_height); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_height, height, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetWindowSize_CallbackFunctionPointer != NULL) + { + Mock.glfwGetWindowSize_CallbackFunctionPointer(window, width, height, Mock.glfwGetWindowSize_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwGetWindowSize(CMOCK_glfwGetWindowSize_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int* width, int* height); +void CMockExpectParameters_glfwGetWindowSize(CMOCK_glfwGetWindowSize_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int* width, int* height) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + cmock_call_instance->Expected_width = width; + cmock_call_instance->IgnoreArg_width = 0; + cmock_call_instance->Expected_height = height; + cmock_call_instance->IgnoreArg_height = 0; +} + +void glfwGetWindowSize_CMockIgnore(void) +{ + Mock.glfwGetWindowSize_IgnoreBool = (char)1; +} + +void glfwGetWindowSize_CMockStopIgnore(void) +{ + Mock.glfwGetWindowSize_IgnoreBool = (char)0; +} + +void glfwGetWindowSize_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int* width, int* height) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetWindowSize_CALL_INSTANCE)); + CMOCK_glfwGetWindowSize_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowSize_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetWindowSize_CallInstance = CMock_Guts_MemChain(Mock.glfwGetWindowSize_CallInstance, cmock_guts_index); + Mock.glfwGetWindowSize_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetWindowSize(cmock_call_instance, window, width, height); +} + +void glfwGetWindowSize_AddCallback(CMOCK_glfwGetWindowSize_CALLBACK Callback) +{ + Mock.glfwGetWindowSize_IgnoreBool = (char)0; + Mock.glfwGetWindowSize_CallbackBool = (char)1; + Mock.glfwGetWindowSize_CallbackFunctionPointer = Callback; +} + +void glfwGetWindowSize_Stub(CMOCK_glfwGetWindowSize_CALLBACK Callback) +{ + Mock.glfwGetWindowSize_IgnoreBool = (char)0; + Mock.glfwGetWindowSize_CallbackBool = (char)0; + Mock.glfwGetWindowSize_CallbackFunctionPointer = Callback; +} + +void glfwGetWindowSize_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetWindowSize_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowSize_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetWindowSize_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwGetWindowSize_CMockIgnoreArg_width(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetWindowSize_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowSize_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetWindowSize_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_width = 1; +} + +void glfwGetWindowSize_CMockIgnoreArg_height(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetWindowSize_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowSize_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetWindowSize_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_height = 1; +} + +void glfwSetWindowSizeLimits(GLFWwindow* window, int minwidth, int minheight, int maxwidth, int maxheight) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetWindowSizeLimits_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetWindowSizeLimits); + cmock_call_instance = (CMOCK_glfwSetWindowSizeLimits_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetWindowSizeLimits_CallInstance); + Mock.glfwSetWindowSizeLimits_CallInstance = CMock_Guts_MemNext(Mock.glfwSetWindowSizeLimits_CallInstance); + if (Mock.glfwSetWindowSizeLimits_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwSetWindowSizeLimits_CallbackBool && + Mock.glfwSetWindowSizeLimits_CallbackFunctionPointer != NULL) + { + Mock.glfwSetWindowSizeLimits_CallbackFunctionPointer(window, minwidth, minheight, maxwidth, maxheight, Mock.glfwSetWindowSizeLimits_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowSizeLimits,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_minwidth) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowSizeLimits,CMockString_minwidth); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_minwidth, minwidth, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_minheight) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowSizeLimits,CMockString_minheight); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_minheight, minheight, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_maxwidth) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowSizeLimits,CMockString_maxwidth); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_maxwidth, maxwidth, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_maxheight) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowSizeLimits,CMockString_maxheight); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_maxheight, maxheight, cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetWindowSizeLimits_CallbackFunctionPointer != NULL) + { + Mock.glfwSetWindowSizeLimits_CallbackFunctionPointer(window, minwidth, minheight, maxwidth, maxheight, Mock.glfwSetWindowSizeLimits_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwSetWindowSizeLimits(CMOCK_glfwSetWindowSizeLimits_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int minwidth, int minheight, int maxwidth, int maxheight); +void CMockExpectParameters_glfwSetWindowSizeLimits(CMOCK_glfwSetWindowSizeLimits_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int minwidth, int minheight, int maxwidth, int maxheight) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + cmock_call_instance->Expected_minwidth = minwidth; + cmock_call_instance->IgnoreArg_minwidth = 0; + cmock_call_instance->Expected_minheight = minheight; + cmock_call_instance->IgnoreArg_minheight = 0; + cmock_call_instance->Expected_maxwidth = maxwidth; + cmock_call_instance->IgnoreArg_maxwidth = 0; + cmock_call_instance->Expected_maxheight = maxheight; + cmock_call_instance->IgnoreArg_maxheight = 0; +} + +void glfwSetWindowSizeLimits_CMockIgnore(void) +{ + Mock.glfwSetWindowSizeLimits_IgnoreBool = (char)1; +} + +void glfwSetWindowSizeLimits_CMockStopIgnore(void) +{ + Mock.glfwSetWindowSizeLimits_IgnoreBool = (char)0; +} + +void glfwSetWindowSizeLimits_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int minwidth, int minheight, int maxwidth, int maxheight) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetWindowSizeLimits_CALL_INSTANCE)); + CMOCK_glfwSetWindowSizeLimits_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowSizeLimits_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetWindowSizeLimits_CallInstance = CMock_Guts_MemChain(Mock.glfwSetWindowSizeLimits_CallInstance, cmock_guts_index); + Mock.glfwSetWindowSizeLimits_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetWindowSizeLimits(cmock_call_instance, window, minwidth, minheight, maxwidth, maxheight); +} + +void glfwSetWindowSizeLimits_AddCallback(CMOCK_glfwSetWindowSizeLimits_CALLBACK Callback) +{ + Mock.glfwSetWindowSizeLimits_IgnoreBool = (char)0; + Mock.glfwSetWindowSizeLimits_CallbackBool = (char)1; + Mock.glfwSetWindowSizeLimits_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowSizeLimits_Stub(CMOCK_glfwSetWindowSizeLimits_CALLBACK Callback) +{ + Mock.glfwSetWindowSizeLimits_IgnoreBool = (char)0; + Mock.glfwSetWindowSizeLimits_CallbackBool = (char)0; + Mock.glfwSetWindowSizeLimits_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowSizeLimits_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowSizeLimits_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowSizeLimits_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowSizeLimits_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetWindowSizeLimits_CMockIgnoreArg_minwidth(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowSizeLimits_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowSizeLimits_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowSizeLimits_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_minwidth = 1; +} + +void glfwSetWindowSizeLimits_CMockIgnoreArg_minheight(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowSizeLimits_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowSizeLimits_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowSizeLimits_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_minheight = 1; +} + +void glfwSetWindowSizeLimits_CMockIgnoreArg_maxwidth(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowSizeLimits_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowSizeLimits_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowSizeLimits_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_maxwidth = 1; +} + +void glfwSetWindowSizeLimits_CMockIgnoreArg_maxheight(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowSizeLimits_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowSizeLimits_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowSizeLimits_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_maxheight = 1; +} + +void glfwSetWindowAspectRatio(GLFWwindow* window, int numer, int denom) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetWindowAspectRatio_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetWindowAspectRatio); + cmock_call_instance = (CMOCK_glfwSetWindowAspectRatio_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetWindowAspectRatio_CallInstance); + Mock.glfwSetWindowAspectRatio_CallInstance = CMock_Guts_MemNext(Mock.glfwSetWindowAspectRatio_CallInstance); + if (Mock.glfwSetWindowAspectRatio_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwSetWindowAspectRatio_CallbackBool && + Mock.glfwSetWindowAspectRatio_CallbackFunctionPointer != NULL) + { + Mock.glfwSetWindowAspectRatio_CallbackFunctionPointer(window, numer, denom, Mock.glfwSetWindowAspectRatio_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowAspectRatio,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_numer) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowAspectRatio,CMockString_numer); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_numer, numer, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_denom) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowAspectRatio,CMockString_denom); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_denom, denom, cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetWindowAspectRatio_CallbackFunctionPointer != NULL) + { + Mock.glfwSetWindowAspectRatio_CallbackFunctionPointer(window, numer, denom, Mock.glfwSetWindowAspectRatio_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwSetWindowAspectRatio(CMOCK_glfwSetWindowAspectRatio_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int numer, int denom); +void CMockExpectParameters_glfwSetWindowAspectRatio(CMOCK_glfwSetWindowAspectRatio_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int numer, int denom) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + cmock_call_instance->Expected_numer = numer; + cmock_call_instance->IgnoreArg_numer = 0; + cmock_call_instance->Expected_denom = denom; + cmock_call_instance->IgnoreArg_denom = 0; +} + +void glfwSetWindowAspectRatio_CMockIgnore(void) +{ + Mock.glfwSetWindowAspectRatio_IgnoreBool = (char)1; +} + +void glfwSetWindowAspectRatio_CMockStopIgnore(void) +{ + Mock.glfwSetWindowAspectRatio_IgnoreBool = (char)0; +} + +void glfwSetWindowAspectRatio_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int numer, int denom) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetWindowAspectRatio_CALL_INSTANCE)); + CMOCK_glfwSetWindowAspectRatio_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowAspectRatio_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetWindowAspectRatio_CallInstance = CMock_Guts_MemChain(Mock.glfwSetWindowAspectRatio_CallInstance, cmock_guts_index); + Mock.glfwSetWindowAspectRatio_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetWindowAspectRatio(cmock_call_instance, window, numer, denom); +} + +void glfwSetWindowAspectRatio_AddCallback(CMOCK_glfwSetWindowAspectRatio_CALLBACK Callback) +{ + Mock.glfwSetWindowAspectRatio_IgnoreBool = (char)0; + Mock.glfwSetWindowAspectRatio_CallbackBool = (char)1; + Mock.glfwSetWindowAspectRatio_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowAspectRatio_Stub(CMOCK_glfwSetWindowAspectRatio_CALLBACK Callback) +{ + Mock.glfwSetWindowAspectRatio_IgnoreBool = (char)0; + Mock.glfwSetWindowAspectRatio_CallbackBool = (char)0; + Mock.glfwSetWindowAspectRatio_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowAspectRatio_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowAspectRatio_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowAspectRatio_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowAspectRatio_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetWindowAspectRatio_CMockIgnoreArg_numer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowAspectRatio_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowAspectRatio_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowAspectRatio_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_numer = 1; +} + +void glfwSetWindowAspectRatio_CMockIgnoreArg_denom(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowAspectRatio_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowAspectRatio_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowAspectRatio_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_denom = 1; +} + +void glfwSetWindowSize(GLFWwindow* window, int width, int height) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetWindowSize_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetWindowSize); + cmock_call_instance = (CMOCK_glfwSetWindowSize_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetWindowSize_CallInstance); + Mock.glfwSetWindowSize_CallInstance = CMock_Guts_MemNext(Mock.glfwSetWindowSize_CallInstance); + if (Mock.glfwSetWindowSize_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwSetWindowSize_CallbackBool && + Mock.glfwSetWindowSize_CallbackFunctionPointer != NULL) + { + Mock.glfwSetWindowSize_CallbackFunctionPointer(window, width, height, Mock.glfwSetWindowSize_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowSize,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_width) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowSize,CMockString_width); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_width, width, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_height) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowSize,CMockString_height); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_height, height, cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetWindowSize_CallbackFunctionPointer != NULL) + { + Mock.glfwSetWindowSize_CallbackFunctionPointer(window, width, height, Mock.glfwSetWindowSize_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwSetWindowSize(CMOCK_glfwSetWindowSize_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int width, int height); +void CMockExpectParameters_glfwSetWindowSize(CMOCK_glfwSetWindowSize_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int width, int height) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + cmock_call_instance->Expected_width = width; + cmock_call_instance->IgnoreArg_width = 0; + cmock_call_instance->Expected_height = height; + cmock_call_instance->IgnoreArg_height = 0; +} + +void glfwSetWindowSize_CMockIgnore(void) +{ + Mock.glfwSetWindowSize_IgnoreBool = (char)1; +} + +void glfwSetWindowSize_CMockStopIgnore(void) +{ + Mock.glfwSetWindowSize_IgnoreBool = (char)0; +} + +void glfwSetWindowSize_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int width, int height) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetWindowSize_CALL_INSTANCE)); + CMOCK_glfwSetWindowSize_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowSize_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetWindowSize_CallInstance = CMock_Guts_MemChain(Mock.glfwSetWindowSize_CallInstance, cmock_guts_index); + Mock.glfwSetWindowSize_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetWindowSize(cmock_call_instance, window, width, height); +} + +void glfwSetWindowSize_AddCallback(CMOCK_glfwSetWindowSize_CALLBACK Callback) +{ + Mock.glfwSetWindowSize_IgnoreBool = (char)0; + Mock.glfwSetWindowSize_CallbackBool = (char)1; + Mock.glfwSetWindowSize_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowSize_Stub(CMOCK_glfwSetWindowSize_CALLBACK Callback) +{ + Mock.glfwSetWindowSize_IgnoreBool = (char)0; + Mock.glfwSetWindowSize_CallbackBool = (char)0; + Mock.glfwSetWindowSize_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowSize_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowSize_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowSize_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowSize_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetWindowSize_CMockIgnoreArg_width(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowSize_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowSize_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowSize_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_width = 1; +} + +void glfwSetWindowSize_CMockIgnoreArg_height(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowSize_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowSize_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowSize_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_height = 1; +} + +void glfwGetFramebufferSize(GLFWwindow* window, int* width, int* height) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetFramebufferSize_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetFramebufferSize); + cmock_call_instance = (CMOCK_glfwGetFramebufferSize_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetFramebufferSize_CallInstance); + Mock.glfwGetFramebufferSize_CallInstance = CMock_Guts_MemNext(Mock.glfwGetFramebufferSize_CallInstance); + if (Mock.glfwGetFramebufferSize_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwGetFramebufferSize_CallbackBool && + Mock.glfwGetFramebufferSize_CallbackFunctionPointer != NULL) + { + Mock.glfwGetFramebufferSize_CallbackFunctionPointer(window, width, height, Mock.glfwGetFramebufferSize_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwGetFramebufferSize,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_width) + { + UNITY_SET_DETAILS(CMockString_glfwGetFramebufferSize,CMockString_width); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_width, width, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_height) + { + UNITY_SET_DETAILS(CMockString_glfwGetFramebufferSize,CMockString_height); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_height, height, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetFramebufferSize_CallbackFunctionPointer != NULL) + { + Mock.glfwGetFramebufferSize_CallbackFunctionPointer(window, width, height, Mock.glfwGetFramebufferSize_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwGetFramebufferSize(CMOCK_glfwGetFramebufferSize_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int* width, int* height); +void CMockExpectParameters_glfwGetFramebufferSize(CMOCK_glfwGetFramebufferSize_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int* width, int* height) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + cmock_call_instance->Expected_width = width; + cmock_call_instance->IgnoreArg_width = 0; + cmock_call_instance->Expected_height = height; + cmock_call_instance->IgnoreArg_height = 0; +} + +void glfwGetFramebufferSize_CMockIgnore(void) +{ + Mock.glfwGetFramebufferSize_IgnoreBool = (char)1; +} + +void glfwGetFramebufferSize_CMockStopIgnore(void) +{ + Mock.glfwGetFramebufferSize_IgnoreBool = (char)0; +} + +void glfwGetFramebufferSize_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int* width, int* height) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetFramebufferSize_CALL_INSTANCE)); + CMOCK_glfwGetFramebufferSize_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetFramebufferSize_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetFramebufferSize_CallInstance = CMock_Guts_MemChain(Mock.glfwGetFramebufferSize_CallInstance, cmock_guts_index); + Mock.glfwGetFramebufferSize_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetFramebufferSize(cmock_call_instance, window, width, height); +} + +void glfwGetFramebufferSize_AddCallback(CMOCK_glfwGetFramebufferSize_CALLBACK Callback) +{ + Mock.glfwGetFramebufferSize_IgnoreBool = (char)0; + Mock.glfwGetFramebufferSize_CallbackBool = (char)1; + Mock.glfwGetFramebufferSize_CallbackFunctionPointer = Callback; +} + +void glfwGetFramebufferSize_Stub(CMOCK_glfwGetFramebufferSize_CALLBACK Callback) +{ + Mock.glfwGetFramebufferSize_IgnoreBool = (char)0; + Mock.glfwGetFramebufferSize_CallbackBool = (char)0; + Mock.glfwGetFramebufferSize_CallbackFunctionPointer = Callback; +} + +void glfwGetFramebufferSize_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetFramebufferSize_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetFramebufferSize_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetFramebufferSize_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwGetFramebufferSize_CMockIgnoreArg_width(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetFramebufferSize_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetFramebufferSize_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetFramebufferSize_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_width = 1; +} + +void glfwGetFramebufferSize_CMockIgnoreArg_height(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetFramebufferSize_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetFramebufferSize_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetFramebufferSize_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_height = 1; +} + +void glfwGetWindowFrameSize(GLFWwindow* window, int* left, int* top, int* right, int* bottom) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetWindowFrameSize_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetWindowFrameSize); + cmock_call_instance = (CMOCK_glfwGetWindowFrameSize_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetWindowFrameSize_CallInstance); + Mock.glfwGetWindowFrameSize_CallInstance = CMock_Guts_MemNext(Mock.glfwGetWindowFrameSize_CallInstance); + if (Mock.glfwGetWindowFrameSize_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwGetWindowFrameSize_CallbackBool && + Mock.glfwGetWindowFrameSize_CallbackFunctionPointer != NULL) + { + Mock.glfwGetWindowFrameSize_CallbackFunctionPointer(window, left, top, right, bottom, Mock.glfwGetWindowFrameSize_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwGetWindowFrameSize,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_left) + { + UNITY_SET_DETAILS(CMockString_glfwGetWindowFrameSize,CMockString_left); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_left, left, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_top) + { + UNITY_SET_DETAILS(CMockString_glfwGetWindowFrameSize,CMockString_top); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_top, top, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_right) + { + UNITY_SET_DETAILS(CMockString_glfwGetWindowFrameSize,CMockString_right); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_right, right, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_bottom) + { + UNITY_SET_DETAILS(CMockString_glfwGetWindowFrameSize,CMockString_bottom); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_bottom, bottom, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetWindowFrameSize_CallbackFunctionPointer != NULL) + { + Mock.glfwGetWindowFrameSize_CallbackFunctionPointer(window, left, top, right, bottom, Mock.glfwGetWindowFrameSize_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwGetWindowFrameSize(CMOCK_glfwGetWindowFrameSize_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int* left, int* top, int* right, int* bottom); +void CMockExpectParameters_glfwGetWindowFrameSize(CMOCK_glfwGetWindowFrameSize_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int* left, int* top, int* right, int* bottom) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + cmock_call_instance->Expected_left = left; + cmock_call_instance->IgnoreArg_left = 0; + cmock_call_instance->Expected_top = top; + cmock_call_instance->IgnoreArg_top = 0; + cmock_call_instance->Expected_right = right; + cmock_call_instance->IgnoreArg_right = 0; + cmock_call_instance->Expected_bottom = bottom; + cmock_call_instance->IgnoreArg_bottom = 0; +} + +void glfwGetWindowFrameSize_CMockIgnore(void) +{ + Mock.glfwGetWindowFrameSize_IgnoreBool = (char)1; +} + +void glfwGetWindowFrameSize_CMockStopIgnore(void) +{ + Mock.glfwGetWindowFrameSize_IgnoreBool = (char)0; +} + +void glfwGetWindowFrameSize_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int* left, int* top, int* right, int* bottom) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetWindowFrameSize_CALL_INSTANCE)); + CMOCK_glfwGetWindowFrameSize_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowFrameSize_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetWindowFrameSize_CallInstance = CMock_Guts_MemChain(Mock.glfwGetWindowFrameSize_CallInstance, cmock_guts_index); + Mock.glfwGetWindowFrameSize_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetWindowFrameSize(cmock_call_instance, window, left, top, right, bottom); +} + +void glfwGetWindowFrameSize_AddCallback(CMOCK_glfwGetWindowFrameSize_CALLBACK Callback) +{ + Mock.glfwGetWindowFrameSize_IgnoreBool = (char)0; + Mock.glfwGetWindowFrameSize_CallbackBool = (char)1; + Mock.glfwGetWindowFrameSize_CallbackFunctionPointer = Callback; +} + +void glfwGetWindowFrameSize_Stub(CMOCK_glfwGetWindowFrameSize_CALLBACK Callback) +{ + Mock.glfwGetWindowFrameSize_IgnoreBool = (char)0; + Mock.glfwGetWindowFrameSize_CallbackBool = (char)0; + Mock.glfwGetWindowFrameSize_CallbackFunctionPointer = Callback; +} + +void glfwGetWindowFrameSize_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetWindowFrameSize_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowFrameSize_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetWindowFrameSize_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwGetWindowFrameSize_CMockIgnoreArg_left(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetWindowFrameSize_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowFrameSize_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetWindowFrameSize_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_left = 1; +} + +void glfwGetWindowFrameSize_CMockIgnoreArg_top(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetWindowFrameSize_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowFrameSize_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetWindowFrameSize_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_top = 1; +} + +void glfwGetWindowFrameSize_CMockIgnoreArg_right(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetWindowFrameSize_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowFrameSize_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetWindowFrameSize_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_right = 1; +} + +void glfwGetWindowFrameSize_CMockIgnoreArg_bottom(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetWindowFrameSize_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowFrameSize_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetWindowFrameSize_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_bottom = 1; +} + +void glfwGetWindowContentScale(GLFWwindow* window, float* xscale, float* yscale) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetWindowContentScale_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetWindowContentScale); + cmock_call_instance = (CMOCK_glfwGetWindowContentScale_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetWindowContentScale_CallInstance); + Mock.glfwGetWindowContentScale_CallInstance = CMock_Guts_MemNext(Mock.glfwGetWindowContentScale_CallInstance); + if (Mock.glfwGetWindowContentScale_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwGetWindowContentScale_CallbackBool && + Mock.glfwGetWindowContentScale_CallbackFunctionPointer != NULL) + { + Mock.glfwGetWindowContentScale_CallbackFunctionPointer(window, xscale, yscale, Mock.glfwGetWindowContentScale_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwGetWindowContentScale,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_xscale) + { + UNITY_SET_DETAILS(CMockString_glfwGetWindowContentScale,CMockString_xscale); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_xscale, xscale, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_yscale) + { + UNITY_SET_DETAILS(CMockString_glfwGetWindowContentScale,CMockString_yscale); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_yscale, yscale, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetWindowContentScale_CallbackFunctionPointer != NULL) + { + Mock.glfwGetWindowContentScale_CallbackFunctionPointer(window, xscale, yscale, Mock.glfwGetWindowContentScale_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwGetWindowContentScale(CMOCK_glfwGetWindowContentScale_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, float* xscale, float* yscale); +void CMockExpectParameters_glfwGetWindowContentScale(CMOCK_glfwGetWindowContentScale_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, float* xscale, float* yscale) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + cmock_call_instance->Expected_xscale = xscale; + cmock_call_instance->IgnoreArg_xscale = 0; + cmock_call_instance->Expected_yscale = yscale; + cmock_call_instance->IgnoreArg_yscale = 0; +} + +void glfwGetWindowContentScale_CMockIgnore(void) +{ + Mock.glfwGetWindowContentScale_IgnoreBool = (char)1; +} + +void glfwGetWindowContentScale_CMockStopIgnore(void) +{ + Mock.glfwGetWindowContentScale_IgnoreBool = (char)0; +} + +void glfwGetWindowContentScale_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, float* xscale, float* yscale) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetWindowContentScale_CALL_INSTANCE)); + CMOCK_glfwGetWindowContentScale_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowContentScale_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetWindowContentScale_CallInstance = CMock_Guts_MemChain(Mock.glfwGetWindowContentScale_CallInstance, cmock_guts_index); + Mock.glfwGetWindowContentScale_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetWindowContentScale(cmock_call_instance, window, xscale, yscale); +} + +void glfwGetWindowContentScale_AddCallback(CMOCK_glfwGetWindowContentScale_CALLBACK Callback) +{ + Mock.glfwGetWindowContentScale_IgnoreBool = (char)0; + Mock.glfwGetWindowContentScale_CallbackBool = (char)1; + Mock.glfwGetWindowContentScale_CallbackFunctionPointer = Callback; +} + +void glfwGetWindowContentScale_Stub(CMOCK_glfwGetWindowContentScale_CALLBACK Callback) +{ + Mock.glfwGetWindowContentScale_IgnoreBool = (char)0; + Mock.glfwGetWindowContentScale_CallbackBool = (char)0; + Mock.glfwGetWindowContentScale_CallbackFunctionPointer = Callback; +} + +void glfwGetWindowContentScale_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetWindowContentScale_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowContentScale_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetWindowContentScale_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwGetWindowContentScale_CMockIgnoreArg_xscale(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetWindowContentScale_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowContentScale_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetWindowContentScale_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_xscale = 1; +} + +void glfwGetWindowContentScale_CMockIgnoreArg_yscale(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetWindowContentScale_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowContentScale_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetWindowContentScale_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_yscale = 1; +} + +float glfwGetWindowOpacity(GLFWwindow* window) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetWindowOpacity_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetWindowOpacity); + cmock_call_instance = (CMOCK_glfwGetWindowOpacity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetWindowOpacity_CallInstance); + Mock.glfwGetWindowOpacity_CallInstance = CMock_Guts_MemNext(Mock.glfwGetWindowOpacity_CallInstance); + if (Mock.glfwGetWindowOpacity_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetWindowOpacity_FinalReturn; + Mock.glfwGetWindowOpacity_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetWindowOpacity_CallbackBool && + Mock.glfwGetWindowOpacity_CallbackFunctionPointer != NULL) + { + float cmock_cb_ret = Mock.glfwGetWindowOpacity_CallbackFunctionPointer(window, Mock.glfwGetWindowOpacity_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwGetWindowOpacity,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetWindowOpacity_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetWindowOpacity_CallbackFunctionPointer(window, Mock.glfwGetWindowOpacity_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwGetWindowOpacity(CMOCK_glfwGetWindowOpacity_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window); +void CMockExpectParameters_glfwGetWindowOpacity(CMOCK_glfwGetWindowOpacity_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; +} + +void glfwGetWindowOpacity_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, float cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetWindowOpacity_CALL_INSTANCE)); + CMOCK_glfwGetWindowOpacity_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowOpacity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetWindowOpacity_CallInstance = CMock_Guts_MemChain(Mock.glfwGetWindowOpacity_CallInstance, cmock_guts_index); + Mock.glfwGetWindowOpacity_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetWindowOpacity_IgnoreBool = (char)1; +} + +void glfwGetWindowOpacity_CMockStopIgnore(void) +{ + if(Mock.glfwGetWindowOpacity_IgnoreBool) + Mock.glfwGetWindowOpacity_CallInstance = CMock_Guts_MemNext(Mock.glfwGetWindowOpacity_CallInstance); + Mock.glfwGetWindowOpacity_IgnoreBool = (char)0; +} + +void glfwGetWindowOpacity_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, float cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetWindowOpacity_CALL_INSTANCE)); + CMOCK_glfwGetWindowOpacity_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowOpacity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetWindowOpacity_CallInstance = CMock_Guts_MemChain(Mock.glfwGetWindowOpacity_CallInstance, cmock_guts_index); + Mock.glfwGetWindowOpacity_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetWindowOpacity(cmock_call_instance, window); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwGetWindowOpacity_AddCallback(CMOCK_glfwGetWindowOpacity_CALLBACK Callback) +{ + Mock.glfwGetWindowOpacity_IgnoreBool = (char)0; + Mock.glfwGetWindowOpacity_CallbackBool = (char)1; + Mock.glfwGetWindowOpacity_CallbackFunctionPointer = Callback; +} + +void glfwGetWindowOpacity_Stub(CMOCK_glfwGetWindowOpacity_CALLBACK Callback) +{ + Mock.glfwGetWindowOpacity_IgnoreBool = (char)0; + Mock.glfwGetWindowOpacity_CallbackBool = (char)0; + Mock.glfwGetWindowOpacity_CallbackFunctionPointer = Callback; +} + +void glfwGetWindowOpacity_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetWindowOpacity_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowOpacity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetWindowOpacity_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetWindowOpacity(GLFWwindow* window, float opacity) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetWindowOpacity_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetWindowOpacity); + cmock_call_instance = (CMOCK_glfwSetWindowOpacity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetWindowOpacity_CallInstance); + Mock.glfwSetWindowOpacity_CallInstance = CMock_Guts_MemNext(Mock.glfwSetWindowOpacity_CallInstance); + if (Mock.glfwSetWindowOpacity_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwSetWindowOpacity_CallbackBool && + Mock.glfwSetWindowOpacity_CallbackFunctionPointer != NULL) + { + Mock.glfwSetWindowOpacity_CallbackFunctionPointer(window, opacity, Mock.glfwSetWindowOpacity_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowOpacity,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_opacity) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowOpacity,CMockString_opacity); + UNITY_TEST_ASSERT_EQUAL_FLOAT(cmock_call_instance->Expected_opacity, opacity, cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetWindowOpacity_CallbackFunctionPointer != NULL) + { + Mock.glfwSetWindowOpacity_CallbackFunctionPointer(window, opacity, Mock.glfwSetWindowOpacity_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwSetWindowOpacity(CMOCK_glfwSetWindowOpacity_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, float opacity); +void CMockExpectParameters_glfwSetWindowOpacity(CMOCK_glfwSetWindowOpacity_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, float opacity) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + cmock_call_instance->Expected_opacity = opacity; + cmock_call_instance->IgnoreArg_opacity = 0; +} + +void glfwSetWindowOpacity_CMockIgnore(void) +{ + Mock.glfwSetWindowOpacity_IgnoreBool = (char)1; +} + +void glfwSetWindowOpacity_CMockStopIgnore(void) +{ + Mock.glfwSetWindowOpacity_IgnoreBool = (char)0; +} + +void glfwSetWindowOpacity_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, float opacity) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetWindowOpacity_CALL_INSTANCE)); + CMOCK_glfwSetWindowOpacity_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowOpacity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetWindowOpacity_CallInstance = CMock_Guts_MemChain(Mock.glfwSetWindowOpacity_CallInstance, cmock_guts_index); + Mock.glfwSetWindowOpacity_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetWindowOpacity(cmock_call_instance, window, opacity); +} + +void glfwSetWindowOpacity_AddCallback(CMOCK_glfwSetWindowOpacity_CALLBACK Callback) +{ + Mock.glfwSetWindowOpacity_IgnoreBool = (char)0; + Mock.glfwSetWindowOpacity_CallbackBool = (char)1; + Mock.glfwSetWindowOpacity_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowOpacity_Stub(CMOCK_glfwSetWindowOpacity_CALLBACK Callback) +{ + Mock.glfwSetWindowOpacity_IgnoreBool = (char)0; + Mock.glfwSetWindowOpacity_CallbackBool = (char)0; + Mock.glfwSetWindowOpacity_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowOpacity_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowOpacity_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowOpacity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowOpacity_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetWindowOpacity_CMockIgnoreArg_opacity(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowOpacity_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowOpacity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowOpacity_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_opacity = 1; +} + +void glfwIconifyWindow(GLFWwindow* window) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwIconifyWindow_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwIconifyWindow); + cmock_call_instance = (CMOCK_glfwIconifyWindow_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwIconifyWindow_CallInstance); + Mock.glfwIconifyWindow_CallInstance = CMock_Guts_MemNext(Mock.glfwIconifyWindow_CallInstance); + if (Mock.glfwIconifyWindow_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwIconifyWindow_CallbackBool && + Mock.glfwIconifyWindow_CallbackFunctionPointer != NULL) + { + Mock.glfwIconifyWindow_CallbackFunctionPointer(window, Mock.glfwIconifyWindow_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwIconifyWindow,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (Mock.glfwIconifyWindow_CallbackFunctionPointer != NULL) + { + Mock.glfwIconifyWindow_CallbackFunctionPointer(window, Mock.glfwIconifyWindow_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwIconifyWindow(CMOCK_glfwIconifyWindow_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window); +void CMockExpectParameters_glfwIconifyWindow(CMOCK_glfwIconifyWindow_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; +} + +void glfwIconifyWindow_CMockIgnore(void) +{ + Mock.glfwIconifyWindow_IgnoreBool = (char)1; +} + +void glfwIconifyWindow_CMockStopIgnore(void) +{ + Mock.glfwIconifyWindow_IgnoreBool = (char)0; +} + +void glfwIconifyWindow_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwIconifyWindow_CALL_INSTANCE)); + CMOCK_glfwIconifyWindow_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwIconifyWindow_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwIconifyWindow_CallInstance = CMock_Guts_MemChain(Mock.glfwIconifyWindow_CallInstance, cmock_guts_index); + Mock.glfwIconifyWindow_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwIconifyWindow(cmock_call_instance, window); +} + +void glfwIconifyWindow_AddCallback(CMOCK_glfwIconifyWindow_CALLBACK Callback) +{ + Mock.glfwIconifyWindow_IgnoreBool = (char)0; + Mock.glfwIconifyWindow_CallbackBool = (char)1; + Mock.glfwIconifyWindow_CallbackFunctionPointer = Callback; +} + +void glfwIconifyWindow_Stub(CMOCK_glfwIconifyWindow_CALLBACK Callback) +{ + Mock.glfwIconifyWindow_IgnoreBool = (char)0; + Mock.glfwIconifyWindow_CallbackBool = (char)0; + Mock.glfwIconifyWindow_CallbackFunctionPointer = Callback; +} + +void glfwIconifyWindow_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwIconifyWindow_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwIconifyWindow_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwIconifyWindow_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwRestoreWindow(GLFWwindow* window) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwRestoreWindow_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwRestoreWindow); + cmock_call_instance = (CMOCK_glfwRestoreWindow_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwRestoreWindow_CallInstance); + Mock.glfwRestoreWindow_CallInstance = CMock_Guts_MemNext(Mock.glfwRestoreWindow_CallInstance); + if (Mock.glfwRestoreWindow_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwRestoreWindow_CallbackBool && + Mock.glfwRestoreWindow_CallbackFunctionPointer != NULL) + { + Mock.glfwRestoreWindow_CallbackFunctionPointer(window, Mock.glfwRestoreWindow_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwRestoreWindow,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (Mock.glfwRestoreWindow_CallbackFunctionPointer != NULL) + { + Mock.glfwRestoreWindow_CallbackFunctionPointer(window, Mock.glfwRestoreWindow_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwRestoreWindow(CMOCK_glfwRestoreWindow_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window); +void CMockExpectParameters_glfwRestoreWindow(CMOCK_glfwRestoreWindow_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; +} + +void glfwRestoreWindow_CMockIgnore(void) +{ + Mock.glfwRestoreWindow_IgnoreBool = (char)1; +} + +void glfwRestoreWindow_CMockStopIgnore(void) +{ + Mock.glfwRestoreWindow_IgnoreBool = (char)0; +} + +void glfwRestoreWindow_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwRestoreWindow_CALL_INSTANCE)); + CMOCK_glfwRestoreWindow_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwRestoreWindow_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwRestoreWindow_CallInstance = CMock_Guts_MemChain(Mock.glfwRestoreWindow_CallInstance, cmock_guts_index); + Mock.glfwRestoreWindow_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwRestoreWindow(cmock_call_instance, window); +} + +void glfwRestoreWindow_AddCallback(CMOCK_glfwRestoreWindow_CALLBACK Callback) +{ + Mock.glfwRestoreWindow_IgnoreBool = (char)0; + Mock.glfwRestoreWindow_CallbackBool = (char)1; + Mock.glfwRestoreWindow_CallbackFunctionPointer = Callback; +} + +void glfwRestoreWindow_Stub(CMOCK_glfwRestoreWindow_CALLBACK Callback) +{ + Mock.glfwRestoreWindow_IgnoreBool = (char)0; + Mock.glfwRestoreWindow_CallbackBool = (char)0; + Mock.glfwRestoreWindow_CallbackFunctionPointer = Callback; +} + +void glfwRestoreWindow_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwRestoreWindow_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwRestoreWindow_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwRestoreWindow_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwMaximizeWindow(GLFWwindow* window) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwMaximizeWindow_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwMaximizeWindow); + cmock_call_instance = (CMOCK_glfwMaximizeWindow_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwMaximizeWindow_CallInstance); + Mock.glfwMaximizeWindow_CallInstance = CMock_Guts_MemNext(Mock.glfwMaximizeWindow_CallInstance); + if (Mock.glfwMaximizeWindow_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwMaximizeWindow_CallbackBool && + Mock.glfwMaximizeWindow_CallbackFunctionPointer != NULL) + { + Mock.glfwMaximizeWindow_CallbackFunctionPointer(window, Mock.glfwMaximizeWindow_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwMaximizeWindow,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (Mock.glfwMaximizeWindow_CallbackFunctionPointer != NULL) + { + Mock.glfwMaximizeWindow_CallbackFunctionPointer(window, Mock.glfwMaximizeWindow_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwMaximizeWindow(CMOCK_glfwMaximizeWindow_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window); +void CMockExpectParameters_glfwMaximizeWindow(CMOCK_glfwMaximizeWindow_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; +} + +void glfwMaximizeWindow_CMockIgnore(void) +{ + Mock.glfwMaximizeWindow_IgnoreBool = (char)1; +} + +void glfwMaximizeWindow_CMockStopIgnore(void) +{ + Mock.glfwMaximizeWindow_IgnoreBool = (char)0; +} + +void glfwMaximizeWindow_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwMaximizeWindow_CALL_INSTANCE)); + CMOCK_glfwMaximizeWindow_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwMaximizeWindow_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwMaximizeWindow_CallInstance = CMock_Guts_MemChain(Mock.glfwMaximizeWindow_CallInstance, cmock_guts_index); + Mock.glfwMaximizeWindow_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwMaximizeWindow(cmock_call_instance, window); +} + +void glfwMaximizeWindow_AddCallback(CMOCK_glfwMaximizeWindow_CALLBACK Callback) +{ + Mock.glfwMaximizeWindow_IgnoreBool = (char)0; + Mock.glfwMaximizeWindow_CallbackBool = (char)1; + Mock.glfwMaximizeWindow_CallbackFunctionPointer = Callback; +} + +void glfwMaximizeWindow_Stub(CMOCK_glfwMaximizeWindow_CALLBACK Callback) +{ + Mock.glfwMaximizeWindow_IgnoreBool = (char)0; + Mock.glfwMaximizeWindow_CallbackBool = (char)0; + Mock.glfwMaximizeWindow_CallbackFunctionPointer = Callback; +} + +void glfwMaximizeWindow_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwMaximizeWindow_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwMaximizeWindow_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwMaximizeWindow_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwShowWindow(GLFWwindow* window) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwShowWindow_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwShowWindow); + cmock_call_instance = (CMOCK_glfwShowWindow_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwShowWindow_CallInstance); + Mock.glfwShowWindow_CallInstance = CMock_Guts_MemNext(Mock.glfwShowWindow_CallInstance); + if (Mock.glfwShowWindow_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwShowWindow_CallbackBool && + Mock.glfwShowWindow_CallbackFunctionPointer != NULL) + { + Mock.glfwShowWindow_CallbackFunctionPointer(window, Mock.glfwShowWindow_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwShowWindow,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (Mock.glfwShowWindow_CallbackFunctionPointer != NULL) + { + Mock.glfwShowWindow_CallbackFunctionPointer(window, Mock.glfwShowWindow_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwShowWindow(CMOCK_glfwShowWindow_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window); +void CMockExpectParameters_glfwShowWindow(CMOCK_glfwShowWindow_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; +} + +void glfwShowWindow_CMockIgnore(void) +{ + Mock.glfwShowWindow_IgnoreBool = (char)1; +} + +void glfwShowWindow_CMockStopIgnore(void) +{ + Mock.glfwShowWindow_IgnoreBool = (char)0; +} + +void glfwShowWindow_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwShowWindow_CALL_INSTANCE)); + CMOCK_glfwShowWindow_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwShowWindow_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwShowWindow_CallInstance = CMock_Guts_MemChain(Mock.glfwShowWindow_CallInstance, cmock_guts_index); + Mock.glfwShowWindow_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwShowWindow(cmock_call_instance, window); +} + +void glfwShowWindow_AddCallback(CMOCK_glfwShowWindow_CALLBACK Callback) +{ + Mock.glfwShowWindow_IgnoreBool = (char)0; + Mock.glfwShowWindow_CallbackBool = (char)1; + Mock.glfwShowWindow_CallbackFunctionPointer = Callback; +} + +void glfwShowWindow_Stub(CMOCK_glfwShowWindow_CALLBACK Callback) +{ + Mock.glfwShowWindow_IgnoreBool = (char)0; + Mock.glfwShowWindow_CallbackBool = (char)0; + Mock.glfwShowWindow_CallbackFunctionPointer = Callback; +} + +void glfwShowWindow_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwShowWindow_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwShowWindow_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwShowWindow_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwHideWindow(GLFWwindow* window) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwHideWindow_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwHideWindow); + cmock_call_instance = (CMOCK_glfwHideWindow_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwHideWindow_CallInstance); + Mock.glfwHideWindow_CallInstance = CMock_Guts_MemNext(Mock.glfwHideWindow_CallInstance); + if (Mock.glfwHideWindow_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwHideWindow_CallbackBool && + Mock.glfwHideWindow_CallbackFunctionPointer != NULL) + { + Mock.glfwHideWindow_CallbackFunctionPointer(window, Mock.glfwHideWindow_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwHideWindow,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (Mock.glfwHideWindow_CallbackFunctionPointer != NULL) + { + Mock.glfwHideWindow_CallbackFunctionPointer(window, Mock.glfwHideWindow_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwHideWindow(CMOCK_glfwHideWindow_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window); +void CMockExpectParameters_glfwHideWindow(CMOCK_glfwHideWindow_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; +} + +void glfwHideWindow_CMockIgnore(void) +{ + Mock.glfwHideWindow_IgnoreBool = (char)1; +} + +void glfwHideWindow_CMockStopIgnore(void) +{ + Mock.glfwHideWindow_IgnoreBool = (char)0; +} + +void glfwHideWindow_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwHideWindow_CALL_INSTANCE)); + CMOCK_glfwHideWindow_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwHideWindow_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwHideWindow_CallInstance = CMock_Guts_MemChain(Mock.glfwHideWindow_CallInstance, cmock_guts_index); + Mock.glfwHideWindow_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwHideWindow(cmock_call_instance, window); +} + +void glfwHideWindow_AddCallback(CMOCK_glfwHideWindow_CALLBACK Callback) +{ + Mock.glfwHideWindow_IgnoreBool = (char)0; + Mock.glfwHideWindow_CallbackBool = (char)1; + Mock.glfwHideWindow_CallbackFunctionPointer = Callback; +} + +void glfwHideWindow_Stub(CMOCK_glfwHideWindow_CALLBACK Callback) +{ + Mock.glfwHideWindow_IgnoreBool = (char)0; + Mock.glfwHideWindow_CallbackBool = (char)0; + Mock.glfwHideWindow_CallbackFunctionPointer = Callback; +} + +void glfwHideWindow_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwHideWindow_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwHideWindow_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwHideWindow_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwFocusWindow(GLFWwindow* window) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwFocusWindow_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwFocusWindow); + cmock_call_instance = (CMOCK_glfwFocusWindow_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwFocusWindow_CallInstance); + Mock.glfwFocusWindow_CallInstance = CMock_Guts_MemNext(Mock.glfwFocusWindow_CallInstance); + if (Mock.glfwFocusWindow_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwFocusWindow_CallbackBool && + Mock.glfwFocusWindow_CallbackFunctionPointer != NULL) + { + Mock.glfwFocusWindow_CallbackFunctionPointer(window, Mock.glfwFocusWindow_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwFocusWindow,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (Mock.glfwFocusWindow_CallbackFunctionPointer != NULL) + { + Mock.glfwFocusWindow_CallbackFunctionPointer(window, Mock.glfwFocusWindow_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwFocusWindow(CMOCK_glfwFocusWindow_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window); +void CMockExpectParameters_glfwFocusWindow(CMOCK_glfwFocusWindow_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; +} + +void glfwFocusWindow_CMockIgnore(void) +{ + Mock.glfwFocusWindow_IgnoreBool = (char)1; +} + +void glfwFocusWindow_CMockStopIgnore(void) +{ + Mock.glfwFocusWindow_IgnoreBool = (char)0; +} + +void glfwFocusWindow_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwFocusWindow_CALL_INSTANCE)); + CMOCK_glfwFocusWindow_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwFocusWindow_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwFocusWindow_CallInstance = CMock_Guts_MemChain(Mock.glfwFocusWindow_CallInstance, cmock_guts_index); + Mock.glfwFocusWindow_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwFocusWindow(cmock_call_instance, window); +} + +void glfwFocusWindow_AddCallback(CMOCK_glfwFocusWindow_CALLBACK Callback) +{ + Mock.glfwFocusWindow_IgnoreBool = (char)0; + Mock.glfwFocusWindow_CallbackBool = (char)1; + Mock.glfwFocusWindow_CallbackFunctionPointer = Callback; +} + +void glfwFocusWindow_Stub(CMOCK_glfwFocusWindow_CALLBACK Callback) +{ + Mock.glfwFocusWindow_IgnoreBool = (char)0; + Mock.glfwFocusWindow_CallbackBool = (char)0; + Mock.glfwFocusWindow_CallbackFunctionPointer = Callback; +} + +void glfwFocusWindow_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwFocusWindow_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwFocusWindow_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwFocusWindow_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwRequestWindowAttention(GLFWwindow* window) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwRequestWindowAttention_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwRequestWindowAttention); + cmock_call_instance = (CMOCK_glfwRequestWindowAttention_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwRequestWindowAttention_CallInstance); + Mock.glfwRequestWindowAttention_CallInstance = CMock_Guts_MemNext(Mock.glfwRequestWindowAttention_CallInstance); + if (Mock.glfwRequestWindowAttention_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwRequestWindowAttention_CallbackBool && + Mock.glfwRequestWindowAttention_CallbackFunctionPointer != NULL) + { + Mock.glfwRequestWindowAttention_CallbackFunctionPointer(window, Mock.glfwRequestWindowAttention_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwRequestWindowAttention,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (Mock.glfwRequestWindowAttention_CallbackFunctionPointer != NULL) + { + Mock.glfwRequestWindowAttention_CallbackFunctionPointer(window, Mock.glfwRequestWindowAttention_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwRequestWindowAttention(CMOCK_glfwRequestWindowAttention_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window); +void CMockExpectParameters_glfwRequestWindowAttention(CMOCK_glfwRequestWindowAttention_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; +} + +void glfwRequestWindowAttention_CMockIgnore(void) +{ + Mock.glfwRequestWindowAttention_IgnoreBool = (char)1; +} + +void glfwRequestWindowAttention_CMockStopIgnore(void) +{ + Mock.glfwRequestWindowAttention_IgnoreBool = (char)0; +} + +void glfwRequestWindowAttention_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwRequestWindowAttention_CALL_INSTANCE)); + CMOCK_glfwRequestWindowAttention_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwRequestWindowAttention_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwRequestWindowAttention_CallInstance = CMock_Guts_MemChain(Mock.glfwRequestWindowAttention_CallInstance, cmock_guts_index); + Mock.glfwRequestWindowAttention_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwRequestWindowAttention(cmock_call_instance, window); +} + +void glfwRequestWindowAttention_AddCallback(CMOCK_glfwRequestWindowAttention_CALLBACK Callback) +{ + Mock.glfwRequestWindowAttention_IgnoreBool = (char)0; + Mock.glfwRequestWindowAttention_CallbackBool = (char)1; + Mock.glfwRequestWindowAttention_CallbackFunctionPointer = Callback; +} + +void glfwRequestWindowAttention_Stub(CMOCK_glfwRequestWindowAttention_CALLBACK Callback) +{ + Mock.glfwRequestWindowAttention_IgnoreBool = (char)0; + Mock.glfwRequestWindowAttention_CallbackBool = (char)0; + Mock.glfwRequestWindowAttention_CallbackFunctionPointer = Callback; +} + +void glfwRequestWindowAttention_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwRequestWindowAttention_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwRequestWindowAttention_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwRequestWindowAttention_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +GLFWmonitor* glfwGetWindowMonitor(GLFWwindow* window) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetWindowMonitor_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetWindowMonitor); + cmock_call_instance = (CMOCK_glfwGetWindowMonitor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetWindowMonitor_CallInstance); + Mock.glfwGetWindowMonitor_CallInstance = CMock_Guts_MemNext(Mock.glfwGetWindowMonitor_CallInstance); + if (Mock.glfwGetWindowMonitor_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetWindowMonitor_FinalReturn; + Mock.glfwGetWindowMonitor_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetWindowMonitor_CallbackBool && + Mock.glfwGetWindowMonitor_CallbackFunctionPointer != NULL) + { + GLFWmonitor* cmock_cb_ret = Mock.glfwGetWindowMonitor_CallbackFunctionPointer(window, Mock.glfwGetWindowMonitor_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwGetWindowMonitor,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetWindowMonitor_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetWindowMonitor_CallbackFunctionPointer(window, Mock.glfwGetWindowMonitor_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwGetWindowMonitor(CMOCK_glfwGetWindowMonitor_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window); +void CMockExpectParameters_glfwGetWindowMonitor(CMOCK_glfwGetWindowMonitor_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; +} + +void glfwGetWindowMonitor_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWmonitor* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetWindowMonitor_CALL_INSTANCE)); + CMOCK_glfwGetWindowMonitor_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowMonitor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetWindowMonitor_CallInstance = CMock_Guts_MemChain(Mock.glfwGetWindowMonitor_CallInstance, cmock_guts_index); + Mock.glfwGetWindowMonitor_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetWindowMonitor_IgnoreBool = (char)1; +} + +void glfwGetWindowMonitor_CMockStopIgnore(void) +{ + if(Mock.glfwGetWindowMonitor_IgnoreBool) + Mock.glfwGetWindowMonitor_CallInstance = CMock_Guts_MemNext(Mock.glfwGetWindowMonitor_CallInstance); + Mock.glfwGetWindowMonitor_IgnoreBool = (char)0; +} + +void glfwGetWindowMonitor_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWmonitor* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetWindowMonitor_CALL_INSTANCE)); + CMOCK_glfwGetWindowMonitor_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowMonitor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetWindowMonitor_CallInstance = CMock_Guts_MemChain(Mock.glfwGetWindowMonitor_CallInstance, cmock_guts_index); + Mock.glfwGetWindowMonitor_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetWindowMonitor(cmock_call_instance, window); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwGetWindowMonitor_AddCallback(CMOCK_glfwGetWindowMonitor_CALLBACK Callback) +{ + Mock.glfwGetWindowMonitor_IgnoreBool = (char)0; + Mock.glfwGetWindowMonitor_CallbackBool = (char)1; + Mock.glfwGetWindowMonitor_CallbackFunctionPointer = Callback; +} + +void glfwGetWindowMonitor_Stub(CMOCK_glfwGetWindowMonitor_CALLBACK Callback) +{ + Mock.glfwGetWindowMonitor_IgnoreBool = (char)0; + Mock.glfwGetWindowMonitor_CallbackBool = (char)0; + Mock.glfwGetWindowMonitor_CallbackFunctionPointer = Callback; +} + +void glfwGetWindowMonitor_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetWindowMonitor_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowMonitor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetWindowMonitor_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetWindowMonitor(GLFWwindow* window, GLFWmonitor* monitor, int xpos, int ypos, int width, int height, int refreshRate) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetWindowMonitor_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetWindowMonitor); + cmock_call_instance = (CMOCK_glfwSetWindowMonitor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetWindowMonitor_CallInstance); + Mock.glfwSetWindowMonitor_CallInstance = CMock_Guts_MemNext(Mock.glfwSetWindowMonitor_CallInstance); + if (Mock.glfwSetWindowMonitor_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwSetWindowMonitor_CallbackBool && + Mock.glfwSetWindowMonitor_CallbackFunctionPointer != NULL) + { + Mock.glfwSetWindowMonitor_CallbackFunctionPointer(window, monitor, xpos, ypos, width, height, refreshRate, Mock.glfwSetWindowMonitor_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowMonitor,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_monitor) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowMonitor,CMockString_monitor); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_monitor, monitor, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_xpos) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowMonitor,CMockString_xpos); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_xpos, xpos, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_ypos) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowMonitor,CMockString_ypos); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_ypos, ypos, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_width) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowMonitor,CMockString_width); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_width, width, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_height) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowMonitor,CMockString_height); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_height, height, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_refreshRate) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowMonitor,CMockString_refreshRate); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_refreshRate, refreshRate, cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetWindowMonitor_CallbackFunctionPointer != NULL) + { + Mock.glfwSetWindowMonitor_CallbackFunctionPointer(window, monitor, xpos, ypos, width, height, refreshRate, Mock.glfwSetWindowMonitor_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwSetWindowMonitor(CMOCK_glfwSetWindowMonitor_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWmonitor* monitor, int xpos, int ypos, int width, int height, int refreshRate); +void CMockExpectParameters_glfwSetWindowMonitor(CMOCK_glfwSetWindowMonitor_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWmonitor* monitor, int xpos, int ypos, int width, int height, int refreshRate) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + cmock_call_instance->Expected_monitor = monitor; + cmock_call_instance->IgnoreArg_monitor = 0; + cmock_call_instance->Expected_xpos = xpos; + cmock_call_instance->IgnoreArg_xpos = 0; + cmock_call_instance->Expected_ypos = ypos; + cmock_call_instance->IgnoreArg_ypos = 0; + cmock_call_instance->Expected_width = width; + cmock_call_instance->IgnoreArg_width = 0; + cmock_call_instance->Expected_height = height; + cmock_call_instance->IgnoreArg_height = 0; + cmock_call_instance->Expected_refreshRate = refreshRate; + cmock_call_instance->IgnoreArg_refreshRate = 0; +} + +void glfwSetWindowMonitor_CMockIgnore(void) +{ + Mock.glfwSetWindowMonitor_IgnoreBool = (char)1; +} + +void glfwSetWindowMonitor_CMockStopIgnore(void) +{ + Mock.glfwSetWindowMonitor_IgnoreBool = (char)0; +} + +void glfwSetWindowMonitor_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWmonitor* monitor, int xpos, int ypos, int width, int height, int refreshRate) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetWindowMonitor_CALL_INSTANCE)); + CMOCK_glfwSetWindowMonitor_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowMonitor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetWindowMonitor_CallInstance = CMock_Guts_MemChain(Mock.glfwSetWindowMonitor_CallInstance, cmock_guts_index); + Mock.glfwSetWindowMonitor_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetWindowMonitor(cmock_call_instance, window, monitor, xpos, ypos, width, height, refreshRate); +} + +void glfwSetWindowMonitor_AddCallback(CMOCK_glfwSetWindowMonitor_CALLBACK Callback) +{ + Mock.glfwSetWindowMonitor_IgnoreBool = (char)0; + Mock.glfwSetWindowMonitor_CallbackBool = (char)1; + Mock.glfwSetWindowMonitor_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowMonitor_Stub(CMOCK_glfwSetWindowMonitor_CALLBACK Callback) +{ + Mock.glfwSetWindowMonitor_IgnoreBool = (char)0; + Mock.glfwSetWindowMonitor_CallbackBool = (char)0; + Mock.glfwSetWindowMonitor_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowMonitor_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowMonitor_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowMonitor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowMonitor_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetWindowMonitor_CMockIgnoreArg_monitor(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowMonitor_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowMonitor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowMonitor_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_monitor = 1; +} + +void glfwSetWindowMonitor_CMockIgnoreArg_xpos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowMonitor_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowMonitor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowMonitor_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_xpos = 1; +} + +void glfwSetWindowMonitor_CMockIgnoreArg_ypos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowMonitor_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowMonitor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowMonitor_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_ypos = 1; +} + +void glfwSetWindowMonitor_CMockIgnoreArg_width(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowMonitor_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowMonitor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowMonitor_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_width = 1; +} + +void glfwSetWindowMonitor_CMockIgnoreArg_height(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowMonitor_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowMonitor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowMonitor_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_height = 1; +} + +void glfwSetWindowMonitor_CMockIgnoreArg_refreshRate(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowMonitor_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowMonitor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowMonitor_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_refreshRate = 1; +} + +int glfwGetWindowAttrib(GLFWwindow* window, int attrib) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetWindowAttrib_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetWindowAttrib); + cmock_call_instance = (CMOCK_glfwGetWindowAttrib_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetWindowAttrib_CallInstance); + Mock.glfwGetWindowAttrib_CallInstance = CMock_Guts_MemNext(Mock.glfwGetWindowAttrib_CallInstance); + if (Mock.glfwGetWindowAttrib_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetWindowAttrib_FinalReturn; + Mock.glfwGetWindowAttrib_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetWindowAttrib_CallbackBool && + Mock.glfwGetWindowAttrib_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.glfwGetWindowAttrib_CallbackFunctionPointer(window, attrib, Mock.glfwGetWindowAttrib_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwGetWindowAttrib,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_attrib) + { + UNITY_SET_DETAILS(CMockString_glfwGetWindowAttrib,CMockString_attrib); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_attrib, attrib, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetWindowAttrib_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetWindowAttrib_CallbackFunctionPointer(window, attrib, Mock.glfwGetWindowAttrib_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwGetWindowAttrib(CMOCK_glfwGetWindowAttrib_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int attrib); +void CMockExpectParameters_glfwGetWindowAttrib(CMOCK_glfwGetWindowAttrib_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int attrib) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + cmock_call_instance->Expected_attrib = attrib; + cmock_call_instance->IgnoreArg_attrib = 0; +} + +void glfwGetWindowAttrib_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetWindowAttrib_CALL_INSTANCE)); + CMOCK_glfwGetWindowAttrib_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowAttrib_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetWindowAttrib_CallInstance = CMock_Guts_MemChain(Mock.glfwGetWindowAttrib_CallInstance, cmock_guts_index); + Mock.glfwGetWindowAttrib_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetWindowAttrib_IgnoreBool = (char)1; +} + +void glfwGetWindowAttrib_CMockStopIgnore(void) +{ + if(Mock.glfwGetWindowAttrib_IgnoreBool) + Mock.glfwGetWindowAttrib_CallInstance = CMock_Guts_MemNext(Mock.glfwGetWindowAttrib_CallInstance); + Mock.glfwGetWindowAttrib_IgnoreBool = (char)0; +} + +void glfwGetWindowAttrib_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int attrib, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetWindowAttrib_CALL_INSTANCE)); + CMOCK_glfwGetWindowAttrib_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowAttrib_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetWindowAttrib_CallInstance = CMock_Guts_MemChain(Mock.glfwGetWindowAttrib_CallInstance, cmock_guts_index); + Mock.glfwGetWindowAttrib_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetWindowAttrib(cmock_call_instance, window, attrib); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwGetWindowAttrib_AddCallback(CMOCK_glfwGetWindowAttrib_CALLBACK Callback) +{ + Mock.glfwGetWindowAttrib_IgnoreBool = (char)0; + Mock.glfwGetWindowAttrib_CallbackBool = (char)1; + Mock.glfwGetWindowAttrib_CallbackFunctionPointer = Callback; +} + +void glfwGetWindowAttrib_Stub(CMOCK_glfwGetWindowAttrib_CALLBACK Callback) +{ + Mock.glfwGetWindowAttrib_IgnoreBool = (char)0; + Mock.glfwGetWindowAttrib_CallbackBool = (char)0; + Mock.glfwGetWindowAttrib_CallbackFunctionPointer = Callback; +} + +void glfwGetWindowAttrib_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetWindowAttrib_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowAttrib_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetWindowAttrib_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwGetWindowAttrib_CMockIgnoreArg_attrib(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetWindowAttrib_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowAttrib_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetWindowAttrib_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_attrib = 1; +} + +void glfwSetWindowAttrib(GLFWwindow* window, int attrib, int value) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetWindowAttrib_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetWindowAttrib); + cmock_call_instance = (CMOCK_glfwSetWindowAttrib_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetWindowAttrib_CallInstance); + Mock.glfwSetWindowAttrib_CallInstance = CMock_Guts_MemNext(Mock.glfwSetWindowAttrib_CallInstance); + if (Mock.glfwSetWindowAttrib_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwSetWindowAttrib_CallbackBool && + Mock.glfwSetWindowAttrib_CallbackFunctionPointer != NULL) + { + Mock.glfwSetWindowAttrib_CallbackFunctionPointer(window, attrib, value, Mock.glfwSetWindowAttrib_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowAttrib,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_attrib) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowAttrib,CMockString_attrib); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_attrib, attrib, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_value) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowAttrib,CMockString_value); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_value, value, cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetWindowAttrib_CallbackFunctionPointer != NULL) + { + Mock.glfwSetWindowAttrib_CallbackFunctionPointer(window, attrib, value, Mock.glfwSetWindowAttrib_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwSetWindowAttrib(CMOCK_glfwSetWindowAttrib_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int attrib, int value); +void CMockExpectParameters_glfwSetWindowAttrib(CMOCK_glfwSetWindowAttrib_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int attrib, int value) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + cmock_call_instance->Expected_attrib = attrib; + cmock_call_instance->IgnoreArg_attrib = 0; + cmock_call_instance->Expected_value = value; + cmock_call_instance->IgnoreArg_value = 0; +} + +void glfwSetWindowAttrib_CMockIgnore(void) +{ + Mock.glfwSetWindowAttrib_IgnoreBool = (char)1; +} + +void glfwSetWindowAttrib_CMockStopIgnore(void) +{ + Mock.glfwSetWindowAttrib_IgnoreBool = (char)0; +} + +void glfwSetWindowAttrib_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int attrib, int value) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetWindowAttrib_CALL_INSTANCE)); + CMOCK_glfwSetWindowAttrib_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowAttrib_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetWindowAttrib_CallInstance = CMock_Guts_MemChain(Mock.glfwSetWindowAttrib_CallInstance, cmock_guts_index); + Mock.glfwSetWindowAttrib_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetWindowAttrib(cmock_call_instance, window, attrib, value); +} + +void glfwSetWindowAttrib_AddCallback(CMOCK_glfwSetWindowAttrib_CALLBACK Callback) +{ + Mock.glfwSetWindowAttrib_IgnoreBool = (char)0; + Mock.glfwSetWindowAttrib_CallbackBool = (char)1; + Mock.glfwSetWindowAttrib_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowAttrib_Stub(CMOCK_glfwSetWindowAttrib_CALLBACK Callback) +{ + Mock.glfwSetWindowAttrib_IgnoreBool = (char)0; + Mock.glfwSetWindowAttrib_CallbackBool = (char)0; + Mock.glfwSetWindowAttrib_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowAttrib_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowAttrib_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowAttrib_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowAttrib_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetWindowAttrib_CMockIgnoreArg_attrib(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowAttrib_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowAttrib_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowAttrib_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_attrib = 1; +} + +void glfwSetWindowAttrib_CMockIgnoreArg_value(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowAttrib_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowAttrib_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowAttrib_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_value = 1; +} + +void glfwSetWindowUserPointer(GLFWwindow* window, void* pointer) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetWindowUserPointer_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetWindowUserPointer); + cmock_call_instance = (CMOCK_glfwSetWindowUserPointer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetWindowUserPointer_CallInstance); + Mock.glfwSetWindowUserPointer_CallInstance = CMock_Guts_MemNext(Mock.glfwSetWindowUserPointer_CallInstance); + if (Mock.glfwSetWindowUserPointer_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwSetWindowUserPointer_CallbackBool && + Mock.glfwSetWindowUserPointer_CallbackFunctionPointer != NULL) + { + Mock.glfwSetWindowUserPointer_CallbackFunctionPointer(window, pointer, Mock.glfwSetWindowUserPointer_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowUserPointer,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pointer) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowUserPointer,CMockString_pointer); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_pointer, pointer, cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetWindowUserPointer_CallbackFunctionPointer != NULL) + { + Mock.glfwSetWindowUserPointer_CallbackFunctionPointer(window, pointer, Mock.glfwSetWindowUserPointer_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwSetWindowUserPointer(CMOCK_glfwSetWindowUserPointer_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, void* pointer); +void CMockExpectParameters_glfwSetWindowUserPointer(CMOCK_glfwSetWindowUserPointer_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, void* pointer) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + cmock_call_instance->Expected_pointer = pointer; + cmock_call_instance->IgnoreArg_pointer = 0; +} + +void glfwSetWindowUserPointer_CMockIgnore(void) +{ + Mock.glfwSetWindowUserPointer_IgnoreBool = (char)1; +} + +void glfwSetWindowUserPointer_CMockStopIgnore(void) +{ + Mock.glfwSetWindowUserPointer_IgnoreBool = (char)0; +} + +void glfwSetWindowUserPointer_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, void* pointer) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetWindowUserPointer_CALL_INSTANCE)); + CMOCK_glfwSetWindowUserPointer_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowUserPointer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetWindowUserPointer_CallInstance = CMock_Guts_MemChain(Mock.glfwSetWindowUserPointer_CallInstance, cmock_guts_index); + Mock.glfwSetWindowUserPointer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetWindowUserPointer(cmock_call_instance, window, pointer); +} + +void glfwSetWindowUserPointer_AddCallback(CMOCK_glfwSetWindowUserPointer_CALLBACK Callback) +{ + Mock.glfwSetWindowUserPointer_IgnoreBool = (char)0; + Mock.glfwSetWindowUserPointer_CallbackBool = (char)1; + Mock.glfwSetWindowUserPointer_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowUserPointer_Stub(CMOCK_glfwSetWindowUserPointer_CALLBACK Callback) +{ + Mock.glfwSetWindowUserPointer_IgnoreBool = (char)0; + Mock.glfwSetWindowUserPointer_CallbackBool = (char)0; + Mock.glfwSetWindowUserPointer_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowUserPointer_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowUserPointer_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowUserPointer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowUserPointer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetWindowUserPointer_CMockIgnoreArg_pointer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowUserPointer_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowUserPointer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowUserPointer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pointer = 1; +} + +void* glfwGetWindowUserPointer(GLFWwindow* window) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetWindowUserPointer_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetWindowUserPointer); + cmock_call_instance = (CMOCK_glfwGetWindowUserPointer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetWindowUserPointer_CallInstance); + Mock.glfwGetWindowUserPointer_CallInstance = CMock_Guts_MemNext(Mock.glfwGetWindowUserPointer_CallInstance); + if (Mock.glfwGetWindowUserPointer_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetWindowUserPointer_FinalReturn; + Mock.glfwGetWindowUserPointer_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetWindowUserPointer_CallbackBool && + Mock.glfwGetWindowUserPointer_CallbackFunctionPointer != NULL) + { + void* cmock_cb_ret = Mock.glfwGetWindowUserPointer_CallbackFunctionPointer(window, Mock.glfwGetWindowUserPointer_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwGetWindowUserPointer,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetWindowUserPointer_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetWindowUserPointer_CallbackFunctionPointer(window, Mock.glfwGetWindowUserPointer_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwGetWindowUserPointer(CMOCK_glfwGetWindowUserPointer_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window); +void CMockExpectParameters_glfwGetWindowUserPointer(CMOCK_glfwGetWindowUserPointer_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; +} + +void glfwGetWindowUserPointer_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, void* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetWindowUserPointer_CALL_INSTANCE)); + CMOCK_glfwGetWindowUserPointer_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowUserPointer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetWindowUserPointer_CallInstance = CMock_Guts_MemChain(Mock.glfwGetWindowUserPointer_CallInstance, cmock_guts_index); + Mock.glfwGetWindowUserPointer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetWindowUserPointer_IgnoreBool = (char)1; +} + +void glfwGetWindowUserPointer_CMockStopIgnore(void) +{ + if(Mock.glfwGetWindowUserPointer_IgnoreBool) + Mock.glfwGetWindowUserPointer_CallInstance = CMock_Guts_MemNext(Mock.glfwGetWindowUserPointer_CallInstance); + Mock.glfwGetWindowUserPointer_IgnoreBool = (char)0; +} + +void glfwGetWindowUserPointer_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, void* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetWindowUserPointer_CALL_INSTANCE)); + CMOCK_glfwGetWindowUserPointer_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowUserPointer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetWindowUserPointer_CallInstance = CMock_Guts_MemChain(Mock.glfwGetWindowUserPointer_CallInstance, cmock_guts_index); + Mock.glfwGetWindowUserPointer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetWindowUserPointer(cmock_call_instance, window); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwGetWindowUserPointer_AddCallback(CMOCK_glfwGetWindowUserPointer_CALLBACK Callback) +{ + Mock.glfwGetWindowUserPointer_IgnoreBool = (char)0; + Mock.glfwGetWindowUserPointer_CallbackBool = (char)1; + Mock.glfwGetWindowUserPointer_CallbackFunctionPointer = Callback; +} + +void glfwGetWindowUserPointer_Stub(CMOCK_glfwGetWindowUserPointer_CALLBACK Callback) +{ + Mock.glfwGetWindowUserPointer_IgnoreBool = (char)0; + Mock.glfwGetWindowUserPointer_CallbackBool = (char)0; + Mock.glfwGetWindowUserPointer_CallbackFunctionPointer = Callback; +} + +void glfwGetWindowUserPointer_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetWindowUserPointer_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetWindowUserPointer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetWindowUserPointer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +GLFWwindowposfun glfwSetWindowPosCallback(GLFWwindow* window, GLFWwindowposfun callback) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetWindowPosCallback_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetWindowPosCallback); + cmock_call_instance = (CMOCK_glfwSetWindowPosCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetWindowPosCallback_CallInstance); + Mock.glfwSetWindowPosCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetWindowPosCallback_CallInstance); + if (Mock.glfwSetWindowPosCallback_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwSetWindowPosCallback_FinalReturn; + memcpy((void*)(&Mock.glfwSetWindowPosCallback_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(GLFWwindowposfun[sizeof(cmock_call_instance->ReturnVal) == sizeof(GLFWwindowposfun) ? 1 : -1])); /* add GLFWwindowposfun to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwSetWindowPosCallback_CallbackBool && + Mock.glfwSetWindowPosCallback_CallbackFunctionPointer != NULL) + { + GLFWwindowposfun cmock_cb_ret = Mock.glfwSetWindowPosCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetWindowPosCallback_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowPosCallback,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_callback) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowPosCallback,CMockString_callback); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), sizeof(GLFWwindowposfun), cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetWindowPosCallback_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwSetWindowPosCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetWindowPosCallback_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwSetWindowPosCallback(CMOCK_glfwSetWindowPosCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWwindowposfun callback); +void CMockExpectParameters_glfwSetWindowPosCallback(CMOCK_glfwSetWindowPosCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWwindowposfun callback) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + memcpy((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), + sizeof(GLFWwindowposfun[sizeof(callback) == sizeof(GLFWwindowposfun) ? 1 : -1])); /* add GLFWwindowposfun to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_callback = 0; +} + +void glfwSetWindowPosCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindowposfun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetWindowPosCallback_CALL_INSTANCE)); + CMOCK_glfwSetWindowPosCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowPosCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetWindowPosCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetWindowPosCallback_CallInstance, cmock_guts_index); + Mock.glfwSetWindowPosCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwSetWindowPosCallback_IgnoreBool = (char)1; +} + +void glfwSetWindowPosCallback_CMockStopIgnore(void) +{ + if(Mock.glfwSetWindowPosCallback_IgnoreBool) + Mock.glfwSetWindowPosCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetWindowPosCallback_CallInstance); + Mock.glfwSetWindowPosCallback_IgnoreBool = (char)0; +} + +void glfwSetWindowPosCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWwindowposfun callback, GLFWwindowposfun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetWindowPosCallback_CALL_INSTANCE)); + CMOCK_glfwSetWindowPosCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowPosCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetWindowPosCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetWindowPosCallback_CallInstance, cmock_guts_index); + Mock.glfwSetWindowPosCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetWindowPosCallback(cmock_call_instance, window, callback); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(GLFWwindowposfun[sizeof(cmock_to_return) == sizeof(GLFWwindowposfun) ? 1 : -1])); /* add GLFWwindowposfun to :treat_as_array if this causes an error */ +} + +void glfwSetWindowPosCallback_AddCallback(CMOCK_glfwSetWindowPosCallback_CALLBACK Callback) +{ + Mock.glfwSetWindowPosCallback_IgnoreBool = (char)0; + Mock.glfwSetWindowPosCallback_CallbackBool = (char)1; + Mock.glfwSetWindowPosCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowPosCallback_Stub(CMOCK_glfwSetWindowPosCallback_CALLBACK Callback) +{ + Mock.glfwSetWindowPosCallback_IgnoreBool = (char)0; + Mock.glfwSetWindowPosCallback_CallbackBool = (char)0; + Mock.glfwSetWindowPosCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowPosCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowPosCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowPosCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowPosCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetWindowPosCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowPosCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowPosCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowPosCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_callback = 1; +} + +GLFWwindowsizefun glfwSetWindowSizeCallback(GLFWwindow* window, GLFWwindowsizefun callback) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetWindowSizeCallback_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetWindowSizeCallback); + cmock_call_instance = (CMOCK_glfwSetWindowSizeCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetWindowSizeCallback_CallInstance); + Mock.glfwSetWindowSizeCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetWindowSizeCallback_CallInstance); + if (Mock.glfwSetWindowSizeCallback_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwSetWindowSizeCallback_FinalReturn; + memcpy((void*)(&Mock.glfwSetWindowSizeCallback_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(GLFWwindowsizefun[sizeof(cmock_call_instance->ReturnVal) == sizeof(GLFWwindowsizefun) ? 1 : -1])); /* add GLFWwindowsizefun to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwSetWindowSizeCallback_CallbackBool && + Mock.glfwSetWindowSizeCallback_CallbackFunctionPointer != NULL) + { + GLFWwindowsizefun cmock_cb_ret = Mock.glfwSetWindowSizeCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetWindowSizeCallback_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowSizeCallback,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_callback) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowSizeCallback,CMockString_callback); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), sizeof(GLFWwindowsizefun), cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetWindowSizeCallback_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwSetWindowSizeCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetWindowSizeCallback_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwSetWindowSizeCallback(CMOCK_glfwSetWindowSizeCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWwindowsizefun callback); +void CMockExpectParameters_glfwSetWindowSizeCallback(CMOCK_glfwSetWindowSizeCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWwindowsizefun callback) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + memcpy((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), + sizeof(GLFWwindowsizefun[sizeof(callback) == sizeof(GLFWwindowsizefun) ? 1 : -1])); /* add GLFWwindowsizefun to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_callback = 0; +} + +void glfwSetWindowSizeCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindowsizefun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetWindowSizeCallback_CALL_INSTANCE)); + CMOCK_glfwSetWindowSizeCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowSizeCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetWindowSizeCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetWindowSizeCallback_CallInstance, cmock_guts_index); + Mock.glfwSetWindowSizeCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwSetWindowSizeCallback_IgnoreBool = (char)1; +} + +void glfwSetWindowSizeCallback_CMockStopIgnore(void) +{ + if(Mock.glfwSetWindowSizeCallback_IgnoreBool) + Mock.glfwSetWindowSizeCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetWindowSizeCallback_CallInstance); + Mock.glfwSetWindowSizeCallback_IgnoreBool = (char)0; +} + +void glfwSetWindowSizeCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWwindowsizefun callback, GLFWwindowsizefun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetWindowSizeCallback_CALL_INSTANCE)); + CMOCK_glfwSetWindowSizeCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowSizeCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetWindowSizeCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetWindowSizeCallback_CallInstance, cmock_guts_index); + Mock.glfwSetWindowSizeCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetWindowSizeCallback(cmock_call_instance, window, callback); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(GLFWwindowsizefun[sizeof(cmock_to_return) == sizeof(GLFWwindowsizefun) ? 1 : -1])); /* add GLFWwindowsizefun to :treat_as_array if this causes an error */ +} + +void glfwSetWindowSizeCallback_AddCallback(CMOCK_glfwSetWindowSizeCallback_CALLBACK Callback) +{ + Mock.glfwSetWindowSizeCallback_IgnoreBool = (char)0; + Mock.glfwSetWindowSizeCallback_CallbackBool = (char)1; + Mock.glfwSetWindowSizeCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowSizeCallback_Stub(CMOCK_glfwSetWindowSizeCallback_CALLBACK Callback) +{ + Mock.glfwSetWindowSizeCallback_IgnoreBool = (char)0; + Mock.glfwSetWindowSizeCallback_CallbackBool = (char)0; + Mock.glfwSetWindowSizeCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowSizeCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowSizeCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowSizeCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowSizeCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetWindowSizeCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowSizeCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowSizeCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowSizeCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_callback = 1; +} + +GLFWwindowclosefun glfwSetWindowCloseCallback(GLFWwindow* window, GLFWwindowclosefun callback) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetWindowCloseCallback_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetWindowCloseCallback); + cmock_call_instance = (CMOCK_glfwSetWindowCloseCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetWindowCloseCallback_CallInstance); + Mock.glfwSetWindowCloseCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetWindowCloseCallback_CallInstance); + if (Mock.glfwSetWindowCloseCallback_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwSetWindowCloseCallback_FinalReturn; + memcpy((void*)(&Mock.glfwSetWindowCloseCallback_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(GLFWwindowclosefun[sizeof(cmock_call_instance->ReturnVal) == sizeof(GLFWwindowclosefun) ? 1 : -1])); /* add GLFWwindowclosefun to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwSetWindowCloseCallback_CallbackBool && + Mock.glfwSetWindowCloseCallback_CallbackFunctionPointer != NULL) + { + GLFWwindowclosefun cmock_cb_ret = Mock.glfwSetWindowCloseCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetWindowCloseCallback_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowCloseCallback,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_callback) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowCloseCallback,CMockString_callback); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), sizeof(GLFWwindowclosefun), cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetWindowCloseCallback_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwSetWindowCloseCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetWindowCloseCallback_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwSetWindowCloseCallback(CMOCK_glfwSetWindowCloseCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWwindowclosefun callback); +void CMockExpectParameters_glfwSetWindowCloseCallback(CMOCK_glfwSetWindowCloseCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWwindowclosefun callback) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + memcpy((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), + sizeof(GLFWwindowclosefun[sizeof(callback) == sizeof(GLFWwindowclosefun) ? 1 : -1])); /* add GLFWwindowclosefun to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_callback = 0; +} + +void glfwSetWindowCloseCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindowclosefun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetWindowCloseCallback_CALL_INSTANCE)); + CMOCK_glfwSetWindowCloseCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowCloseCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetWindowCloseCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetWindowCloseCallback_CallInstance, cmock_guts_index); + Mock.glfwSetWindowCloseCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwSetWindowCloseCallback_IgnoreBool = (char)1; +} + +void glfwSetWindowCloseCallback_CMockStopIgnore(void) +{ + if(Mock.glfwSetWindowCloseCallback_IgnoreBool) + Mock.glfwSetWindowCloseCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetWindowCloseCallback_CallInstance); + Mock.glfwSetWindowCloseCallback_IgnoreBool = (char)0; +} + +void glfwSetWindowCloseCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWwindowclosefun callback, GLFWwindowclosefun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetWindowCloseCallback_CALL_INSTANCE)); + CMOCK_glfwSetWindowCloseCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowCloseCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetWindowCloseCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetWindowCloseCallback_CallInstance, cmock_guts_index); + Mock.glfwSetWindowCloseCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetWindowCloseCallback(cmock_call_instance, window, callback); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(GLFWwindowclosefun[sizeof(cmock_to_return) == sizeof(GLFWwindowclosefun) ? 1 : -1])); /* add GLFWwindowclosefun to :treat_as_array if this causes an error */ +} + +void glfwSetWindowCloseCallback_AddCallback(CMOCK_glfwSetWindowCloseCallback_CALLBACK Callback) +{ + Mock.glfwSetWindowCloseCallback_IgnoreBool = (char)0; + Mock.glfwSetWindowCloseCallback_CallbackBool = (char)1; + Mock.glfwSetWindowCloseCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowCloseCallback_Stub(CMOCK_glfwSetWindowCloseCallback_CALLBACK Callback) +{ + Mock.glfwSetWindowCloseCallback_IgnoreBool = (char)0; + Mock.glfwSetWindowCloseCallback_CallbackBool = (char)0; + Mock.glfwSetWindowCloseCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowCloseCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowCloseCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowCloseCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowCloseCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetWindowCloseCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowCloseCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowCloseCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowCloseCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_callback = 1; +} + +GLFWwindowrefreshfun glfwSetWindowRefreshCallback(GLFWwindow* window, GLFWwindowrefreshfun callback) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetWindowRefreshCallback_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetWindowRefreshCallback); + cmock_call_instance = (CMOCK_glfwSetWindowRefreshCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetWindowRefreshCallback_CallInstance); + Mock.glfwSetWindowRefreshCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetWindowRefreshCallback_CallInstance); + if (Mock.glfwSetWindowRefreshCallback_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwSetWindowRefreshCallback_FinalReturn; + memcpy((void*)(&Mock.glfwSetWindowRefreshCallback_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(GLFWwindowrefreshfun[sizeof(cmock_call_instance->ReturnVal) == sizeof(GLFWwindowrefreshfun) ? 1 : -1])); /* add GLFWwindowrefreshfun to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwSetWindowRefreshCallback_CallbackBool && + Mock.glfwSetWindowRefreshCallback_CallbackFunctionPointer != NULL) + { + GLFWwindowrefreshfun cmock_cb_ret = Mock.glfwSetWindowRefreshCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetWindowRefreshCallback_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowRefreshCallback,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_callback) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowRefreshCallback,CMockString_callback); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), sizeof(GLFWwindowrefreshfun), cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetWindowRefreshCallback_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwSetWindowRefreshCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetWindowRefreshCallback_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwSetWindowRefreshCallback(CMOCK_glfwSetWindowRefreshCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWwindowrefreshfun callback); +void CMockExpectParameters_glfwSetWindowRefreshCallback(CMOCK_glfwSetWindowRefreshCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWwindowrefreshfun callback) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + memcpy((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), + sizeof(GLFWwindowrefreshfun[sizeof(callback) == sizeof(GLFWwindowrefreshfun) ? 1 : -1])); /* add GLFWwindowrefreshfun to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_callback = 0; +} + +void glfwSetWindowRefreshCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindowrefreshfun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetWindowRefreshCallback_CALL_INSTANCE)); + CMOCK_glfwSetWindowRefreshCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowRefreshCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetWindowRefreshCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetWindowRefreshCallback_CallInstance, cmock_guts_index); + Mock.glfwSetWindowRefreshCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwSetWindowRefreshCallback_IgnoreBool = (char)1; +} + +void glfwSetWindowRefreshCallback_CMockStopIgnore(void) +{ + if(Mock.glfwSetWindowRefreshCallback_IgnoreBool) + Mock.glfwSetWindowRefreshCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetWindowRefreshCallback_CallInstance); + Mock.glfwSetWindowRefreshCallback_IgnoreBool = (char)0; +} + +void glfwSetWindowRefreshCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWwindowrefreshfun callback, GLFWwindowrefreshfun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetWindowRefreshCallback_CALL_INSTANCE)); + CMOCK_glfwSetWindowRefreshCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowRefreshCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetWindowRefreshCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetWindowRefreshCallback_CallInstance, cmock_guts_index); + Mock.glfwSetWindowRefreshCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetWindowRefreshCallback(cmock_call_instance, window, callback); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(GLFWwindowrefreshfun[sizeof(cmock_to_return) == sizeof(GLFWwindowrefreshfun) ? 1 : -1])); /* add GLFWwindowrefreshfun to :treat_as_array if this causes an error */ +} + +void glfwSetWindowRefreshCallback_AddCallback(CMOCK_glfwSetWindowRefreshCallback_CALLBACK Callback) +{ + Mock.glfwSetWindowRefreshCallback_IgnoreBool = (char)0; + Mock.glfwSetWindowRefreshCallback_CallbackBool = (char)1; + Mock.glfwSetWindowRefreshCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowRefreshCallback_Stub(CMOCK_glfwSetWindowRefreshCallback_CALLBACK Callback) +{ + Mock.glfwSetWindowRefreshCallback_IgnoreBool = (char)0; + Mock.glfwSetWindowRefreshCallback_CallbackBool = (char)0; + Mock.glfwSetWindowRefreshCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowRefreshCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowRefreshCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowRefreshCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowRefreshCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetWindowRefreshCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowRefreshCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowRefreshCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowRefreshCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_callback = 1; +} + +GLFWwindowfocusfun glfwSetWindowFocusCallback(GLFWwindow* window, GLFWwindowfocusfun callback) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetWindowFocusCallback_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetWindowFocusCallback); + cmock_call_instance = (CMOCK_glfwSetWindowFocusCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetWindowFocusCallback_CallInstance); + Mock.glfwSetWindowFocusCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetWindowFocusCallback_CallInstance); + if (Mock.glfwSetWindowFocusCallback_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwSetWindowFocusCallback_FinalReturn; + memcpy((void*)(&Mock.glfwSetWindowFocusCallback_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(GLFWwindowfocusfun[sizeof(cmock_call_instance->ReturnVal) == sizeof(GLFWwindowfocusfun) ? 1 : -1])); /* add GLFWwindowfocusfun to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwSetWindowFocusCallback_CallbackBool && + Mock.glfwSetWindowFocusCallback_CallbackFunctionPointer != NULL) + { + GLFWwindowfocusfun cmock_cb_ret = Mock.glfwSetWindowFocusCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetWindowFocusCallback_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowFocusCallback,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_callback) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowFocusCallback,CMockString_callback); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), sizeof(GLFWwindowfocusfun), cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetWindowFocusCallback_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwSetWindowFocusCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetWindowFocusCallback_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwSetWindowFocusCallback(CMOCK_glfwSetWindowFocusCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWwindowfocusfun callback); +void CMockExpectParameters_glfwSetWindowFocusCallback(CMOCK_glfwSetWindowFocusCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWwindowfocusfun callback) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + memcpy((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), + sizeof(GLFWwindowfocusfun[sizeof(callback) == sizeof(GLFWwindowfocusfun) ? 1 : -1])); /* add GLFWwindowfocusfun to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_callback = 0; +} + +void glfwSetWindowFocusCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindowfocusfun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetWindowFocusCallback_CALL_INSTANCE)); + CMOCK_glfwSetWindowFocusCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowFocusCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetWindowFocusCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetWindowFocusCallback_CallInstance, cmock_guts_index); + Mock.glfwSetWindowFocusCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwSetWindowFocusCallback_IgnoreBool = (char)1; +} + +void glfwSetWindowFocusCallback_CMockStopIgnore(void) +{ + if(Mock.glfwSetWindowFocusCallback_IgnoreBool) + Mock.glfwSetWindowFocusCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetWindowFocusCallback_CallInstance); + Mock.glfwSetWindowFocusCallback_IgnoreBool = (char)0; +} + +void glfwSetWindowFocusCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWwindowfocusfun callback, GLFWwindowfocusfun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetWindowFocusCallback_CALL_INSTANCE)); + CMOCK_glfwSetWindowFocusCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowFocusCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetWindowFocusCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetWindowFocusCallback_CallInstance, cmock_guts_index); + Mock.glfwSetWindowFocusCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetWindowFocusCallback(cmock_call_instance, window, callback); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(GLFWwindowfocusfun[sizeof(cmock_to_return) == sizeof(GLFWwindowfocusfun) ? 1 : -1])); /* add GLFWwindowfocusfun to :treat_as_array if this causes an error */ +} + +void glfwSetWindowFocusCallback_AddCallback(CMOCK_glfwSetWindowFocusCallback_CALLBACK Callback) +{ + Mock.glfwSetWindowFocusCallback_IgnoreBool = (char)0; + Mock.glfwSetWindowFocusCallback_CallbackBool = (char)1; + Mock.glfwSetWindowFocusCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowFocusCallback_Stub(CMOCK_glfwSetWindowFocusCallback_CALLBACK Callback) +{ + Mock.glfwSetWindowFocusCallback_IgnoreBool = (char)0; + Mock.glfwSetWindowFocusCallback_CallbackBool = (char)0; + Mock.glfwSetWindowFocusCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowFocusCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowFocusCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowFocusCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowFocusCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetWindowFocusCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowFocusCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowFocusCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowFocusCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_callback = 1; +} + +GLFWwindowiconifyfun glfwSetWindowIconifyCallback(GLFWwindow* window, GLFWwindowiconifyfun callback) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetWindowIconifyCallback_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetWindowIconifyCallback); + cmock_call_instance = (CMOCK_glfwSetWindowIconifyCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetWindowIconifyCallback_CallInstance); + Mock.glfwSetWindowIconifyCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetWindowIconifyCallback_CallInstance); + if (Mock.glfwSetWindowIconifyCallback_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwSetWindowIconifyCallback_FinalReturn; + memcpy((void*)(&Mock.glfwSetWindowIconifyCallback_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(GLFWwindowiconifyfun[sizeof(cmock_call_instance->ReturnVal) == sizeof(GLFWwindowiconifyfun) ? 1 : -1])); /* add GLFWwindowiconifyfun to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwSetWindowIconifyCallback_CallbackBool && + Mock.glfwSetWindowIconifyCallback_CallbackFunctionPointer != NULL) + { + GLFWwindowiconifyfun cmock_cb_ret = Mock.glfwSetWindowIconifyCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetWindowIconifyCallback_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowIconifyCallback,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_callback) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowIconifyCallback,CMockString_callback); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), sizeof(GLFWwindowiconifyfun), cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetWindowIconifyCallback_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwSetWindowIconifyCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetWindowIconifyCallback_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwSetWindowIconifyCallback(CMOCK_glfwSetWindowIconifyCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWwindowiconifyfun callback); +void CMockExpectParameters_glfwSetWindowIconifyCallback(CMOCK_glfwSetWindowIconifyCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWwindowiconifyfun callback) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + memcpy((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), + sizeof(GLFWwindowiconifyfun[sizeof(callback) == sizeof(GLFWwindowiconifyfun) ? 1 : -1])); /* add GLFWwindowiconifyfun to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_callback = 0; +} + +void glfwSetWindowIconifyCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindowiconifyfun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetWindowIconifyCallback_CALL_INSTANCE)); + CMOCK_glfwSetWindowIconifyCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowIconifyCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetWindowIconifyCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetWindowIconifyCallback_CallInstance, cmock_guts_index); + Mock.glfwSetWindowIconifyCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwSetWindowIconifyCallback_IgnoreBool = (char)1; +} + +void glfwSetWindowIconifyCallback_CMockStopIgnore(void) +{ + if(Mock.glfwSetWindowIconifyCallback_IgnoreBool) + Mock.glfwSetWindowIconifyCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetWindowIconifyCallback_CallInstance); + Mock.glfwSetWindowIconifyCallback_IgnoreBool = (char)0; +} + +void glfwSetWindowIconifyCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWwindowiconifyfun callback, GLFWwindowiconifyfun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetWindowIconifyCallback_CALL_INSTANCE)); + CMOCK_glfwSetWindowIconifyCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowIconifyCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetWindowIconifyCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetWindowIconifyCallback_CallInstance, cmock_guts_index); + Mock.glfwSetWindowIconifyCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetWindowIconifyCallback(cmock_call_instance, window, callback); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(GLFWwindowiconifyfun[sizeof(cmock_to_return) == sizeof(GLFWwindowiconifyfun) ? 1 : -1])); /* add GLFWwindowiconifyfun to :treat_as_array if this causes an error */ +} + +void glfwSetWindowIconifyCallback_AddCallback(CMOCK_glfwSetWindowIconifyCallback_CALLBACK Callback) +{ + Mock.glfwSetWindowIconifyCallback_IgnoreBool = (char)0; + Mock.glfwSetWindowIconifyCallback_CallbackBool = (char)1; + Mock.glfwSetWindowIconifyCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowIconifyCallback_Stub(CMOCK_glfwSetWindowIconifyCallback_CALLBACK Callback) +{ + Mock.glfwSetWindowIconifyCallback_IgnoreBool = (char)0; + Mock.glfwSetWindowIconifyCallback_CallbackBool = (char)0; + Mock.glfwSetWindowIconifyCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowIconifyCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowIconifyCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowIconifyCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowIconifyCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetWindowIconifyCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowIconifyCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowIconifyCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowIconifyCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_callback = 1; +} + +GLFWwindowmaximizefun glfwSetWindowMaximizeCallback(GLFWwindow* window, GLFWwindowmaximizefun callback) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetWindowMaximizeCallback_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetWindowMaximizeCallback); + cmock_call_instance = (CMOCK_glfwSetWindowMaximizeCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetWindowMaximizeCallback_CallInstance); + Mock.glfwSetWindowMaximizeCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetWindowMaximizeCallback_CallInstance); + if (Mock.glfwSetWindowMaximizeCallback_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwSetWindowMaximizeCallback_FinalReturn; + memcpy((void*)(&Mock.glfwSetWindowMaximizeCallback_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(GLFWwindowmaximizefun[sizeof(cmock_call_instance->ReturnVal) == sizeof(GLFWwindowmaximizefun) ? 1 : -1])); /* add GLFWwindowmaximizefun to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwSetWindowMaximizeCallback_CallbackBool && + Mock.glfwSetWindowMaximizeCallback_CallbackFunctionPointer != NULL) + { + GLFWwindowmaximizefun cmock_cb_ret = Mock.glfwSetWindowMaximizeCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetWindowMaximizeCallback_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowMaximizeCallback,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_callback) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowMaximizeCallback,CMockString_callback); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), sizeof(GLFWwindowmaximizefun), cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetWindowMaximizeCallback_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwSetWindowMaximizeCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetWindowMaximizeCallback_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwSetWindowMaximizeCallback(CMOCK_glfwSetWindowMaximizeCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWwindowmaximizefun callback); +void CMockExpectParameters_glfwSetWindowMaximizeCallback(CMOCK_glfwSetWindowMaximizeCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWwindowmaximizefun callback) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + memcpy((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), + sizeof(GLFWwindowmaximizefun[sizeof(callback) == sizeof(GLFWwindowmaximizefun) ? 1 : -1])); /* add GLFWwindowmaximizefun to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_callback = 0; +} + +void glfwSetWindowMaximizeCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindowmaximizefun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetWindowMaximizeCallback_CALL_INSTANCE)); + CMOCK_glfwSetWindowMaximizeCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowMaximizeCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetWindowMaximizeCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetWindowMaximizeCallback_CallInstance, cmock_guts_index); + Mock.glfwSetWindowMaximizeCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwSetWindowMaximizeCallback_IgnoreBool = (char)1; +} + +void glfwSetWindowMaximizeCallback_CMockStopIgnore(void) +{ + if(Mock.glfwSetWindowMaximizeCallback_IgnoreBool) + Mock.glfwSetWindowMaximizeCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetWindowMaximizeCallback_CallInstance); + Mock.glfwSetWindowMaximizeCallback_IgnoreBool = (char)0; +} + +void glfwSetWindowMaximizeCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWwindowmaximizefun callback, GLFWwindowmaximizefun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetWindowMaximizeCallback_CALL_INSTANCE)); + CMOCK_glfwSetWindowMaximizeCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowMaximizeCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetWindowMaximizeCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetWindowMaximizeCallback_CallInstance, cmock_guts_index); + Mock.glfwSetWindowMaximizeCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetWindowMaximizeCallback(cmock_call_instance, window, callback); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(GLFWwindowmaximizefun[sizeof(cmock_to_return) == sizeof(GLFWwindowmaximizefun) ? 1 : -1])); /* add GLFWwindowmaximizefun to :treat_as_array if this causes an error */ +} + +void glfwSetWindowMaximizeCallback_AddCallback(CMOCK_glfwSetWindowMaximizeCallback_CALLBACK Callback) +{ + Mock.glfwSetWindowMaximizeCallback_IgnoreBool = (char)0; + Mock.glfwSetWindowMaximizeCallback_CallbackBool = (char)1; + Mock.glfwSetWindowMaximizeCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowMaximizeCallback_Stub(CMOCK_glfwSetWindowMaximizeCallback_CALLBACK Callback) +{ + Mock.glfwSetWindowMaximizeCallback_IgnoreBool = (char)0; + Mock.glfwSetWindowMaximizeCallback_CallbackBool = (char)0; + Mock.glfwSetWindowMaximizeCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowMaximizeCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowMaximizeCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowMaximizeCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowMaximizeCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetWindowMaximizeCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowMaximizeCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowMaximizeCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowMaximizeCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_callback = 1; +} + +GLFWframebuffersizefun glfwSetFramebufferSizeCallback(GLFWwindow* window, GLFWframebuffersizefun callback) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetFramebufferSizeCallback_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetFramebufferSizeCallback); + cmock_call_instance = (CMOCK_glfwSetFramebufferSizeCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetFramebufferSizeCallback_CallInstance); + Mock.glfwSetFramebufferSizeCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetFramebufferSizeCallback_CallInstance); + if (Mock.glfwSetFramebufferSizeCallback_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwSetFramebufferSizeCallback_FinalReturn; + memcpy((void*)(&Mock.glfwSetFramebufferSizeCallback_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(GLFWframebuffersizefun[sizeof(cmock_call_instance->ReturnVal) == sizeof(GLFWframebuffersizefun) ? 1 : -1])); /* add GLFWframebuffersizefun to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwSetFramebufferSizeCallback_CallbackBool && + Mock.glfwSetFramebufferSizeCallback_CallbackFunctionPointer != NULL) + { + GLFWframebuffersizefun cmock_cb_ret = Mock.glfwSetFramebufferSizeCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetFramebufferSizeCallback_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetFramebufferSizeCallback,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_callback) + { + UNITY_SET_DETAILS(CMockString_glfwSetFramebufferSizeCallback,CMockString_callback); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), sizeof(GLFWframebuffersizefun), cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetFramebufferSizeCallback_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwSetFramebufferSizeCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetFramebufferSizeCallback_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwSetFramebufferSizeCallback(CMOCK_glfwSetFramebufferSizeCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWframebuffersizefun callback); +void CMockExpectParameters_glfwSetFramebufferSizeCallback(CMOCK_glfwSetFramebufferSizeCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWframebuffersizefun callback) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + memcpy((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), + sizeof(GLFWframebuffersizefun[sizeof(callback) == sizeof(GLFWframebuffersizefun) ? 1 : -1])); /* add GLFWframebuffersizefun to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_callback = 0; +} + +void glfwSetFramebufferSizeCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWframebuffersizefun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetFramebufferSizeCallback_CALL_INSTANCE)); + CMOCK_glfwSetFramebufferSizeCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetFramebufferSizeCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetFramebufferSizeCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetFramebufferSizeCallback_CallInstance, cmock_guts_index); + Mock.glfwSetFramebufferSizeCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwSetFramebufferSizeCallback_IgnoreBool = (char)1; +} + +void glfwSetFramebufferSizeCallback_CMockStopIgnore(void) +{ + if(Mock.glfwSetFramebufferSizeCallback_IgnoreBool) + Mock.glfwSetFramebufferSizeCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetFramebufferSizeCallback_CallInstance); + Mock.glfwSetFramebufferSizeCallback_IgnoreBool = (char)0; +} + +void glfwSetFramebufferSizeCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWframebuffersizefun callback, GLFWframebuffersizefun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetFramebufferSizeCallback_CALL_INSTANCE)); + CMOCK_glfwSetFramebufferSizeCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetFramebufferSizeCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetFramebufferSizeCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetFramebufferSizeCallback_CallInstance, cmock_guts_index); + Mock.glfwSetFramebufferSizeCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetFramebufferSizeCallback(cmock_call_instance, window, callback); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(GLFWframebuffersizefun[sizeof(cmock_to_return) == sizeof(GLFWframebuffersizefun) ? 1 : -1])); /* add GLFWframebuffersizefun to :treat_as_array if this causes an error */ +} + +void glfwSetFramebufferSizeCallback_AddCallback(CMOCK_glfwSetFramebufferSizeCallback_CALLBACK Callback) +{ + Mock.glfwSetFramebufferSizeCallback_IgnoreBool = (char)0; + Mock.glfwSetFramebufferSizeCallback_CallbackBool = (char)1; + Mock.glfwSetFramebufferSizeCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetFramebufferSizeCallback_Stub(CMOCK_glfwSetFramebufferSizeCallback_CALLBACK Callback) +{ + Mock.glfwSetFramebufferSizeCallback_IgnoreBool = (char)0; + Mock.glfwSetFramebufferSizeCallback_CallbackBool = (char)0; + Mock.glfwSetFramebufferSizeCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetFramebufferSizeCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetFramebufferSizeCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetFramebufferSizeCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetFramebufferSizeCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetFramebufferSizeCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetFramebufferSizeCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetFramebufferSizeCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetFramebufferSizeCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_callback = 1; +} + +GLFWwindowcontentscalefun glfwSetWindowContentScaleCallback(GLFWwindow* window, GLFWwindowcontentscalefun callback) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetWindowContentScaleCallback_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetWindowContentScaleCallback); + cmock_call_instance = (CMOCK_glfwSetWindowContentScaleCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetWindowContentScaleCallback_CallInstance); + Mock.glfwSetWindowContentScaleCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetWindowContentScaleCallback_CallInstance); + if (Mock.glfwSetWindowContentScaleCallback_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwSetWindowContentScaleCallback_FinalReturn; + memcpy((void*)(&Mock.glfwSetWindowContentScaleCallback_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(GLFWwindowcontentscalefun[sizeof(cmock_call_instance->ReturnVal) == sizeof(GLFWwindowcontentscalefun) ? 1 : -1])); /* add GLFWwindowcontentscalefun to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwSetWindowContentScaleCallback_CallbackBool && + Mock.glfwSetWindowContentScaleCallback_CallbackFunctionPointer != NULL) + { + GLFWwindowcontentscalefun cmock_cb_ret = Mock.glfwSetWindowContentScaleCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetWindowContentScaleCallback_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowContentScaleCallback,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_callback) + { + UNITY_SET_DETAILS(CMockString_glfwSetWindowContentScaleCallback,CMockString_callback); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), sizeof(GLFWwindowcontentscalefun), cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetWindowContentScaleCallback_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwSetWindowContentScaleCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetWindowContentScaleCallback_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwSetWindowContentScaleCallback(CMOCK_glfwSetWindowContentScaleCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWwindowcontentscalefun callback); +void CMockExpectParameters_glfwSetWindowContentScaleCallback(CMOCK_glfwSetWindowContentScaleCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWwindowcontentscalefun callback) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + memcpy((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), + sizeof(GLFWwindowcontentscalefun[sizeof(callback) == sizeof(GLFWwindowcontentscalefun) ? 1 : -1])); /* add GLFWwindowcontentscalefun to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_callback = 0; +} + +void glfwSetWindowContentScaleCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindowcontentscalefun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetWindowContentScaleCallback_CALL_INSTANCE)); + CMOCK_glfwSetWindowContentScaleCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowContentScaleCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetWindowContentScaleCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetWindowContentScaleCallback_CallInstance, cmock_guts_index); + Mock.glfwSetWindowContentScaleCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwSetWindowContentScaleCallback_IgnoreBool = (char)1; +} + +void glfwSetWindowContentScaleCallback_CMockStopIgnore(void) +{ + if(Mock.glfwSetWindowContentScaleCallback_IgnoreBool) + Mock.glfwSetWindowContentScaleCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetWindowContentScaleCallback_CallInstance); + Mock.glfwSetWindowContentScaleCallback_IgnoreBool = (char)0; +} + +void glfwSetWindowContentScaleCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWwindowcontentscalefun callback, GLFWwindowcontentscalefun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetWindowContentScaleCallback_CALL_INSTANCE)); + CMOCK_glfwSetWindowContentScaleCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowContentScaleCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetWindowContentScaleCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetWindowContentScaleCallback_CallInstance, cmock_guts_index); + Mock.glfwSetWindowContentScaleCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetWindowContentScaleCallback(cmock_call_instance, window, callback); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(GLFWwindowcontentscalefun[sizeof(cmock_to_return) == sizeof(GLFWwindowcontentscalefun) ? 1 : -1])); /* add GLFWwindowcontentscalefun to :treat_as_array if this causes an error */ +} + +void glfwSetWindowContentScaleCallback_AddCallback(CMOCK_glfwSetWindowContentScaleCallback_CALLBACK Callback) +{ + Mock.glfwSetWindowContentScaleCallback_IgnoreBool = (char)0; + Mock.glfwSetWindowContentScaleCallback_CallbackBool = (char)1; + Mock.glfwSetWindowContentScaleCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowContentScaleCallback_Stub(CMOCK_glfwSetWindowContentScaleCallback_CALLBACK Callback) +{ + Mock.glfwSetWindowContentScaleCallback_IgnoreBool = (char)0; + Mock.glfwSetWindowContentScaleCallback_CallbackBool = (char)0; + Mock.glfwSetWindowContentScaleCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetWindowContentScaleCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowContentScaleCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowContentScaleCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowContentScaleCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetWindowContentScaleCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetWindowContentScaleCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetWindowContentScaleCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetWindowContentScaleCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_callback = 1; +} + +void glfwPollEvents(void) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwPollEvents_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwPollEvents); + cmock_call_instance = (CMOCK_glfwPollEvents_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwPollEvents_CallInstance); + Mock.glfwPollEvents_CallInstance = CMock_Guts_MemNext(Mock.glfwPollEvents_CallInstance); + if (Mock.glfwPollEvents_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwPollEvents_CallbackBool && + Mock.glfwPollEvents_CallbackFunctionPointer != NULL) + { + Mock.glfwPollEvents_CallbackFunctionPointer(Mock.glfwPollEvents_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (Mock.glfwPollEvents_CallbackFunctionPointer != NULL) + { + Mock.glfwPollEvents_CallbackFunctionPointer(Mock.glfwPollEvents_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void glfwPollEvents_CMockIgnore(void) +{ + Mock.glfwPollEvents_IgnoreBool = (char)1; +} + +void glfwPollEvents_CMockStopIgnore(void) +{ + Mock.glfwPollEvents_IgnoreBool = (char)0; +} + +void glfwPollEvents_CMockExpect(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwPollEvents_CALL_INSTANCE)); + CMOCK_glfwPollEvents_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwPollEvents_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwPollEvents_CallInstance = CMock_Guts_MemChain(Mock.glfwPollEvents_CallInstance, cmock_guts_index); + Mock.glfwPollEvents_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; +} + +void glfwPollEvents_AddCallback(CMOCK_glfwPollEvents_CALLBACK Callback) +{ + Mock.glfwPollEvents_IgnoreBool = (char)0; + Mock.glfwPollEvents_CallbackBool = (char)1; + Mock.glfwPollEvents_CallbackFunctionPointer = Callback; +} + +void glfwPollEvents_Stub(CMOCK_glfwPollEvents_CALLBACK Callback) +{ + Mock.glfwPollEvents_IgnoreBool = (char)0; + Mock.glfwPollEvents_CallbackBool = (char)0; + Mock.glfwPollEvents_CallbackFunctionPointer = Callback; +} + +void glfwWaitEvents(void) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwWaitEvents_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwWaitEvents); + cmock_call_instance = (CMOCK_glfwWaitEvents_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwWaitEvents_CallInstance); + Mock.glfwWaitEvents_CallInstance = CMock_Guts_MemNext(Mock.glfwWaitEvents_CallInstance); + if (Mock.glfwWaitEvents_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwWaitEvents_CallbackBool && + Mock.glfwWaitEvents_CallbackFunctionPointer != NULL) + { + Mock.glfwWaitEvents_CallbackFunctionPointer(Mock.glfwWaitEvents_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (Mock.glfwWaitEvents_CallbackFunctionPointer != NULL) + { + Mock.glfwWaitEvents_CallbackFunctionPointer(Mock.glfwWaitEvents_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void glfwWaitEvents_CMockIgnore(void) +{ + Mock.glfwWaitEvents_IgnoreBool = (char)1; +} + +void glfwWaitEvents_CMockStopIgnore(void) +{ + Mock.glfwWaitEvents_IgnoreBool = (char)0; +} + +void glfwWaitEvents_CMockExpect(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwWaitEvents_CALL_INSTANCE)); + CMOCK_glfwWaitEvents_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwWaitEvents_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwWaitEvents_CallInstance = CMock_Guts_MemChain(Mock.glfwWaitEvents_CallInstance, cmock_guts_index); + Mock.glfwWaitEvents_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; +} + +void glfwWaitEvents_AddCallback(CMOCK_glfwWaitEvents_CALLBACK Callback) +{ + Mock.glfwWaitEvents_IgnoreBool = (char)0; + Mock.glfwWaitEvents_CallbackBool = (char)1; + Mock.glfwWaitEvents_CallbackFunctionPointer = Callback; +} + +void glfwWaitEvents_Stub(CMOCK_glfwWaitEvents_CALLBACK Callback) +{ + Mock.glfwWaitEvents_IgnoreBool = (char)0; + Mock.glfwWaitEvents_CallbackBool = (char)0; + Mock.glfwWaitEvents_CallbackFunctionPointer = Callback; +} + +void glfwWaitEventsTimeout(double timeout) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwWaitEventsTimeout_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwWaitEventsTimeout); + cmock_call_instance = (CMOCK_glfwWaitEventsTimeout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwWaitEventsTimeout_CallInstance); + Mock.glfwWaitEventsTimeout_CallInstance = CMock_Guts_MemNext(Mock.glfwWaitEventsTimeout_CallInstance); + if (Mock.glfwWaitEventsTimeout_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwWaitEventsTimeout_CallbackBool && + Mock.glfwWaitEventsTimeout_CallbackFunctionPointer != NULL) + { + Mock.glfwWaitEventsTimeout_CallbackFunctionPointer(timeout, Mock.glfwWaitEventsTimeout_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_timeout) + { + UNITY_SET_DETAILS(CMockString_glfwWaitEventsTimeout,CMockString_timeout); + UNITY_TEST_ASSERT_EQUAL_FLOAT(cmock_call_instance->Expected_timeout, timeout, cmock_line, CMockStringMismatch); + } + if (Mock.glfwWaitEventsTimeout_CallbackFunctionPointer != NULL) + { + Mock.glfwWaitEventsTimeout_CallbackFunctionPointer(timeout, Mock.glfwWaitEventsTimeout_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwWaitEventsTimeout(CMOCK_glfwWaitEventsTimeout_CALL_INSTANCE* cmock_call_instance, double timeout); +void CMockExpectParameters_glfwWaitEventsTimeout(CMOCK_glfwWaitEventsTimeout_CALL_INSTANCE* cmock_call_instance, double timeout) +{ + cmock_call_instance->Expected_timeout = timeout; + cmock_call_instance->IgnoreArg_timeout = 0; +} + +void glfwWaitEventsTimeout_CMockIgnore(void) +{ + Mock.glfwWaitEventsTimeout_IgnoreBool = (char)1; +} + +void glfwWaitEventsTimeout_CMockStopIgnore(void) +{ + Mock.glfwWaitEventsTimeout_IgnoreBool = (char)0; +} + +void glfwWaitEventsTimeout_CMockExpect(UNITY_LINE_TYPE cmock_line, double timeout) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwWaitEventsTimeout_CALL_INSTANCE)); + CMOCK_glfwWaitEventsTimeout_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwWaitEventsTimeout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwWaitEventsTimeout_CallInstance = CMock_Guts_MemChain(Mock.glfwWaitEventsTimeout_CallInstance, cmock_guts_index); + Mock.glfwWaitEventsTimeout_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwWaitEventsTimeout(cmock_call_instance, timeout); +} + +void glfwWaitEventsTimeout_AddCallback(CMOCK_glfwWaitEventsTimeout_CALLBACK Callback) +{ + Mock.glfwWaitEventsTimeout_IgnoreBool = (char)0; + Mock.glfwWaitEventsTimeout_CallbackBool = (char)1; + Mock.glfwWaitEventsTimeout_CallbackFunctionPointer = Callback; +} + +void glfwWaitEventsTimeout_Stub(CMOCK_glfwWaitEventsTimeout_CALLBACK Callback) +{ + Mock.glfwWaitEventsTimeout_IgnoreBool = (char)0; + Mock.glfwWaitEventsTimeout_CallbackBool = (char)0; + Mock.glfwWaitEventsTimeout_CallbackFunctionPointer = Callback; +} + +void glfwWaitEventsTimeout_CMockIgnoreArg_timeout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwWaitEventsTimeout_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwWaitEventsTimeout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwWaitEventsTimeout_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_timeout = 1; +} + +void glfwPostEmptyEvent(void) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwPostEmptyEvent_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwPostEmptyEvent); + cmock_call_instance = (CMOCK_glfwPostEmptyEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwPostEmptyEvent_CallInstance); + Mock.glfwPostEmptyEvent_CallInstance = CMock_Guts_MemNext(Mock.glfwPostEmptyEvent_CallInstance); + if (Mock.glfwPostEmptyEvent_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwPostEmptyEvent_CallbackBool && + Mock.glfwPostEmptyEvent_CallbackFunctionPointer != NULL) + { + Mock.glfwPostEmptyEvent_CallbackFunctionPointer(Mock.glfwPostEmptyEvent_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (Mock.glfwPostEmptyEvent_CallbackFunctionPointer != NULL) + { + Mock.glfwPostEmptyEvent_CallbackFunctionPointer(Mock.glfwPostEmptyEvent_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void glfwPostEmptyEvent_CMockIgnore(void) +{ + Mock.glfwPostEmptyEvent_IgnoreBool = (char)1; +} + +void glfwPostEmptyEvent_CMockStopIgnore(void) +{ + Mock.glfwPostEmptyEvent_IgnoreBool = (char)0; +} + +void glfwPostEmptyEvent_CMockExpect(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwPostEmptyEvent_CALL_INSTANCE)); + CMOCK_glfwPostEmptyEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwPostEmptyEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwPostEmptyEvent_CallInstance = CMock_Guts_MemChain(Mock.glfwPostEmptyEvent_CallInstance, cmock_guts_index); + Mock.glfwPostEmptyEvent_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; +} + +void glfwPostEmptyEvent_AddCallback(CMOCK_glfwPostEmptyEvent_CALLBACK Callback) +{ + Mock.glfwPostEmptyEvent_IgnoreBool = (char)0; + Mock.glfwPostEmptyEvent_CallbackBool = (char)1; + Mock.glfwPostEmptyEvent_CallbackFunctionPointer = Callback; +} + +void glfwPostEmptyEvent_Stub(CMOCK_glfwPostEmptyEvent_CALLBACK Callback) +{ + Mock.glfwPostEmptyEvent_IgnoreBool = (char)0; + Mock.glfwPostEmptyEvent_CallbackBool = (char)0; + Mock.glfwPostEmptyEvent_CallbackFunctionPointer = Callback; +} + +int glfwGetInputMode(GLFWwindow* window, int mode) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetInputMode_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetInputMode); + cmock_call_instance = (CMOCK_glfwGetInputMode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetInputMode_CallInstance); + Mock.glfwGetInputMode_CallInstance = CMock_Guts_MemNext(Mock.glfwGetInputMode_CallInstance); + if (Mock.glfwGetInputMode_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetInputMode_FinalReturn; + Mock.glfwGetInputMode_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetInputMode_CallbackBool && + Mock.glfwGetInputMode_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.glfwGetInputMode_CallbackFunctionPointer(window, mode, Mock.glfwGetInputMode_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwGetInputMode,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_mode) + { + UNITY_SET_DETAILS(CMockString_glfwGetInputMode,CMockString_mode); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_mode, mode, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetInputMode_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetInputMode_CallbackFunctionPointer(window, mode, Mock.glfwGetInputMode_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwGetInputMode(CMOCK_glfwGetInputMode_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int mode); +void CMockExpectParameters_glfwGetInputMode(CMOCK_glfwGetInputMode_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int mode) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + cmock_call_instance->Expected_mode = mode; + cmock_call_instance->IgnoreArg_mode = 0; +} + +void glfwGetInputMode_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetInputMode_CALL_INSTANCE)); + CMOCK_glfwGetInputMode_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetInputMode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetInputMode_CallInstance = CMock_Guts_MemChain(Mock.glfwGetInputMode_CallInstance, cmock_guts_index); + Mock.glfwGetInputMode_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetInputMode_IgnoreBool = (char)1; +} + +void glfwGetInputMode_CMockStopIgnore(void) +{ + if(Mock.glfwGetInputMode_IgnoreBool) + Mock.glfwGetInputMode_CallInstance = CMock_Guts_MemNext(Mock.glfwGetInputMode_CallInstance); + Mock.glfwGetInputMode_IgnoreBool = (char)0; +} + +void glfwGetInputMode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int mode, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetInputMode_CALL_INSTANCE)); + CMOCK_glfwGetInputMode_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetInputMode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetInputMode_CallInstance = CMock_Guts_MemChain(Mock.glfwGetInputMode_CallInstance, cmock_guts_index); + Mock.glfwGetInputMode_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetInputMode(cmock_call_instance, window, mode); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwGetInputMode_AddCallback(CMOCK_glfwGetInputMode_CALLBACK Callback) +{ + Mock.glfwGetInputMode_IgnoreBool = (char)0; + Mock.glfwGetInputMode_CallbackBool = (char)1; + Mock.glfwGetInputMode_CallbackFunctionPointer = Callback; +} + +void glfwGetInputMode_Stub(CMOCK_glfwGetInputMode_CALLBACK Callback) +{ + Mock.glfwGetInputMode_IgnoreBool = (char)0; + Mock.glfwGetInputMode_CallbackBool = (char)0; + Mock.glfwGetInputMode_CallbackFunctionPointer = Callback; +} + +void glfwGetInputMode_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetInputMode_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetInputMode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetInputMode_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwGetInputMode_CMockIgnoreArg_mode(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetInputMode_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetInputMode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetInputMode_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_mode = 1; +} + +void glfwSetInputMode(GLFWwindow* window, int mode, int value) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetInputMode_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetInputMode); + cmock_call_instance = (CMOCK_glfwSetInputMode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetInputMode_CallInstance); + Mock.glfwSetInputMode_CallInstance = CMock_Guts_MemNext(Mock.glfwSetInputMode_CallInstance); + if (Mock.glfwSetInputMode_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwSetInputMode_CallbackBool && + Mock.glfwSetInputMode_CallbackFunctionPointer != NULL) + { + Mock.glfwSetInputMode_CallbackFunctionPointer(window, mode, value, Mock.glfwSetInputMode_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetInputMode,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_mode) + { + UNITY_SET_DETAILS(CMockString_glfwSetInputMode,CMockString_mode); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_mode, mode, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_value) + { + UNITY_SET_DETAILS(CMockString_glfwSetInputMode,CMockString_value); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_value, value, cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetInputMode_CallbackFunctionPointer != NULL) + { + Mock.glfwSetInputMode_CallbackFunctionPointer(window, mode, value, Mock.glfwSetInputMode_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwSetInputMode(CMOCK_glfwSetInputMode_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int mode, int value); +void CMockExpectParameters_glfwSetInputMode(CMOCK_glfwSetInputMode_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int mode, int value) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + cmock_call_instance->Expected_mode = mode; + cmock_call_instance->IgnoreArg_mode = 0; + cmock_call_instance->Expected_value = value; + cmock_call_instance->IgnoreArg_value = 0; +} + +void glfwSetInputMode_CMockIgnore(void) +{ + Mock.glfwSetInputMode_IgnoreBool = (char)1; +} + +void glfwSetInputMode_CMockStopIgnore(void) +{ + Mock.glfwSetInputMode_IgnoreBool = (char)0; +} + +void glfwSetInputMode_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int mode, int value) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetInputMode_CALL_INSTANCE)); + CMOCK_glfwSetInputMode_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetInputMode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetInputMode_CallInstance = CMock_Guts_MemChain(Mock.glfwSetInputMode_CallInstance, cmock_guts_index); + Mock.glfwSetInputMode_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetInputMode(cmock_call_instance, window, mode, value); +} + +void glfwSetInputMode_AddCallback(CMOCK_glfwSetInputMode_CALLBACK Callback) +{ + Mock.glfwSetInputMode_IgnoreBool = (char)0; + Mock.glfwSetInputMode_CallbackBool = (char)1; + Mock.glfwSetInputMode_CallbackFunctionPointer = Callback; +} + +void glfwSetInputMode_Stub(CMOCK_glfwSetInputMode_CALLBACK Callback) +{ + Mock.glfwSetInputMode_IgnoreBool = (char)0; + Mock.glfwSetInputMode_CallbackBool = (char)0; + Mock.glfwSetInputMode_CallbackFunctionPointer = Callback; +} + +void glfwSetInputMode_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetInputMode_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetInputMode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetInputMode_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetInputMode_CMockIgnoreArg_mode(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetInputMode_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetInputMode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetInputMode_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_mode = 1; +} + +void glfwSetInputMode_CMockIgnoreArg_value(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetInputMode_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetInputMode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetInputMode_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_value = 1; +} + +int glfwRawMouseMotionSupported(void) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwRawMouseMotionSupported_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwRawMouseMotionSupported); + cmock_call_instance = (CMOCK_glfwRawMouseMotionSupported_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwRawMouseMotionSupported_CallInstance); + Mock.glfwRawMouseMotionSupported_CallInstance = CMock_Guts_MemNext(Mock.glfwRawMouseMotionSupported_CallInstance); + if (Mock.glfwRawMouseMotionSupported_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwRawMouseMotionSupported_FinalReturn; + Mock.glfwRawMouseMotionSupported_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwRawMouseMotionSupported_CallbackBool && + Mock.glfwRawMouseMotionSupported_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.glfwRawMouseMotionSupported_CallbackFunctionPointer(Mock.glfwRawMouseMotionSupported_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (Mock.glfwRawMouseMotionSupported_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwRawMouseMotionSupported_CallbackFunctionPointer(Mock.glfwRawMouseMotionSupported_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void glfwRawMouseMotionSupported_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwRawMouseMotionSupported_CALL_INSTANCE)); + CMOCK_glfwRawMouseMotionSupported_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwRawMouseMotionSupported_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwRawMouseMotionSupported_CallInstance = CMock_Guts_MemChain(Mock.glfwRawMouseMotionSupported_CallInstance, cmock_guts_index); + Mock.glfwRawMouseMotionSupported_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwRawMouseMotionSupported_IgnoreBool = (char)1; +} + +void glfwRawMouseMotionSupported_CMockStopIgnore(void) +{ + if(Mock.glfwRawMouseMotionSupported_IgnoreBool) + Mock.glfwRawMouseMotionSupported_CallInstance = CMock_Guts_MemNext(Mock.glfwRawMouseMotionSupported_CallInstance); + Mock.glfwRawMouseMotionSupported_IgnoreBool = (char)0; +} + +void glfwRawMouseMotionSupported_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwRawMouseMotionSupported_CALL_INSTANCE)); + CMOCK_glfwRawMouseMotionSupported_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwRawMouseMotionSupported_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwRawMouseMotionSupported_CallInstance = CMock_Guts_MemChain(Mock.glfwRawMouseMotionSupported_CallInstance, cmock_guts_index); + Mock.glfwRawMouseMotionSupported_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwRawMouseMotionSupported_AddCallback(CMOCK_glfwRawMouseMotionSupported_CALLBACK Callback) +{ + Mock.glfwRawMouseMotionSupported_IgnoreBool = (char)0; + Mock.glfwRawMouseMotionSupported_CallbackBool = (char)1; + Mock.glfwRawMouseMotionSupported_CallbackFunctionPointer = Callback; +} + +void glfwRawMouseMotionSupported_Stub(CMOCK_glfwRawMouseMotionSupported_CALLBACK Callback) +{ + Mock.glfwRawMouseMotionSupported_IgnoreBool = (char)0; + Mock.glfwRawMouseMotionSupported_CallbackBool = (char)0; + Mock.glfwRawMouseMotionSupported_CallbackFunctionPointer = Callback; +} + +const char* glfwGetKeyName(int key, int scancode) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetKeyName_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetKeyName); + cmock_call_instance = (CMOCK_glfwGetKeyName_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetKeyName_CallInstance); + Mock.glfwGetKeyName_CallInstance = CMock_Guts_MemNext(Mock.glfwGetKeyName_CallInstance); + if (Mock.glfwGetKeyName_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetKeyName_FinalReturn; + Mock.glfwGetKeyName_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetKeyName_CallbackBool && + Mock.glfwGetKeyName_CallbackFunctionPointer != NULL) + { + const char* cmock_cb_ret = Mock.glfwGetKeyName_CallbackFunctionPointer(key, scancode, Mock.glfwGetKeyName_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_key) + { + UNITY_SET_DETAILS(CMockString_glfwGetKeyName,CMockString_key); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_key, key, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_scancode) + { + UNITY_SET_DETAILS(CMockString_glfwGetKeyName,CMockString_scancode); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_scancode, scancode, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetKeyName_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetKeyName_CallbackFunctionPointer(key, scancode, Mock.glfwGetKeyName_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwGetKeyName(CMOCK_glfwGetKeyName_CALL_INSTANCE* cmock_call_instance, int key, int scancode); +void CMockExpectParameters_glfwGetKeyName(CMOCK_glfwGetKeyName_CALL_INSTANCE* cmock_call_instance, int key, int scancode) +{ + cmock_call_instance->Expected_key = key; + cmock_call_instance->IgnoreArg_key = 0; + cmock_call_instance->Expected_scancode = scancode; + cmock_call_instance->IgnoreArg_scancode = 0; +} + +void glfwGetKeyName_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, const char* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetKeyName_CALL_INSTANCE)); + CMOCK_glfwGetKeyName_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetKeyName_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetKeyName_CallInstance = CMock_Guts_MemChain(Mock.glfwGetKeyName_CallInstance, cmock_guts_index); + Mock.glfwGetKeyName_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetKeyName_IgnoreBool = (char)1; +} + +void glfwGetKeyName_CMockStopIgnore(void) +{ + if(Mock.glfwGetKeyName_IgnoreBool) + Mock.glfwGetKeyName_CallInstance = CMock_Guts_MemNext(Mock.glfwGetKeyName_CallInstance); + Mock.glfwGetKeyName_IgnoreBool = (char)0; +} + +void glfwGetKeyName_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int key, int scancode, const char* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetKeyName_CALL_INSTANCE)); + CMOCK_glfwGetKeyName_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetKeyName_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetKeyName_CallInstance = CMock_Guts_MemChain(Mock.glfwGetKeyName_CallInstance, cmock_guts_index); + Mock.glfwGetKeyName_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetKeyName(cmock_call_instance, key, scancode); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwGetKeyName_AddCallback(CMOCK_glfwGetKeyName_CALLBACK Callback) +{ + Mock.glfwGetKeyName_IgnoreBool = (char)0; + Mock.glfwGetKeyName_CallbackBool = (char)1; + Mock.glfwGetKeyName_CallbackFunctionPointer = Callback; +} + +void glfwGetKeyName_Stub(CMOCK_glfwGetKeyName_CALLBACK Callback) +{ + Mock.glfwGetKeyName_IgnoreBool = (char)0; + Mock.glfwGetKeyName_CallbackBool = (char)0; + Mock.glfwGetKeyName_CallbackFunctionPointer = Callback; +} + +void glfwGetKeyName_CMockIgnoreArg_key(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetKeyName_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetKeyName_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetKeyName_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_key = 1; +} + +void glfwGetKeyName_CMockIgnoreArg_scancode(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetKeyName_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetKeyName_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetKeyName_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_scancode = 1; +} + +int glfwGetKeyScancode(int key) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetKeyScancode_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetKeyScancode); + cmock_call_instance = (CMOCK_glfwGetKeyScancode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetKeyScancode_CallInstance); + Mock.glfwGetKeyScancode_CallInstance = CMock_Guts_MemNext(Mock.glfwGetKeyScancode_CallInstance); + if (Mock.glfwGetKeyScancode_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetKeyScancode_FinalReturn; + Mock.glfwGetKeyScancode_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetKeyScancode_CallbackBool && + Mock.glfwGetKeyScancode_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.glfwGetKeyScancode_CallbackFunctionPointer(key, Mock.glfwGetKeyScancode_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_key) + { + UNITY_SET_DETAILS(CMockString_glfwGetKeyScancode,CMockString_key); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_key, key, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetKeyScancode_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetKeyScancode_CallbackFunctionPointer(key, Mock.glfwGetKeyScancode_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwGetKeyScancode(CMOCK_glfwGetKeyScancode_CALL_INSTANCE* cmock_call_instance, int key); +void CMockExpectParameters_glfwGetKeyScancode(CMOCK_glfwGetKeyScancode_CALL_INSTANCE* cmock_call_instance, int key) +{ + cmock_call_instance->Expected_key = key; + cmock_call_instance->IgnoreArg_key = 0; +} + +void glfwGetKeyScancode_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetKeyScancode_CALL_INSTANCE)); + CMOCK_glfwGetKeyScancode_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetKeyScancode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetKeyScancode_CallInstance = CMock_Guts_MemChain(Mock.glfwGetKeyScancode_CallInstance, cmock_guts_index); + Mock.glfwGetKeyScancode_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetKeyScancode_IgnoreBool = (char)1; +} + +void glfwGetKeyScancode_CMockStopIgnore(void) +{ + if(Mock.glfwGetKeyScancode_IgnoreBool) + Mock.glfwGetKeyScancode_CallInstance = CMock_Guts_MemNext(Mock.glfwGetKeyScancode_CallInstance); + Mock.glfwGetKeyScancode_IgnoreBool = (char)0; +} + +void glfwGetKeyScancode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int key, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetKeyScancode_CALL_INSTANCE)); + CMOCK_glfwGetKeyScancode_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetKeyScancode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetKeyScancode_CallInstance = CMock_Guts_MemChain(Mock.glfwGetKeyScancode_CallInstance, cmock_guts_index); + Mock.glfwGetKeyScancode_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetKeyScancode(cmock_call_instance, key); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwGetKeyScancode_AddCallback(CMOCK_glfwGetKeyScancode_CALLBACK Callback) +{ + Mock.glfwGetKeyScancode_IgnoreBool = (char)0; + Mock.glfwGetKeyScancode_CallbackBool = (char)1; + Mock.glfwGetKeyScancode_CallbackFunctionPointer = Callback; +} + +void glfwGetKeyScancode_Stub(CMOCK_glfwGetKeyScancode_CALLBACK Callback) +{ + Mock.glfwGetKeyScancode_IgnoreBool = (char)0; + Mock.glfwGetKeyScancode_CallbackBool = (char)0; + Mock.glfwGetKeyScancode_CallbackFunctionPointer = Callback; +} + +void glfwGetKeyScancode_CMockIgnoreArg_key(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetKeyScancode_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetKeyScancode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetKeyScancode_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_key = 1; +} + +int glfwGetKey(GLFWwindow* window, int key) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetKey_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetKey); + cmock_call_instance = (CMOCK_glfwGetKey_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetKey_CallInstance); + Mock.glfwGetKey_CallInstance = CMock_Guts_MemNext(Mock.glfwGetKey_CallInstance); + if (Mock.glfwGetKey_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetKey_FinalReturn; + Mock.glfwGetKey_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetKey_CallbackBool && + Mock.glfwGetKey_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.glfwGetKey_CallbackFunctionPointer(window, key, Mock.glfwGetKey_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwGetKey,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_key) + { + UNITY_SET_DETAILS(CMockString_glfwGetKey,CMockString_key); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_key, key, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetKey_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetKey_CallbackFunctionPointer(window, key, Mock.glfwGetKey_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwGetKey(CMOCK_glfwGetKey_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int key); +void CMockExpectParameters_glfwGetKey(CMOCK_glfwGetKey_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int key) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + cmock_call_instance->Expected_key = key; + cmock_call_instance->IgnoreArg_key = 0; +} + +void glfwGetKey_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetKey_CALL_INSTANCE)); + CMOCK_glfwGetKey_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetKey_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetKey_CallInstance = CMock_Guts_MemChain(Mock.glfwGetKey_CallInstance, cmock_guts_index); + Mock.glfwGetKey_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetKey_IgnoreBool = (char)1; +} + +void glfwGetKey_CMockStopIgnore(void) +{ + if(Mock.glfwGetKey_IgnoreBool) + Mock.glfwGetKey_CallInstance = CMock_Guts_MemNext(Mock.glfwGetKey_CallInstance); + Mock.glfwGetKey_IgnoreBool = (char)0; +} + +void glfwGetKey_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int key, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetKey_CALL_INSTANCE)); + CMOCK_glfwGetKey_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetKey_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetKey_CallInstance = CMock_Guts_MemChain(Mock.glfwGetKey_CallInstance, cmock_guts_index); + Mock.glfwGetKey_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetKey(cmock_call_instance, window, key); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwGetKey_AddCallback(CMOCK_glfwGetKey_CALLBACK Callback) +{ + Mock.glfwGetKey_IgnoreBool = (char)0; + Mock.glfwGetKey_CallbackBool = (char)1; + Mock.glfwGetKey_CallbackFunctionPointer = Callback; +} + +void glfwGetKey_Stub(CMOCK_glfwGetKey_CALLBACK Callback) +{ + Mock.glfwGetKey_IgnoreBool = (char)0; + Mock.glfwGetKey_CallbackBool = (char)0; + Mock.glfwGetKey_CallbackFunctionPointer = Callback; +} + +void glfwGetKey_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetKey_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetKey_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetKey_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwGetKey_CMockIgnoreArg_key(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetKey_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetKey_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetKey_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_key = 1; +} + +int glfwGetMouseButton(GLFWwindow* window, int button) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetMouseButton_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetMouseButton); + cmock_call_instance = (CMOCK_glfwGetMouseButton_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetMouseButton_CallInstance); + Mock.glfwGetMouseButton_CallInstance = CMock_Guts_MemNext(Mock.glfwGetMouseButton_CallInstance); + if (Mock.glfwGetMouseButton_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetMouseButton_FinalReturn; + Mock.glfwGetMouseButton_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetMouseButton_CallbackBool && + Mock.glfwGetMouseButton_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.glfwGetMouseButton_CallbackFunctionPointer(window, button, Mock.glfwGetMouseButton_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwGetMouseButton,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_button) + { + UNITY_SET_DETAILS(CMockString_glfwGetMouseButton,CMockString_button); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_button, button, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetMouseButton_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetMouseButton_CallbackFunctionPointer(window, button, Mock.glfwGetMouseButton_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwGetMouseButton(CMOCK_glfwGetMouseButton_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int button); +void CMockExpectParameters_glfwGetMouseButton(CMOCK_glfwGetMouseButton_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, int button) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + cmock_call_instance->Expected_button = button; + cmock_call_instance->IgnoreArg_button = 0; +} + +void glfwGetMouseButton_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetMouseButton_CALL_INSTANCE)); + CMOCK_glfwGetMouseButton_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMouseButton_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetMouseButton_CallInstance = CMock_Guts_MemChain(Mock.glfwGetMouseButton_CallInstance, cmock_guts_index); + Mock.glfwGetMouseButton_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetMouseButton_IgnoreBool = (char)1; +} + +void glfwGetMouseButton_CMockStopIgnore(void) +{ + if(Mock.glfwGetMouseButton_IgnoreBool) + Mock.glfwGetMouseButton_CallInstance = CMock_Guts_MemNext(Mock.glfwGetMouseButton_CallInstance); + Mock.glfwGetMouseButton_IgnoreBool = (char)0; +} + +void glfwGetMouseButton_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int button, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetMouseButton_CALL_INSTANCE)); + CMOCK_glfwGetMouseButton_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMouseButton_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetMouseButton_CallInstance = CMock_Guts_MemChain(Mock.glfwGetMouseButton_CallInstance, cmock_guts_index); + Mock.glfwGetMouseButton_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetMouseButton(cmock_call_instance, window, button); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwGetMouseButton_AddCallback(CMOCK_glfwGetMouseButton_CALLBACK Callback) +{ + Mock.glfwGetMouseButton_IgnoreBool = (char)0; + Mock.glfwGetMouseButton_CallbackBool = (char)1; + Mock.glfwGetMouseButton_CallbackFunctionPointer = Callback; +} + +void glfwGetMouseButton_Stub(CMOCK_glfwGetMouseButton_CALLBACK Callback) +{ + Mock.glfwGetMouseButton_IgnoreBool = (char)0; + Mock.glfwGetMouseButton_CallbackBool = (char)0; + Mock.glfwGetMouseButton_CallbackFunctionPointer = Callback; +} + +void glfwGetMouseButton_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetMouseButton_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMouseButton_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetMouseButton_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwGetMouseButton_CMockIgnoreArg_button(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetMouseButton_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetMouseButton_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetMouseButton_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_button = 1; +} + +void glfwGetCursorPos(GLFWwindow* window, double* xpos, double* ypos) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetCursorPos_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetCursorPos); + cmock_call_instance = (CMOCK_glfwGetCursorPos_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetCursorPos_CallInstance); + Mock.glfwGetCursorPos_CallInstance = CMock_Guts_MemNext(Mock.glfwGetCursorPos_CallInstance); + if (Mock.glfwGetCursorPos_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwGetCursorPos_CallbackBool && + Mock.glfwGetCursorPos_CallbackFunctionPointer != NULL) + { + Mock.glfwGetCursorPos_CallbackFunctionPointer(window, xpos, ypos, Mock.glfwGetCursorPos_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwGetCursorPos,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_xpos) + { + UNITY_SET_DETAILS(CMockString_glfwGetCursorPos,CMockString_xpos); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_xpos, xpos, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_ypos) + { + UNITY_SET_DETAILS(CMockString_glfwGetCursorPos,CMockString_ypos); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_ypos, ypos, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetCursorPos_CallbackFunctionPointer != NULL) + { + Mock.glfwGetCursorPos_CallbackFunctionPointer(window, xpos, ypos, Mock.glfwGetCursorPos_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwGetCursorPos(CMOCK_glfwGetCursorPos_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, double* xpos, double* ypos); +void CMockExpectParameters_glfwGetCursorPos(CMOCK_glfwGetCursorPos_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, double* xpos, double* ypos) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + cmock_call_instance->Expected_xpos = xpos; + cmock_call_instance->IgnoreArg_xpos = 0; + cmock_call_instance->Expected_ypos = ypos; + cmock_call_instance->IgnoreArg_ypos = 0; +} + +void glfwGetCursorPos_CMockIgnore(void) +{ + Mock.glfwGetCursorPos_IgnoreBool = (char)1; +} + +void glfwGetCursorPos_CMockStopIgnore(void) +{ + Mock.glfwGetCursorPos_IgnoreBool = (char)0; +} + +void glfwGetCursorPos_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, double* xpos, double* ypos) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetCursorPos_CALL_INSTANCE)); + CMOCK_glfwGetCursorPos_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetCursorPos_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetCursorPos_CallInstance = CMock_Guts_MemChain(Mock.glfwGetCursorPos_CallInstance, cmock_guts_index); + Mock.glfwGetCursorPos_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetCursorPos(cmock_call_instance, window, xpos, ypos); +} + +void glfwGetCursorPos_AddCallback(CMOCK_glfwGetCursorPos_CALLBACK Callback) +{ + Mock.glfwGetCursorPos_IgnoreBool = (char)0; + Mock.glfwGetCursorPos_CallbackBool = (char)1; + Mock.glfwGetCursorPos_CallbackFunctionPointer = Callback; +} + +void glfwGetCursorPos_Stub(CMOCK_glfwGetCursorPos_CALLBACK Callback) +{ + Mock.glfwGetCursorPos_IgnoreBool = (char)0; + Mock.glfwGetCursorPos_CallbackBool = (char)0; + Mock.glfwGetCursorPos_CallbackFunctionPointer = Callback; +} + +void glfwGetCursorPos_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetCursorPos_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetCursorPos_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetCursorPos_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwGetCursorPos_CMockIgnoreArg_xpos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetCursorPos_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetCursorPos_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetCursorPos_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_xpos = 1; +} + +void glfwGetCursorPos_CMockIgnoreArg_ypos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetCursorPos_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetCursorPos_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetCursorPos_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_ypos = 1; +} + +void glfwSetCursorPos(GLFWwindow* window, double xpos, double ypos) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetCursorPos_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetCursorPos); + cmock_call_instance = (CMOCK_glfwSetCursorPos_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetCursorPos_CallInstance); + Mock.glfwSetCursorPos_CallInstance = CMock_Guts_MemNext(Mock.glfwSetCursorPos_CallInstance); + if (Mock.glfwSetCursorPos_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwSetCursorPos_CallbackBool && + Mock.glfwSetCursorPos_CallbackFunctionPointer != NULL) + { + Mock.glfwSetCursorPos_CallbackFunctionPointer(window, xpos, ypos, Mock.glfwSetCursorPos_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetCursorPos,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_xpos) + { + UNITY_SET_DETAILS(CMockString_glfwSetCursorPos,CMockString_xpos); + UNITY_TEST_ASSERT_EQUAL_FLOAT(cmock_call_instance->Expected_xpos, xpos, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_ypos) + { + UNITY_SET_DETAILS(CMockString_glfwSetCursorPos,CMockString_ypos); + UNITY_TEST_ASSERT_EQUAL_FLOAT(cmock_call_instance->Expected_ypos, ypos, cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetCursorPos_CallbackFunctionPointer != NULL) + { + Mock.glfwSetCursorPos_CallbackFunctionPointer(window, xpos, ypos, Mock.glfwSetCursorPos_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwSetCursorPos(CMOCK_glfwSetCursorPos_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, double xpos, double ypos); +void CMockExpectParameters_glfwSetCursorPos(CMOCK_glfwSetCursorPos_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, double xpos, double ypos) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + cmock_call_instance->Expected_xpos = xpos; + cmock_call_instance->IgnoreArg_xpos = 0; + cmock_call_instance->Expected_ypos = ypos; + cmock_call_instance->IgnoreArg_ypos = 0; +} + +void glfwSetCursorPos_CMockIgnore(void) +{ + Mock.glfwSetCursorPos_IgnoreBool = (char)1; +} + +void glfwSetCursorPos_CMockStopIgnore(void) +{ + Mock.glfwSetCursorPos_IgnoreBool = (char)0; +} + +void glfwSetCursorPos_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, double xpos, double ypos) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetCursorPos_CALL_INSTANCE)); + CMOCK_glfwSetCursorPos_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetCursorPos_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetCursorPos_CallInstance = CMock_Guts_MemChain(Mock.glfwSetCursorPos_CallInstance, cmock_guts_index); + Mock.glfwSetCursorPos_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetCursorPos(cmock_call_instance, window, xpos, ypos); +} + +void glfwSetCursorPos_AddCallback(CMOCK_glfwSetCursorPos_CALLBACK Callback) +{ + Mock.glfwSetCursorPos_IgnoreBool = (char)0; + Mock.glfwSetCursorPos_CallbackBool = (char)1; + Mock.glfwSetCursorPos_CallbackFunctionPointer = Callback; +} + +void glfwSetCursorPos_Stub(CMOCK_glfwSetCursorPos_CALLBACK Callback) +{ + Mock.glfwSetCursorPos_IgnoreBool = (char)0; + Mock.glfwSetCursorPos_CallbackBool = (char)0; + Mock.glfwSetCursorPos_CallbackFunctionPointer = Callback; +} + +void glfwSetCursorPos_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetCursorPos_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetCursorPos_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetCursorPos_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetCursorPos_CMockIgnoreArg_xpos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetCursorPos_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetCursorPos_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetCursorPos_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_xpos = 1; +} + +void glfwSetCursorPos_CMockIgnoreArg_ypos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetCursorPos_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetCursorPos_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetCursorPos_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_ypos = 1; +} + +GLFWcursor* glfwCreateCursor(const GLFWimage* image, int xhot, int yhot) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwCreateCursor_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwCreateCursor); + cmock_call_instance = (CMOCK_glfwCreateCursor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwCreateCursor_CallInstance); + Mock.glfwCreateCursor_CallInstance = CMock_Guts_MemNext(Mock.glfwCreateCursor_CallInstance); + if (Mock.glfwCreateCursor_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwCreateCursor_FinalReturn; + Mock.glfwCreateCursor_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwCreateCursor_CallbackBool && + Mock.glfwCreateCursor_CallbackFunctionPointer != NULL) + { + GLFWcursor* cmock_cb_ret = Mock.glfwCreateCursor_CallbackFunctionPointer(image, xhot, yhot, Mock.glfwCreateCursor_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_image) + { + UNITY_SET_DETAILS(CMockString_glfwCreateCursor,CMockString_image); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_image, image, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_xhot) + { + UNITY_SET_DETAILS(CMockString_glfwCreateCursor,CMockString_xhot); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_xhot, xhot, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_yhot) + { + UNITY_SET_DETAILS(CMockString_glfwCreateCursor,CMockString_yhot); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_yhot, yhot, cmock_line, CMockStringMismatch); + } + if (Mock.glfwCreateCursor_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwCreateCursor_CallbackFunctionPointer(image, xhot, yhot, Mock.glfwCreateCursor_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwCreateCursor(CMOCK_glfwCreateCursor_CALL_INSTANCE* cmock_call_instance, const GLFWimage* image, int xhot, int yhot); +void CMockExpectParameters_glfwCreateCursor(CMOCK_glfwCreateCursor_CALL_INSTANCE* cmock_call_instance, const GLFWimage* image, int xhot, int yhot) +{ + cmock_call_instance->Expected_image = image; + cmock_call_instance->IgnoreArg_image = 0; + cmock_call_instance->Expected_xhot = xhot; + cmock_call_instance->IgnoreArg_xhot = 0; + cmock_call_instance->Expected_yhot = yhot; + cmock_call_instance->IgnoreArg_yhot = 0; +} + +void glfwCreateCursor_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWcursor* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwCreateCursor_CALL_INSTANCE)); + CMOCK_glfwCreateCursor_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwCreateCursor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwCreateCursor_CallInstance = CMock_Guts_MemChain(Mock.glfwCreateCursor_CallInstance, cmock_guts_index); + Mock.glfwCreateCursor_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwCreateCursor_IgnoreBool = (char)1; +} + +void glfwCreateCursor_CMockStopIgnore(void) +{ + if(Mock.glfwCreateCursor_IgnoreBool) + Mock.glfwCreateCursor_CallInstance = CMock_Guts_MemNext(Mock.glfwCreateCursor_CallInstance); + Mock.glfwCreateCursor_IgnoreBool = (char)0; +} + +void glfwCreateCursor_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, const GLFWimage* image, int xhot, int yhot, GLFWcursor* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwCreateCursor_CALL_INSTANCE)); + CMOCK_glfwCreateCursor_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwCreateCursor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwCreateCursor_CallInstance = CMock_Guts_MemChain(Mock.glfwCreateCursor_CallInstance, cmock_guts_index); + Mock.glfwCreateCursor_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwCreateCursor(cmock_call_instance, image, xhot, yhot); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwCreateCursor_AddCallback(CMOCK_glfwCreateCursor_CALLBACK Callback) +{ + Mock.glfwCreateCursor_IgnoreBool = (char)0; + Mock.glfwCreateCursor_CallbackBool = (char)1; + Mock.glfwCreateCursor_CallbackFunctionPointer = Callback; +} + +void glfwCreateCursor_Stub(CMOCK_glfwCreateCursor_CALLBACK Callback) +{ + Mock.glfwCreateCursor_IgnoreBool = (char)0; + Mock.glfwCreateCursor_CallbackBool = (char)0; + Mock.glfwCreateCursor_CallbackFunctionPointer = Callback; +} + +void glfwCreateCursor_CMockIgnoreArg_image(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwCreateCursor_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwCreateCursor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwCreateCursor_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_image = 1; +} + +void glfwCreateCursor_CMockIgnoreArg_xhot(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwCreateCursor_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwCreateCursor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwCreateCursor_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_xhot = 1; +} + +void glfwCreateCursor_CMockIgnoreArg_yhot(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwCreateCursor_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwCreateCursor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwCreateCursor_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_yhot = 1; +} + +GLFWcursor* glfwCreateStandardCursor(int shape) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwCreateStandardCursor_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwCreateStandardCursor); + cmock_call_instance = (CMOCK_glfwCreateStandardCursor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwCreateStandardCursor_CallInstance); + Mock.glfwCreateStandardCursor_CallInstance = CMock_Guts_MemNext(Mock.glfwCreateStandardCursor_CallInstance); + if (Mock.glfwCreateStandardCursor_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwCreateStandardCursor_FinalReturn; + Mock.glfwCreateStandardCursor_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwCreateStandardCursor_CallbackBool && + Mock.glfwCreateStandardCursor_CallbackFunctionPointer != NULL) + { + GLFWcursor* cmock_cb_ret = Mock.glfwCreateStandardCursor_CallbackFunctionPointer(shape, Mock.glfwCreateStandardCursor_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_shape) + { + UNITY_SET_DETAILS(CMockString_glfwCreateStandardCursor,CMockString_shape); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_shape, shape, cmock_line, CMockStringMismatch); + } + if (Mock.glfwCreateStandardCursor_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwCreateStandardCursor_CallbackFunctionPointer(shape, Mock.glfwCreateStandardCursor_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwCreateStandardCursor(CMOCK_glfwCreateStandardCursor_CALL_INSTANCE* cmock_call_instance, int shape); +void CMockExpectParameters_glfwCreateStandardCursor(CMOCK_glfwCreateStandardCursor_CALL_INSTANCE* cmock_call_instance, int shape) +{ + cmock_call_instance->Expected_shape = shape; + cmock_call_instance->IgnoreArg_shape = 0; +} + +void glfwCreateStandardCursor_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWcursor* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwCreateStandardCursor_CALL_INSTANCE)); + CMOCK_glfwCreateStandardCursor_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwCreateStandardCursor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwCreateStandardCursor_CallInstance = CMock_Guts_MemChain(Mock.glfwCreateStandardCursor_CallInstance, cmock_guts_index); + Mock.glfwCreateStandardCursor_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwCreateStandardCursor_IgnoreBool = (char)1; +} + +void glfwCreateStandardCursor_CMockStopIgnore(void) +{ + if(Mock.glfwCreateStandardCursor_IgnoreBool) + Mock.glfwCreateStandardCursor_CallInstance = CMock_Guts_MemNext(Mock.glfwCreateStandardCursor_CallInstance); + Mock.glfwCreateStandardCursor_IgnoreBool = (char)0; +} + +void glfwCreateStandardCursor_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int shape, GLFWcursor* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwCreateStandardCursor_CALL_INSTANCE)); + CMOCK_glfwCreateStandardCursor_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwCreateStandardCursor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwCreateStandardCursor_CallInstance = CMock_Guts_MemChain(Mock.glfwCreateStandardCursor_CallInstance, cmock_guts_index); + Mock.glfwCreateStandardCursor_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwCreateStandardCursor(cmock_call_instance, shape); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwCreateStandardCursor_AddCallback(CMOCK_glfwCreateStandardCursor_CALLBACK Callback) +{ + Mock.glfwCreateStandardCursor_IgnoreBool = (char)0; + Mock.glfwCreateStandardCursor_CallbackBool = (char)1; + Mock.glfwCreateStandardCursor_CallbackFunctionPointer = Callback; +} + +void glfwCreateStandardCursor_Stub(CMOCK_glfwCreateStandardCursor_CALLBACK Callback) +{ + Mock.glfwCreateStandardCursor_IgnoreBool = (char)0; + Mock.glfwCreateStandardCursor_CallbackBool = (char)0; + Mock.glfwCreateStandardCursor_CallbackFunctionPointer = Callback; +} + +void glfwCreateStandardCursor_CMockIgnoreArg_shape(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwCreateStandardCursor_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwCreateStandardCursor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwCreateStandardCursor_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_shape = 1; +} + +void glfwDestroyCursor(GLFWcursor* cursor) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwDestroyCursor_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwDestroyCursor); + cmock_call_instance = (CMOCK_glfwDestroyCursor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwDestroyCursor_CallInstance); + Mock.glfwDestroyCursor_CallInstance = CMock_Guts_MemNext(Mock.glfwDestroyCursor_CallInstance); + if (Mock.glfwDestroyCursor_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwDestroyCursor_CallbackBool && + Mock.glfwDestroyCursor_CallbackFunctionPointer != NULL) + { + Mock.glfwDestroyCursor_CallbackFunctionPointer(cursor, Mock.glfwDestroyCursor_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_cursor) + { + UNITY_SET_DETAILS(CMockString_glfwDestroyCursor,CMockString_cursor); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_cursor, cursor, cmock_line, CMockStringMismatch); + } + if (Mock.glfwDestroyCursor_CallbackFunctionPointer != NULL) + { + Mock.glfwDestroyCursor_CallbackFunctionPointer(cursor, Mock.glfwDestroyCursor_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwDestroyCursor(CMOCK_glfwDestroyCursor_CALL_INSTANCE* cmock_call_instance, GLFWcursor* cursor); +void CMockExpectParameters_glfwDestroyCursor(CMOCK_glfwDestroyCursor_CALL_INSTANCE* cmock_call_instance, GLFWcursor* cursor) +{ + cmock_call_instance->Expected_cursor = cursor; + cmock_call_instance->IgnoreArg_cursor = 0; +} + +void glfwDestroyCursor_CMockIgnore(void) +{ + Mock.glfwDestroyCursor_IgnoreBool = (char)1; +} + +void glfwDestroyCursor_CMockStopIgnore(void) +{ + Mock.glfwDestroyCursor_IgnoreBool = (char)0; +} + +void glfwDestroyCursor_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWcursor* cursor) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwDestroyCursor_CALL_INSTANCE)); + CMOCK_glfwDestroyCursor_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwDestroyCursor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwDestroyCursor_CallInstance = CMock_Guts_MemChain(Mock.glfwDestroyCursor_CallInstance, cmock_guts_index); + Mock.glfwDestroyCursor_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwDestroyCursor(cmock_call_instance, cursor); +} + +void glfwDestroyCursor_AddCallback(CMOCK_glfwDestroyCursor_CALLBACK Callback) +{ + Mock.glfwDestroyCursor_IgnoreBool = (char)0; + Mock.glfwDestroyCursor_CallbackBool = (char)1; + Mock.glfwDestroyCursor_CallbackFunctionPointer = Callback; +} + +void glfwDestroyCursor_Stub(CMOCK_glfwDestroyCursor_CALLBACK Callback) +{ + Mock.glfwDestroyCursor_IgnoreBool = (char)0; + Mock.glfwDestroyCursor_CallbackBool = (char)0; + Mock.glfwDestroyCursor_CallbackFunctionPointer = Callback; +} + +void glfwDestroyCursor_CMockIgnoreArg_cursor(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwDestroyCursor_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwDestroyCursor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwDestroyCursor_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_cursor = 1; +} + +void glfwSetCursor(GLFWwindow* window, GLFWcursor* cursor) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetCursor_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetCursor); + cmock_call_instance = (CMOCK_glfwSetCursor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetCursor_CallInstance); + Mock.glfwSetCursor_CallInstance = CMock_Guts_MemNext(Mock.glfwSetCursor_CallInstance); + if (Mock.glfwSetCursor_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwSetCursor_CallbackBool && + Mock.glfwSetCursor_CallbackFunctionPointer != NULL) + { + Mock.glfwSetCursor_CallbackFunctionPointer(window, cursor, Mock.glfwSetCursor_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetCursor,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_cursor) + { + UNITY_SET_DETAILS(CMockString_glfwSetCursor,CMockString_cursor); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_cursor, cursor, cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetCursor_CallbackFunctionPointer != NULL) + { + Mock.glfwSetCursor_CallbackFunctionPointer(window, cursor, Mock.glfwSetCursor_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwSetCursor(CMOCK_glfwSetCursor_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWcursor* cursor); +void CMockExpectParameters_glfwSetCursor(CMOCK_glfwSetCursor_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWcursor* cursor) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + cmock_call_instance->Expected_cursor = cursor; + cmock_call_instance->IgnoreArg_cursor = 0; +} + +void glfwSetCursor_CMockIgnore(void) +{ + Mock.glfwSetCursor_IgnoreBool = (char)1; +} + +void glfwSetCursor_CMockStopIgnore(void) +{ + Mock.glfwSetCursor_IgnoreBool = (char)0; +} + +void glfwSetCursor_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWcursor* cursor) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetCursor_CALL_INSTANCE)); + CMOCK_glfwSetCursor_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetCursor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetCursor_CallInstance = CMock_Guts_MemChain(Mock.glfwSetCursor_CallInstance, cmock_guts_index); + Mock.glfwSetCursor_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetCursor(cmock_call_instance, window, cursor); +} + +void glfwSetCursor_AddCallback(CMOCK_glfwSetCursor_CALLBACK Callback) +{ + Mock.glfwSetCursor_IgnoreBool = (char)0; + Mock.glfwSetCursor_CallbackBool = (char)1; + Mock.glfwSetCursor_CallbackFunctionPointer = Callback; +} + +void glfwSetCursor_Stub(CMOCK_glfwSetCursor_CALLBACK Callback) +{ + Mock.glfwSetCursor_IgnoreBool = (char)0; + Mock.glfwSetCursor_CallbackBool = (char)0; + Mock.glfwSetCursor_CallbackFunctionPointer = Callback; +} + +void glfwSetCursor_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetCursor_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetCursor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetCursor_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetCursor_CMockIgnoreArg_cursor(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetCursor_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetCursor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetCursor_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_cursor = 1; +} + +GLFWkeyfun glfwSetKeyCallback(GLFWwindow* window, GLFWkeyfun callback) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetKeyCallback_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetKeyCallback); + cmock_call_instance = (CMOCK_glfwSetKeyCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetKeyCallback_CallInstance); + Mock.glfwSetKeyCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetKeyCallback_CallInstance); + if (Mock.glfwSetKeyCallback_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwSetKeyCallback_FinalReturn; + memcpy((void*)(&Mock.glfwSetKeyCallback_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(GLFWkeyfun[sizeof(cmock_call_instance->ReturnVal) == sizeof(GLFWkeyfun) ? 1 : -1])); /* add GLFWkeyfun to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwSetKeyCallback_CallbackBool && + Mock.glfwSetKeyCallback_CallbackFunctionPointer != NULL) + { + GLFWkeyfun cmock_cb_ret = Mock.glfwSetKeyCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetKeyCallback_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetKeyCallback,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_callback) + { + UNITY_SET_DETAILS(CMockString_glfwSetKeyCallback,CMockString_callback); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), sizeof(GLFWkeyfun), cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetKeyCallback_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwSetKeyCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetKeyCallback_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwSetKeyCallback(CMOCK_glfwSetKeyCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWkeyfun callback); +void CMockExpectParameters_glfwSetKeyCallback(CMOCK_glfwSetKeyCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWkeyfun callback) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + memcpy((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), + sizeof(GLFWkeyfun[sizeof(callback) == sizeof(GLFWkeyfun) ? 1 : -1])); /* add GLFWkeyfun to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_callback = 0; +} + +void glfwSetKeyCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWkeyfun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetKeyCallback_CALL_INSTANCE)); + CMOCK_glfwSetKeyCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetKeyCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetKeyCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetKeyCallback_CallInstance, cmock_guts_index); + Mock.glfwSetKeyCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwSetKeyCallback_IgnoreBool = (char)1; +} + +void glfwSetKeyCallback_CMockStopIgnore(void) +{ + if(Mock.glfwSetKeyCallback_IgnoreBool) + Mock.glfwSetKeyCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetKeyCallback_CallInstance); + Mock.glfwSetKeyCallback_IgnoreBool = (char)0; +} + +void glfwSetKeyCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWkeyfun callback, GLFWkeyfun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetKeyCallback_CALL_INSTANCE)); + CMOCK_glfwSetKeyCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetKeyCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetKeyCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetKeyCallback_CallInstance, cmock_guts_index); + Mock.glfwSetKeyCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetKeyCallback(cmock_call_instance, window, callback); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(GLFWkeyfun[sizeof(cmock_to_return) == sizeof(GLFWkeyfun) ? 1 : -1])); /* add GLFWkeyfun to :treat_as_array if this causes an error */ +} + +void glfwSetKeyCallback_AddCallback(CMOCK_glfwSetKeyCallback_CALLBACK Callback) +{ + Mock.glfwSetKeyCallback_IgnoreBool = (char)0; + Mock.glfwSetKeyCallback_CallbackBool = (char)1; + Mock.glfwSetKeyCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetKeyCallback_Stub(CMOCK_glfwSetKeyCallback_CALLBACK Callback) +{ + Mock.glfwSetKeyCallback_IgnoreBool = (char)0; + Mock.glfwSetKeyCallback_CallbackBool = (char)0; + Mock.glfwSetKeyCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetKeyCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetKeyCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetKeyCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetKeyCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetKeyCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetKeyCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetKeyCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetKeyCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_callback = 1; +} + +GLFWcharfun glfwSetCharCallback(GLFWwindow* window, GLFWcharfun callback) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetCharCallback_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetCharCallback); + cmock_call_instance = (CMOCK_glfwSetCharCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetCharCallback_CallInstance); + Mock.glfwSetCharCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetCharCallback_CallInstance); + if (Mock.glfwSetCharCallback_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwSetCharCallback_FinalReturn; + memcpy((void*)(&Mock.glfwSetCharCallback_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(GLFWcharfun[sizeof(cmock_call_instance->ReturnVal) == sizeof(GLFWcharfun) ? 1 : -1])); /* add GLFWcharfun to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwSetCharCallback_CallbackBool && + Mock.glfwSetCharCallback_CallbackFunctionPointer != NULL) + { + GLFWcharfun cmock_cb_ret = Mock.glfwSetCharCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetCharCallback_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetCharCallback,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_callback) + { + UNITY_SET_DETAILS(CMockString_glfwSetCharCallback,CMockString_callback); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), sizeof(GLFWcharfun), cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetCharCallback_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwSetCharCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetCharCallback_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwSetCharCallback(CMOCK_glfwSetCharCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWcharfun callback); +void CMockExpectParameters_glfwSetCharCallback(CMOCK_glfwSetCharCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWcharfun callback) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + memcpy((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), + sizeof(GLFWcharfun[sizeof(callback) == sizeof(GLFWcharfun) ? 1 : -1])); /* add GLFWcharfun to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_callback = 0; +} + +void glfwSetCharCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWcharfun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetCharCallback_CALL_INSTANCE)); + CMOCK_glfwSetCharCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetCharCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetCharCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetCharCallback_CallInstance, cmock_guts_index); + Mock.glfwSetCharCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwSetCharCallback_IgnoreBool = (char)1; +} + +void glfwSetCharCallback_CMockStopIgnore(void) +{ + if(Mock.glfwSetCharCallback_IgnoreBool) + Mock.glfwSetCharCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetCharCallback_CallInstance); + Mock.glfwSetCharCallback_IgnoreBool = (char)0; +} + +void glfwSetCharCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWcharfun callback, GLFWcharfun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetCharCallback_CALL_INSTANCE)); + CMOCK_glfwSetCharCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetCharCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetCharCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetCharCallback_CallInstance, cmock_guts_index); + Mock.glfwSetCharCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetCharCallback(cmock_call_instance, window, callback); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(GLFWcharfun[sizeof(cmock_to_return) == sizeof(GLFWcharfun) ? 1 : -1])); /* add GLFWcharfun to :treat_as_array if this causes an error */ +} + +void glfwSetCharCallback_AddCallback(CMOCK_glfwSetCharCallback_CALLBACK Callback) +{ + Mock.glfwSetCharCallback_IgnoreBool = (char)0; + Mock.glfwSetCharCallback_CallbackBool = (char)1; + Mock.glfwSetCharCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetCharCallback_Stub(CMOCK_glfwSetCharCallback_CALLBACK Callback) +{ + Mock.glfwSetCharCallback_IgnoreBool = (char)0; + Mock.glfwSetCharCallback_CallbackBool = (char)0; + Mock.glfwSetCharCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetCharCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetCharCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetCharCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetCharCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetCharCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetCharCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetCharCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetCharCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_callback = 1; +} + +GLFWcharmodsfun glfwSetCharModsCallback(GLFWwindow* window, GLFWcharmodsfun callback) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetCharModsCallback_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetCharModsCallback); + cmock_call_instance = (CMOCK_glfwSetCharModsCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetCharModsCallback_CallInstance); + Mock.glfwSetCharModsCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetCharModsCallback_CallInstance); + if (Mock.glfwSetCharModsCallback_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwSetCharModsCallback_FinalReturn; + memcpy((void*)(&Mock.glfwSetCharModsCallback_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(GLFWcharmodsfun[sizeof(cmock_call_instance->ReturnVal) == sizeof(GLFWcharmodsfun) ? 1 : -1])); /* add GLFWcharmodsfun to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwSetCharModsCallback_CallbackBool && + Mock.glfwSetCharModsCallback_CallbackFunctionPointer != NULL) + { + GLFWcharmodsfun cmock_cb_ret = Mock.glfwSetCharModsCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetCharModsCallback_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetCharModsCallback,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_callback) + { + UNITY_SET_DETAILS(CMockString_glfwSetCharModsCallback,CMockString_callback); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), sizeof(GLFWcharmodsfun), cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetCharModsCallback_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwSetCharModsCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetCharModsCallback_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwSetCharModsCallback(CMOCK_glfwSetCharModsCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWcharmodsfun callback); +void CMockExpectParameters_glfwSetCharModsCallback(CMOCK_glfwSetCharModsCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWcharmodsfun callback) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + memcpy((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), + sizeof(GLFWcharmodsfun[sizeof(callback) == sizeof(GLFWcharmodsfun) ? 1 : -1])); /* add GLFWcharmodsfun to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_callback = 0; +} + +void glfwSetCharModsCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWcharmodsfun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetCharModsCallback_CALL_INSTANCE)); + CMOCK_glfwSetCharModsCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetCharModsCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetCharModsCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetCharModsCallback_CallInstance, cmock_guts_index); + Mock.glfwSetCharModsCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwSetCharModsCallback_IgnoreBool = (char)1; +} + +void glfwSetCharModsCallback_CMockStopIgnore(void) +{ + if(Mock.glfwSetCharModsCallback_IgnoreBool) + Mock.glfwSetCharModsCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetCharModsCallback_CallInstance); + Mock.glfwSetCharModsCallback_IgnoreBool = (char)0; +} + +void glfwSetCharModsCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWcharmodsfun callback, GLFWcharmodsfun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetCharModsCallback_CALL_INSTANCE)); + CMOCK_glfwSetCharModsCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetCharModsCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetCharModsCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetCharModsCallback_CallInstance, cmock_guts_index); + Mock.glfwSetCharModsCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetCharModsCallback(cmock_call_instance, window, callback); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(GLFWcharmodsfun[sizeof(cmock_to_return) == sizeof(GLFWcharmodsfun) ? 1 : -1])); /* add GLFWcharmodsfun to :treat_as_array if this causes an error */ +} + +void glfwSetCharModsCallback_AddCallback(CMOCK_glfwSetCharModsCallback_CALLBACK Callback) +{ + Mock.glfwSetCharModsCallback_IgnoreBool = (char)0; + Mock.glfwSetCharModsCallback_CallbackBool = (char)1; + Mock.glfwSetCharModsCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetCharModsCallback_Stub(CMOCK_glfwSetCharModsCallback_CALLBACK Callback) +{ + Mock.glfwSetCharModsCallback_IgnoreBool = (char)0; + Mock.glfwSetCharModsCallback_CallbackBool = (char)0; + Mock.glfwSetCharModsCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetCharModsCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetCharModsCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetCharModsCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetCharModsCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetCharModsCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetCharModsCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetCharModsCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetCharModsCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_callback = 1; +} + +GLFWmousebuttonfun glfwSetMouseButtonCallback(GLFWwindow* window, GLFWmousebuttonfun callback) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetMouseButtonCallback_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetMouseButtonCallback); + cmock_call_instance = (CMOCK_glfwSetMouseButtonCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetMouseButtonCallback_CallInstance); + Mock.glfwSetMouseButtonCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetMouseButtonCallback_CallInstance); + if (Mock.glfwSetMouseButtonCallback_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwSetMouseButtonCallback_FinalReturn; + memcpy((void*)(&Mock.glfwSetMouseButtonCallback_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(GLFWmousebuttonfun[sizeof(cmock_call_instance->ReturnVal) == sizeof(GLFWmousebuttonfun) ? 1 : -1])); /* add GLFWmousebuttonfun to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwSetMouseButtonCallback_CallbackBool && + Mock.glfwSetMouseButtonCallback_CallbackFunctionPointer != NULL) + { + GLFWmousebuttonfun cmock_cb_ret = Mock.glfwSetMouseButtonCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetMouseButtonCallback_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetMouseButtonCallback,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_callback) + { + UNITY_SET_DETAILS(CMockString_glfwSetMouseButtonCallback,CMockString_callback); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), sizeof(GLFWmousebuttonfun), cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetMouseButtonCallback_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwSetMouseButtonCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetMouseButtonCallback_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwSetMouseButtonCallback(CMOCK_glfwSetMouseButtonCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWmousebuttonfun callback); +void CMockExpectParameters_glfwSetMouseButtonCallback(CMOCK_glfwSetMouseButtonCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWmousebuttonfun callback) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + memcpy((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), + sizeof(GLFWmousebuttonfun[sizeof(callback) == sizeof(GLFWmousebuttonfun) ? 1 : -1])); /* add GLFWmousebuttonfun to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_callback = 0; +} + +void glfwSetMouseButtonCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWmousebuttonfun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetMouseButtonCallback_CALL_INSTANCE)); + CMOCK_glfwSetMouseButtonCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetMouseButtonCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetMouseButtonCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetMouseButtonCallback_CallInstance, cmock_guts_index); + Mock.glfwSetMouseButtonCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwSetMouseButtonCallback_IgnoreBool = (char)1; +} + +void glfwSetMouseButtonCallback_CMockStopIgnore(void) +{ + if(Mock.glfwSetMouseButtonCallback_IgnoreBool) + Mock.glfwSetMouseButtonCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetMouseButtonCallback_CallInstance); + Mock.glfwSetMouseButtonCallback_IgnoreBool = (char)0; +} + +void glfwSetMouseButtonCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWmousebuttonfun callback, GLFWmousebuttonfun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetMouseButtonCallback_CALL_INSTANCE)); + CMOCK_glfwSetMouseButtonCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetMouseButtonCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetMouseButtonCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetMouseButtonCallback_CallInstance, cmock_guts_index); + Mock.glfwSetMouseButtonCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetMouseButtonCallback(cmock_call_instance, window, callback); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(GLFWmousebuttonfun[sizeof(cmock_to_return) == sizeof(GLFWmousebuttonfun) ? 1 : -1])); /* add GLFWmousebuttonfun to :treat_as_array if this causes an error */ +} + +void glfwSetMouseButtonCallback_AddCallback(CMOCK_glfwSetMouseButtonCallback_CALLBACK Callback) +{ + Mock.glfwSetMouseButtonCallback_IgnoreBool = (char)0; + Mock.glfwSetMouseButtonCallback_CallbackBool = (char)1; + Mock.glfwSetMouseButtonCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetMouseButtonCallback_Stub(CMOCK_glfwSetMouseButtonCallback_CALLBACK Callback) +{ + Mock.glfwSetMouseButtonCallback_IgnoreBool = (char)0; + Mock.glfwSetMouseButtonCallback_CallbackBool = (char)0; + Mock.glfwSetMouseButtonCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetMouseButtonCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetMouseButtonCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetMouseButtonCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetMouseButtonCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetMouseButtonCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetMouseButtonCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetMouseButtonCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetMouseButtonCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_callback = 1; +} + +GLFWcursorposfun glfwSetCursorPosCallback(GLFWwindow* window, GLFWcursorposfun callback) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetCursorPosCallback_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetCursorPosCallback); + cmock_call_instance = (CMOCK_glfwSetCursorPosCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetCursorPosCallback_CallInstance); + Mock.glfwSetCursorPosCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetCursorPosCallback_CallInstance); + if (Mock.glfwSetCursorPosCallback_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwSetCursorPosCallback_FinalReturn; + memcpy((void*)(&Mock.glfwSetCursorPosCallback_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(GLFWcursorposfun[sizeof(cmock_call_instance->ReturnVal) == sizeof(GLFWcursorposfun) ? 1 : -1])); /* add GLFWcursorposfun to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwSetCursorPosCallback_CallbackBool && + Mock.glfwSetCursorPosCallback_CallbackFunctionPointer != NULL) + { + GLFWcursorposfun cmock_cb_ret = Mock.glfwSetCursorPosCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetCursorPosCallback_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetCursorPosCallback,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_callback) + { + UNITY_SET_DETAILS(CMockString_glfwSetCursorPosCallback,CMockString_callback); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), sizeof(GLFWcursorposfun), cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetCursorPosCallback_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwSetCursorPosCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetCursorPosCallback_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwSetCursorPosCallback(CMOCK_glfwSetCursorPosCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWcursorposfun callback); +void CMockExpectParameters_glfwSetCursorPosCallback(CMOCK_glfwSetCursorPosCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWcursorposfun callback) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + memcpy((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), + sizeof(GLFWcursorposfun[sizeof(callback) == sizeof(GLFWcursorposfun) ? 1 : -1])); /* add GLFWcursorposfun to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_callback = 0; +} + +void glfwSetCursorPosCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWcursorposfun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetCursorPosCallback_CALL_INSTANCE)); + CMOCK_glfwSetCursorPosCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetCursorPosCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetCursorPosCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetCursorPosCallback_CallInstance, cmock_guts_index); + Mock.glfwSetCursorPosCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwSetCursorPosCallback_IgnoreBool = (char)1; +} + +void glfwSetCursorPosCallback_CMockStopIgnore(void) +{ + if(Mock.glfwSetCursorPosCallback_IgnoreBool) + Mock.glfwSetCursorPosCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetCursorPosCallback_CallInstance); + Mock.glfwSetCursorPosCallback_IgnoreBool = (char)0; +} + +void glfwSetCursorPosCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWcursorposfun callback, GLFWcursorposfun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetCursorPosCallback_CALL_INSTANCE)); + CMOCK_glfwSetCursorPosCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetCursorPosCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetCursorPosCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetCursorPosCallback_CallInstance, cmock_guts_index); + Mock.glfwSetCursorPosCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetCursorPosCallback(cmock_call_instance, window, callback); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(GLFWcursorposfun[sizeof(cmock_to_return) == sizeof(GLFWcursorposfun) ? 1 : -1])); /* add GLFWcursorposfun to :treat_as_array if this causes an error */ +} + +void glfwSetCursorPosCallback_AddCallback(CMOCK_glfwSetCursorPosCallback_CALLBACK Callback) +{ + Mock.glfwSetCursorPosCallback_IgnoreBool = (char)0; + Mock.glfwSetCursorPosCallback_CallbackBool = (char)1; + Mock.glfwSetCursorPosCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetCursorPosCallback_Stub(CMOCK_glfwSetCursorPosCallback_CALLBACK Callback) +{ + Mock.glfwSetCursorPosCallback_IgnoreBool = (char)0; + Mock.glfwSetCursorPosCallback_CallbackBool = (char)0; + Mock.glfwSetCursorPosCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetCursorPosCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetCursorPosCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetCursorPosCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetCursorPosCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetCursorPosCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetCursorPosCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetCursorPosCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetCursorPosCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_callback = 1; +} + +GLFWcursorenterfun glfwSetCursorEnterCallback(GLFWwindow* window, GLFWcursorenterfun callback) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetCursorEnterCallback_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetCursorEnterCallback); + cmock_call_instance = (CMOCK_glfwSetCursorEnterCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetCursorEnterCallback_CallInstance); + Mock.glfwSetCursorEnterCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetCursorEnterCallback_CallInstance); + if (Mock.glfwSetCursorEnterCallback_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwSetCursorEnterCallback_FinalReturn; + memcpy((void*)(&Mock.glfwSetCursorEnterCallback_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(GLFWcursorenterfun[sizeof(cmock_call_instance->ReturnVal) == sizeof(GLFWcursorenterfun) ? 1 : -1])); /* add GLFWcursorenterfun to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwSetCursorEnterCallback_CallbackBool && + Mock.glfwSetCursorEnterCallback_CallbackFunctionPointer != NULL) + { + GLFWcursorenterfun cmock_cb_ret = Mock.glfwSetCursorEnterCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetCursorEnterCallback_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetCursorEnterCallback,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_callback) + { + UNITY_SET_DETAILS(CMockString_glfwSetCursorEnterCallback,CMockString_callback); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), sizeof(GLFWcursorenterfun), cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetCursorEnterCallback_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwSetCursorEnterCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetCursorEnterCallback_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwSetCursorEnterCallback(CMOCK_glfwSetCursorEnterCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWcursorenterfun callback); +void CMockExpectParameters_glfwSetCursorEnterCallback(CMOCK_glfwSetCursorEnterCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWcursorenterfun callback) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + memcpy((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), + sizeof(GLFWcursorenterfun[sizeof(callback) == sizeof(GLFWcursorenterfun) ? 1 : -1])); /* add GLFWcursorenterfun to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_callback = 0; +} + +void glfwSetCursorEnterCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWcursorenterfun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetCursorEnterCallback_CALL_INSTANCE)); + CMOCK_glfwSetCursorEnterCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetCursorEnterCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetCursorEnterCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetCursorEnterCallback_CallInstance, cmock_guts_index); + Mock.glfwSetCursorEnterCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwSetCursorEnterCallback_IgnoreBool = (char)1; +} + +void glfwSetCursorEnterCallback_CMockStopIgnore(void) +{ + if(Mock.glfwSetCursorEnterCallback_IgnoreBool) + Mock.glfwSetCursorEnterCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetCursorEnterCallback_CallInstance); + Mock.glfwSetCursorEnterCallback_IgnoreBool = (char)0; +} + +void glfwSetCursorEnterCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWcursorenterfun callback, GLFWcursorenterfun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetCursorEnterCallback_CALL_INSTANCE)); + CMOCK_glfwSetCursorEnterCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetCursorEnterCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetCursorEnterCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetCursorEnterCallback_CallInstance, cmock_guts_index); + Mock.glfwSetCursorEnterCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetCursorEnterCallback(cmock_call_instance, window, callback); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(GLFWcursorenterfun[sizeof(cmock_to_return) == sizeof(GLFWcursorenterfun) ? 1 : -1])); /* add GLFWcursorenterfun to :treat_as_array if this causes an error */ +} + +void glfwSetCursorEnterCallback_AddCallback(CMOCK_glfwSetCursorEnterCallback_CALLBACK Callback) +{ + Mock.glfwSetCursorEnterCallback_IgnoreBool = (char)0; + Mock.glfwSetCursorEnterCallback_CallbackBool = (char)1; + Mock.glfwSetCursorEnterCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetCursorEnterCallback_Stub(CMOCK_glfwSetCursorEnterCallback_CALLBACK Callback) +{ + Mock.glfwSetCursorEnterCallback_IgnoreBool = (char)0; + Mock.glfwSetCursorEnterCallback_CallbackBool = (char)0; + Mock.glfwSetCursorEnterCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetCursorEnterCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetCursorEnterCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetCursorEnterCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetCursorEnterCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetCursorEnterCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetCursorEnterCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetCursorEnterCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetCursorEnterCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_callback = 1; +} + +GLFWscrollfun glfwSetScrollCallback(GLFWwindow* window, GLFWscrollfun callback) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetScrollCallback_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetScrollCallback); + cmock_call_instance = (CMOCK_glfwSetScrollCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetScrollCallback_CallInstance); + Mock.glfwSetScrollCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetScrollCallback_CallInstance); + if (Mock.glfwSetScrollCallback_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwSetScrollCallback_FinalReturn; + memcpy((void*)(&Mock.glfwSetScrollCallback_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(GLFWscrollfun[sizeof(cmock_call_instance->ReturnVal) == sizeof(GLFWscrollfun) ? 1 : -1])); /* add GLFWscrollfun to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwSetScrollCallback_CallbackBool && + Mock.glfwSetScrollCallback_CallbackFunctionPointer != NULL) + { + GLFWscrollfun cmock_cb_ret = Mock.glfwSetScrollCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetScrollCallback_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetScrollCallback,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_callback) + { + UNITY_SET_DETAILS(CMockString_glfwSetScrollCallback,CMockString_callback); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), sizeof(GLFWscrollfun), cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetScrollCallback_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwSetScrollCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetScrollCallback_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwSetScrollCallback(CMOCK_glfwSetScrollCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWscrollfun callback); +void CMockExpectParameters_glfwSetScrollCallback(CMOCK_glfwSetScrollCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWscrollfun callback) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + memcpy((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), + sizeof(GLFWscrollfun[sizeof(callback) == sizeof(GLFWscrollfun) ? 1 : -1])); /* add GLFWscrollfun to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_callback = 0; +} + +void glfwSetScrollCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWscrollfun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetScrollCallback_CALL_INSTANCE)); + CMOCK_glfwSetScrollCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetScrollCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetScrollCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetScrollCallback_CallInstance, cmock_guts_index); + Mock.glfwSetScrollCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwSetScrollCallback_IgnoreBool = (char)1; +} + +void glfwSetScrollCallback_CMockStopIgnore(void) +{ + if(Mock.glfwSetScrollCallback_IgnoreBool) + Mock.glfwSetScrollCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetScrollCallback_CallInstance); + Mock.glfwSetScrollCallback_IgnoreBool = (char)0; +} + +void glfwSetScrollCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWscrollfun callback, GLFWscrollfun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetScrollCallback_CALL_INSTANCE)); + CMOCK_glfwSetScrollCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetScrollCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetScrollCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetScrollCallback_CallInstance, cmock_guts_index); + Mock.glfwSetScrollCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetScrollCallback(cmock_call_instance, window, callback); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(GLFWscrollfun[sizeof(cmock_to_return) == sizeof(GLFWscrollfun) ? 1 : -1])); /* add GLFWscrollfun to :treat_as_array if this causes an error */ +} + +void glfwSetScrollCallback_AddCallback(CMOCK_glfwSetScrollCallback_CALLBACK Callback) +{ + Mock.glfwSetScrollCallback_IgnoreBool = (char)0; + Mock.glfwSetScrollCallback_CallbackBool = (char)1; + Mock.glfwSetScrollCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetScrollCallback_Stub(CMOCK_glfwSetScrollCallback_CALLBACK Callback) +{ + Mock.glfwSetScrollCallback_IgnoreBool = (char)0; + Mock.glfwSetScrollCallback_CallbackBool = (char)0; + Mock.glfwSetScrollCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetScrollCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetScrollCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetScrollCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetScrollCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetScrollCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetScrollCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetScrollCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetScrollCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_callback = 1; +} + +GLFWdropfun glfwSetDropCallback(GLFWwindow* window, GLFWdropfun callback) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetDropCallback_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetDropCallback); + cmock_call_instance = (CMOCK_glfwSetDropCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetDropCallback_CallInstance); + Mock.glfwSetDropCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetDropCallback_CallInstance); + if (Mock.glfwSetDropCallback_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwSetDropCallback_FinalReturn; + memcpy((void*)(&Mock.glfwSetDropCallback_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(GLFWdropfun[sizeof(cmock_call_instance->ReturnVal) == sizeof(GLFWdropfun) ? 1 : -1])); /* add GLFWdropfun to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwSetDropCallback_CallbackBool && + Mock.glfwSetDropCallback_CallbackFunctionPointer != NULL) + { + GLFWdropfun cmock_cb_ret = Mock.glfwSetDropCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetDropCallback_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetDropCallback,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_callback) + { + UNITY_SET_DETAILS(CMockString_glfwSetDropCallback,CMockString_callback); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), sizeof(GLFWdropfun), cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetDropCallback_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwSetDropCallback_CallbackFunctionPointer(window, callback, Mock.glfwSetDropCallback_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwSetDropCallback(CMOCK_glfwSetDropCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWdropfun callback); +void CMockExpectParameters_glfwSetDropCallback(CMOCK_glfwSetDropCallback_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, GLFWdropfun callback) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + memcpy((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), + sizeof(GLFWdropfun[sizeof(callback) == sizeof(GLFWdropfun) ? 1 : -1])); /* add GLFWdropfun to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_callback = 0; +} + +void glfwSetDropCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWdropfun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetDropCallback_CALL_INSTANCE)); + CMOCK_glfwSetDropCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetDropCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetDropCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetDropCallback_CallInstance, cmock_guts_index); + Mock.glfwSetDropCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwSetDropCallback_IgnoreBool = (char)1; +} + +void glfwSetDropCallback_CMockStopIgnore(void) +{ + if(Mock.glfwSetDropCallback_IgnoreBool) + Mock.glfwSetDropCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetDropCallback_CallInstance); + Mock.glfwSetDropCallback_IgnoreBool = (char)0; +} + +void glfwSetDropCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWdropfun callback, GLFWdropfun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetDropCallback_CALL_INSTANCE)); + CMOCK_glfwSetDropCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetDropCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetDropCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetDropCallback_CallInstance, cmock_guts_index); + Mock.glfwSetDropCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetDropCallback(cmock_call_instance, window, callback); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(GLFWdropfun[sizeof(cmock_to_return) == sizeof(GLFWdropfun) ? 1 : -1])); /* add GLFWdropfun to :treat_as_array if this causes an error */ +} + +void glfwSetDropCallback_AddCallback(CMOCK_glfwSetDropCallback_CALLBACK Callback) +{ + Mock.glfwSetDropCallback_IgnoreBool = (char)0; + Mock.glfwSetDropCallback_CallbackBool = (char)1; + Mock.glfwSetDropCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetDropCallback_Stub(CMOCK_glfwSetDropCallback_CALLBACK Callback) +{ + Mock.glfwSetDropCallback_IgnoreBool = (char)0; + Mock.glfwSetDropCallback_CallbackBool = (char)0; + Mock.glfwSetDropCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetDropCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetDropCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetDropCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetDropCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetDropCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetDropCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetDropCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetDropCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_callback = 1; +} + +int glfwJoystickPresent(int jid) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwJoystickPresent_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwJoystickPresent); + cmock_call_instance = (CMOCK_glfwJoystickPresent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwJoystickPresent_CallInstance); + Mock.glfwJoystickPresent_CallInstance = CMock_Guts_MemNext(Mock.glfwJoystickPresent_CallInstance); + if (Mock.glfwJoystickPresent_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwJoystickPresent_FinalReturn; + Mock.glfwJoystickPresent_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwJoystickPresent_CallbackBool && + Mock.glfwJoystickPresent_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.glfwJoystickPresent_CallbackFunctionPointer(jid, Mock.glfwJoystickPresent_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_jid) + { + UNITY_SET_DETAILS(CMockString_glfwJoystickPresent,CMockString_jid); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_jid, jid, cmock_line, CMockStringMismatch); + } + if (Mock.glfwJoystickPresent_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwJoystickPresent_CallbackFunctionPointer(jid, Mock.glfwJoystickPresent_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwJoystickPresent(CMOCK_glfwJoystickPresent_CALL_INSTANCE* cmock_call_instance, int jid); +void CMockExpectParameters_glfwJoystickPresent(CMOCK_glfwJoystickPresent_CALL_INSTANCE* cmock_call_instance, int jid) +{ + cmock_call_instance->Expected_jid = jid; + cmock_call_instance->IgnoreArg_jid = 0; +} + +void glfwJoystickPresent_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwJoystickPresent_CALL_INSTANCE)); + CMOCK_glfwJoystickPresent_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwJoystickPresent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwJoystickPresent_CallInstance = CMock_Guts_MemChain(Mock.glfwJoystickPresent_CallInstance, cmock_guts_index); + Mock.glfwJoystickPresent_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwJoystickPresent_IgnoreBool = (char)1; +} + +void glfwJoystickPresent_CMockStopIgnore(void) +{ + if(Mock.glfwJoystickPresent_IgnoreBool) + Mock.glfwJoystickPresent_CallInstance = CMock_Guts_MemNext(Mock.glfwJoystickPresent_CallInstance); + Mock.glfwJoystickPresent_IgnoreBool = (char)0; +} + +void glfwJoystickPresent_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int jid, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwJoystickPresent_CALL_INSTANCE)); + CMOCK_glfwJoystickPresent_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwJoystickPresent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwJoystickPresent_CallInstance = CMock_Guts_MemChain(Mock.glfwJoystickPresent_CallInstance, cmock_guts_index); + Mock.glfwJoystickPresent_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwJoystickPresent(cmock_call_instance, jid); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwJoystickPresent_AddCallback(CMOCK_glfwJoystickPresent_CALLBACK Callback) +{ + Mock.glfwJoystickPresent_IgnoreBool = (char)0; + Mock.glfwJoystickPresent_CallbackBool = (char)1; + Mock.glfwJoystickPresent_CallbackFunctionPointer = Callback; +} + +void glfwJoystickPresent_Stub(CMOCK_glfwJoystickPresent_CALLBACK Callback) +{ + Mock.glfwJoystickPresent_IgnoreBool = (char)0; + Mock.glfwJoystickPresent_CallbackBool = (char)0; + Mock.glfwJoystickPresent_CallbackFunctionPointer = Callback; +} + +void glfwJoystickPresent_CMockIgnoreArg_jid(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwJoystickPresent_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwJoystickPresent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwJoystickPresent_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_jid = 1; +} + +const float* glfwGetJoystickAxes(int jid, int* count) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetJoystickAxes_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetJoystickAxes); + cmock_call_instance = (CMOCK_glfwGetJoystickAxes_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetJoystickAxes_CallInstance); + Mock.glfwGetJoystickAxes_CallInstance = CMock_Guts_MemNext(Mock.glfwGetJoystickAxes_CallInstance); + if (Mock.glfwGetJoystickAxes_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetJoystickAxes_FinalReturn; + Mock.glfwGetJoystickAxes_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetJoystickAxes_CallbackBool && + Mock.glfwGetJoystickAxes_CallbackFunctionPointer != NULL) + { + const float* cmock_cb_ret = Mock.glfwGetJoystickAxes_CallbackFunctionPointer(jid, count, Mock.glfwGetJoystickAxes_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_jid) + { + UNITY_SET_DETAILS(CMockString_glfwGetJoystickAxes,CMockString_jid); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_jid, jid, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_count) + { + UNITY_SET_DETAILS(CMockString_glfwGetJoystickAxes,CMockString_count); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_count, count, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetJoystickAxes_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetJoystickAxes_CallbackFunctionPointer(jid, count, Mock.glfwGetJoystickAxes_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwGetJoystickAxes(CMOCK_glfwGetJoystickAxes_CALL_INSTANCE* cmock_call_instance, int jid, int* count); +void CMockExpectParameters_glfwGetJoystickAxes(CMOCK_glfwGetJoystickAxes_CALL_INSTANCE* cmock_call_instance, int jid, int* count) +{ + cmock_call_instance->Expected_jid = jid; + cmock_call_instance->IgnoreArg_jid = 0; + cmock_call_instance->Expected_count = count; + cmock_call_instance->IgnoreArg_count = 0; +} + +void glfwGetJoystickAxes_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, const float* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetJoystickAxes_CALL_INSTANCE)); + CMOCK_glfwGetJoystickAxes_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetJoystickAxes_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetJoystickAxes_CallInstance = CMock_Guts_MemChain(Mock.glfwGetJoystickAxes_CallInstance, cmock_guts_index); + Mock.glfwGetJoystickAxes_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetJoystickAxes_IgnoreBool = (char)1; +} + +void glfwGetJoystickAxes_CMockStopIgnore(void) +{ + if(Mock.glfwGetJoystickAxes_IgnoreBool) + Mock.glfwGetJoystickAxes_CallInstance = CMock_Guts_MemNext(Mock.glfwGetJoystickAxes_CallInstance); + Mock.glfwGetJoystickAxes_IgnoreBool = (char)0; +} + +void glfwGetJoystickAxes_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int jid, int* count, const float* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetJoystickAxes_CALL_INSTANCE)); + CMOCK_glfwGetJoystickAxes_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetJoystickAxes_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetJoystickAxes_CallInstance = CMock_Guts_MemChain(Mock.glfwGetJoystickAxes_CallInstance, cmock_guts_index); + Mock.glfwGetJoystickAxes_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetJoystickAxes(cmock_call_instance, jid, count); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwGetJoystickAxes_AddCallback(CMOCK_glfwGetJoystickAxes_CALLBACK Callback) +{ + Mock.glfwGetJoystickAxes_IgnoreBool = (char)0; + Mock.glfwGetJoystickAxes_CallbackBool = (char)1; + Mock.glfwGetJoystickAxes_CallbackFunctionPointer = Callback; +} + +void glfwGetJoystickAxes_Stub(CMOCK_glfwGetJoystickAxes_CALLBACK Callback) +{ + Mock.glfwGetJoystickAxes_IgnoreBool = (char)0; + Mock.glfwGetJoystickAxes_CallbackBool = (char)0; + Mock.glfwGetJoystickAxes_CallbackFunctionPointer = Callback; +} + +void glfwGetJoystickAxes_CMockIgnoreArg_jid(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetJoystickAxes_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetJoystickAxes_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetJoystickAxes_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_jid = 1; +} + +void glfwGetJoystickAxes_CMockIgnoreArg_count(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetJoystickAxes_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetJoystickAxes_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetJoystickAxes_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_count = 1; +} + +const unsigned char* glfwGetJoystickButtons(int jid, int* count) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetJoystickButtons_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetJoystickButtons); + cmock_call_instance = (CMOCK_glfwGetJoystickButtons_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetJoystickButtons_CallInstance); + Mock.glfwGetJoystickButtons_CallInstance = CMock_Guts_MemNext(Mock.glfwGetJoystickButtons_CallInstance); + if (Mock.glfwGetJoystickButtons_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetJoystickButtons_FinalReturn; + memcpy((void*)(&Mock.glfwGetJoystickButtons_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(const unsigned char*[sizeof(cmock_call_instance->ReturnVal) == sizeof(const unsigned char*) ? 1 : -1])); /* add const unsigned char* to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetJoystickButtons_CallbackBool && + Mock.glfwGetJoystickButtons_CallbackFunctionPointer != NULL) + { + const unsigned char* cmock_cb_ret = Mock.glfwGetJoystickButtons_CallbackFunctionPointer(jid, count, Mock.glfwGetJoystickButtons_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_jid) + { + UNITY_SET_DETAILS(CMockString_glfwGetJoystickButtons,CMockString_jid); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_jid, jid, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_count) + { + UNITY_SET_DETAILS(CMockString_glfwGetJoystickButtons,CMockString_count); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_count, count, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetJoystickButtons_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetJoystickButtons_CallbackFunctionPointer(jid, count, Mock.glfwGetJoystickButtons_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwGetJoystickButtons(CMOCK_glfwGetJoystickButtons_CALL_INSTANCE* cmock_call_instance, int jid, int* count); +void CMockExpectParameters_glfwGetJoystickButtons(CMOCK_glfwGetJoystickButtons_CALL_INSTANCE* cmock_call_instance, int jid, int* count) +{ + cmock_call_instance->Expected_jid = jid; + cmock_call_instance->IgnoreArg_jid = 0; + cmock_call_instance->Expected_count = count; + cmock_call_instance->IgnoreArg_count = 0; +} + +void glfwGetJoystickButtons_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, const unsigned char* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetJoystickButtons_CALL_INSTANCE)); + CMOCK_glfwGetJoystickButtons_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetJoystickButtons_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetJoystickButtons_CallInstance = CMock_Guts_MemChain(Mock.glfwGetJoystickButtons_CallInstance, cmock_guts_index); + Mock.glfwGetJoystickButtons_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetJoystickButtons_IgnoreBool = (char)1; +} + +void glfwGetJoystickButtons_CMockStopIgnore(void) +{ + if(Mock.glfwGetJoystickButtons_IgnoreBool) + Mock.glfwGetJoystickButtons_CallInstance = CMock_Guts_MemNext(Mock.glfwGetJoystickButtons_CallInstance); + Mock.glfwGetJoystickButtons_IgnoreBool = (char)0; +} + +void glfwGetJoystickButtons_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int jid, int* count, const unsigned char* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetJoystickButtons_CALL_INSTANCE)); + CMOCK_glfwGetJoystickButtons_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetJoystickButtons_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetJoystickButtons_CallInstance = CMock_Guts_MemChain(Mock.glfwGetJoystickButtons_CallInstance, cmock_guts_index); + Mock.glfwGetJoystickButtons_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetJoystickButtons(cmock_call_instance, jid, count); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(const unsigned char*[sizeof(cmock_to_return) == sizeof(const unsigned char*) ? 1 : -1])); /* add const unsigned char* to :treat_as_array if this causes an error */ +} + +void glfwGetJoystickButtons_AddCallback(CMOCK_glfwGetJoystickButtons_CALLBACK Callback) +{ + Mock.glfwGetJoystickButtons_IgnoreBool = (char)0; + Mock.glfwGetJoystickButtons_CallbackBool = (char)1; + Mock.glfwGetJoystickButtons_CallbackFunctionPointer = Callback; +} + +void glfwGetJoystickButtons_Stub(CMOCK_glfwGetJoystickButtons_CALLBACK Callback) +{ + Mock.glfwGetJoystickButtons_IgnoreBool = (char)0; + Mock.glfwGetJoystickButtons_CallbackBool = (char)0; + Mock.glfwGetJoystickButtons_CallbackFunctionPointer = Callback; +} + +void glfwGetJoystickButtons_CMockIgnoreArg_jid(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetJoystickButtons_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetJoystickButtons_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetJoystickButtons_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_jid = 1; +} + +void glfwGetJoystickButtons_CMockIgnoreArg_count(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetJoystickButtons_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetJoystickButtons_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetJoystickButtons_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_count = 1; +} + +const unsigned char* glfwGetJoystickHats(int jid, int* count) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetJoystickHats_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetJoystickHats); + cmock_call_instance = (CMOCK_glfwGetJoystickHats_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetJoystickHats_CallInstance); + Mock.glfwGetJoystickHats_CallInstance = CMock_Guts_MemNext(Mock.glfwGetJoystickHats_CallInstance); + if (Mock.glfwGetJoystickHats_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetJoystickHats_FinalReturn; + memcpy((void*)(&Mock.glfwGetJoystickHats_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(const unsigned char*[sizeof(cmock_call_instance->ReturnVal) == sizeof(const unsigned char*) ? 1 : -1])); /* add const unsigned char* to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetJoystickHats_CallbackBool && + Mock.glfwGetJoystickHats_CallbackFunctionPointer != NULL) + { + const unsigned char* cmock_cb_ret = Mock.glfwGetJoystickHats_CallbackFunctionPointer(jid, count, Mock.glfwGetJoystickHats_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_jid) + { + UNITY_SET_DETAILS(CMockString_glfwGetJoystickHats,CMockString_jid); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_jid, jid, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_count) + { + UNITY_SET_DETAILS(CMockString_glfwGetJoystickHats,CMockString_count); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_count, count, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetJoystickHats_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetJoystickHats_CallbackFunctionPointer(jid, count, Mock.glfwGetJoystickHats_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwGetJoystickHats(CMOCK_glfwGetJoystickHats_CALL_INSTANCE* cmock_call_instance, int jid, int* count); +void CMockExpectParameters_glfwGetJoystickHats(CMOCK_glfwGetJoystickHats_CALL_INSTANCE* cmock_call_instance, int jid, int* count) +{ + cmock_call_instance->Expected_jid = jid; + cmock_call_instance->IgnoreArg_jid = 0; + cmock_call_instance->Expected_count = count; + cmock_call_instance->IgnoreArg_count = 0; +} + +void glfwGetJoystickHats_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, const unsigned char* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetJoystickHats_CALL_INSTANCE)); + CMOCK_glfwGetJoystickHats_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetJoystickHats_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetJoystickHats_CallInstance = CMock_Guts_MemChain(Mock.glfwGetJoystickHats_CallInstance, cmock_guts_index); + Mock.glfwGetJoystickHats_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetJoystickHats_IgnoreBool = (char)1; +} + +void glfwGetJoystickHats_CMockStopIgnore(void) +{ + if(Mock.glfwGetJoystickHats_IgnoreBool) + Mock.glfwGetJoystickHats_CallInstance = CMock_Guts_MemNext(Mock.glfwGetJoystickHats_CallInstance); + Mock.glfwGetJoystickHats_IgnoreBool = (char)0; +} + +void glfwGetJoystickHats_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int jid, int* count, const unsigned char* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetJoystickHats_CALL_INSTANCE)); + CMOCK_glfwGetJoystickHats_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetJoystickHats_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetJoystickHats_CallInstance = CMock_Guts_MemChain(Mock.glfwGetJoystickHats_CallInstance, cmock_guts_index); + Mock.glfwGetJoystickHats_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetJoystickHats(cmock_call_instance, jid, count); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(const unsigned char*[sizeof(cmock_to_return) == sizeof(const unsigned char*) ? 1 : -1])); /* add const unsigned char* to :treat_as_array if this causes an error */ +} + +void glfwGetJoystickHats_AddCallback(CMOCK_glfwGetJoystickHats_CALLBACK Callback) +{ + Mock.glfwGetJoystickHats_IgnoreBool = (char)0; + Mock.glfwGetJoystickHats_CallbackBool = (char)1; + Mock.glfwGetJoystickHats_CallbackFunctionPointer = Callback; +} + +void glfwGetJoystickHats_Stub(CMOCK_glfwGetJoystickHats_CALLBACK Callback) +{ + Mock.glfwGetJoystickHats_IgnoreBool = (char)0; + Mock.glfwGetJoystickHats_CallbackBool = (char)0; + Mock.glfwGetJoystickHats_CallbackFunctionPointer = Callback; +} + +void glfwGetJoystickHats_CMockIgnoreArg_jid(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetJoystickHats_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetJoystickHats_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetJoystickHats_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_jid = 1; +} + +void glfwGetJoystickHats_CMockIgnoreArg_count(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetJoystickHats_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetJoystickHats_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetJoystickHats_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_count = 1; +} + +const char* glfwGetJoystickName(int jid) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetJoystickName_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetJoystickName); + cmock_call_instance = (CMOCK_glfwGetJoystickName_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetJoystickName_CallInstance); + Mock.glfwGetJoystickName_CallInstance = CMock_Guts_MemNext(Mock.glfwGetJoystickName_CallInstance); + if (Mock.glfwGetJoystickName_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetJoystickName_FinalReturn; + Mock.glfwGetJoystickName_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetJoystickName_CallbackBool && + Mock.glfwGetJoystickName_CallbackFunctionPointer != NULL) + { + const char* cmock_cb_ret = Mock.glfwGetJoystickName_CallbackFunctionPointer(jid, Mock.glfwGetJoystickName_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_jid) + { + UNITY_SET_DETAILS(CMockString_glfwGetJoystickName,CMockString_jid); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_jid, jid, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetJoystickName_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetJoystickName_CallbackFunctionPointer(jid, Mock.glfwGetJoystickName_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwGetJoystickName(CMOCK_glfwGetJoystickName_CALL_INSTANCE* cmock_call_instance, int jid); +void CMockExpectParameters_glfwGetJoystickName(CMOCK_glfwGetJoystickName_CALL_INSTANCE* cmock_call_instance, int jid) +{ + cmock_call_instance->Expected_jid = jid; + cmock_call_instance->IgnoreArg_jid = 0; +} + +void glfwGetJoystickName_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, const char* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetJoystickName_CALL_INSTANCE)); + CMOCK_glfwGetJoystickName_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetJoystickName_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetJoystickName_CallInstance = CMock_Guts_MemChain(Mock.glfwGetJoystickName_CallInstance, cmock_guts_index); + Mock.glfwGetJoystickName_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetJoystickName_IgnoreBool = (char)1; +} + +void glfwGetJoystickName_CMockStopIgnore(void) +{ + if(Mock.glfwGetJoystickName_IgnoreBool) + Mock.glfwGetJoystickName_CallInstance = CMock_Guts_MemNext(Mock.glfwGetJoystickName_CallInstance); + Mock.glfwGetJoystickName_IgnoreBool = (char)0; +} + +void glfwGetJoystickName_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int jid, const char* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetJoystickName_CALL_INSTANCE)); + CMOCK_glfwGetJoystickName_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetJoystickName_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetJoystickName_CallInstance = CMock_Guts_MemChain(Mock.glfwGetJoystickName_CallInstance, cmock_guts_index); + Mock.glfwGetJoystickName_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetJoystickName(cmock_call_instance, jid); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwGetJoystickName_AddCallback(CMOCK_glfwGetJoystickName_CALLBACK Callback) +{ + Mock.glfwGetJoystickName_IgnoreBool = (char)0; + Mock.glfwGetJoystickName_CallbackBool = (char)1; + Mock.glfwGetJoystickName_CallbackFunctionPointer = Callback; +} + +void glfwGetJoystickName_Stub(CMOCK_glfwGetJoystickName_CALLBACK Callback) +{ + Mock.glfwGetJoystickName_IgnoreBool = (char)0; + Mock.glfwGetJoystickName_CallbackBool = (char)0; + Mock.glfwGetJoystickName_CallbackFunctionPointer = Callback; +} + +void glfwGetJoystickName_CMockIgnoreArg_jid(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetJoystickName_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetJoystickName_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetJoystickName_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_jid = 1; +} + +const char* glfwGetJoystickGUID(int jid) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetJoystickGUID_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetJoystickGUID); + cmock_call_instance = (CMOCK_glfwGetJoystickGUID_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetJoystickGUID_CallInstance); + Mock.glfwGetJoystickGUID_CallInstance = CMock_Guts_MemNext(Mock.glfwGetJoystickGUID_CallInstance); + if (Mock.glfwGetJoystickGUID_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetJoystickGUID_FinalReturn; + Mock.glfwGetJoystickGUID_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetJoystickGUID_CallbackBool && + Mock.glfwGetJoystickGUID_CallbackFunctionPointer != NULL) + { + const char* cmock_cb_ret = Mock.glfwGetJoystickGUID_CallbackFunctionPointer(jid, Mock.glfwGetJoystickGUID_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_jid) + { + UNITY_SET_DETAILS(CMockString_glfwGetJoystickGUID,CMockString_jid); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_jid, jid, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetJoystickGUID_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetJoystickGUID_CallbackFunctionPointer(jid, Mock.glfwGetJoystickGUID_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwGetJoystickGUID(CMOCK_glfwGetJoystickGUID_CALL_INSTANCE* cmock_call_instance, int jid); +void CMockExpectParameters_glfwGetJoystickGUID(CMOCK_glfwGetJoystickGUID_CALL_INSTANCE* cmock_call_instance, int jid) +{ + cmock_call_instance->Expected_jid = jid; + cmock_call_instance->IgnoreArg_jid = 0; +} + +void glfwGetJoystickGUID_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, const char* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetJoystickGUID_CALL_INSTANCE)); + CMOCK_glfwGetJoystickGUID_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetJoystickGUID_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetJoystickGUID_CallInstance = CMock_Guts_MemChain(Mock.glfwGetJoystickGUID_CallInstance, cmock_guts_index); + Mock.glfwGetJoystickGUID_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetJoystickGUID_IgnoreBool = (char)1; +} + +void glfwGetJoystickGUID_CMockStopIgnore(void) +{ + if(Mock.glfwGetJoystickGUID_IgnoreBool) + Mock.glfwGetJoystickGUID_CallInstance = CMock_Guts_MemNext(Mock.glfwGetJoystickGUID_CallInstance); + Mock.glfwGetJoystickGUID_IgnoreBool = (char)0; +} + +void glfwGetJoystickGUID_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int jid, const char* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetJoystickGUID_CALL_INSTANCE)); + CMOCK_glfwGetJoystickGUID_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetJoystickGUID_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetJoystickGUID_CallInstance = CMock_Guts_MemChain(Mock.glfwGetJoystickGUID_CallInstance, cmock_guts_index); + Mock.glfwGetJoystickGUID_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetJoystickGUID(cmock_call_instance, jid); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwGetJoystickGUID_AddCallback(CMOCK_glfwGetJoystickGUID_CALLBACK Callback) +{ + Mock.glfwGetJoystickGUID_IgnoreBool = (char)0; + Mock.glfwGetJoystickGUID_CallbackBool = (char)1; + Mock.glfwGetJoystickGUID_CallbackFunctionPointer = Callback; +} + +void glfwGetJoystickGUID_Stub(CMOCK_glfwGetJoystickGUID_CALLBACK Callback) +{ + Mock.glfwGetJoystickGUID_IgnoreBool = (char)0; + Mock.glfwGetJoystickGUID_CallbackBool = (char)0; + Mock.glfwGetJoystickGUID_CallbackFunctionPointer = Callback; +} + +void glfwGetJoystickGUID_CMockIgnoreArg_jid(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetJoystickGUID_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetJoystickGUID_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetJoystickGUID_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_jid = 1; +} + +void glfwSetJoystickUserPointer(int jid, void* pointer) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetJoystickUserPointer_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetJoystickUserPointer); + cmock_call_instance = (CMOCK_glfwSetJoystickUserPointer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetJoystickUserPointer_CallInstance); + Mock.glfwSetJoystickUserPointer_CallInstance = CMock_Guts_MemNext(Mock.glfwSetJoystickUserPointer_CallInstance); + if (Mock.glfwSetJoystickUserPointer_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwSetJoystickUserPointer_CallbackBool && + Mock.glfwSetJoystickUserPointer_CallbackFunctionPointer != NULL) + { + Mock.glfwSetJoystickUserPointer_CallbackFunctionPointer(jid, pointer, Mock.glfwSetJoystickUserPointer_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_jid) + { + UNITY_SET_DETAILS(CMockString_glfwSetJoystickUserPointer,CMockString_jid); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_jid, jid, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pointer) + { + UNITY_SET_DETAILS(CMockString_glfwSetJoystickUserPointer,CMockString_pointer); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_pointer, pointer, cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetJoystickUserPointer_CallbackFunctionPointer != NULL) + { + Mock.glfwSetJoystickUserPointer_CallbackFunctionPointer(jid, pointer, Mock.glfwSetJoystickUserPointer_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwSetJoystickUserPointer(CMOCK_glfwSetJoystickUserPointer_CALL_INSTANCE* cmock_call_instance, int jid, void* pointer); +void CMockExpectParameters_glfwSetJoystickUserPointer(CMOCK_glfwSetJoystickUserPointer_CALL_INSTANCE* cmock_call_instance, int jid, void* pointer) +{ + cmock_call_instance->Expected_jid = jid; + cmock_call_instance->IgnoreArg_jid = 0; + cmock_call_instance->Expected_pointer = pointer; + cmock_call_instance->IgnoreArg_pointer = 0; +} + +void glfwSetJoystickUserPointer_CMockIgnore(void) +{ + Mock.glfwSetJoystickUserPointer_IgnoreBool = (char)1; +} + +void glfwSetJoystickUserPointer_CMockStopIgnore(void) +{ + Mock.glfwSetJoystickUserPointer_IgnoreBool = (char)0; +} + +void glfwSetJoystickUserPointer_CMockExpect(UNITY_LINE_TYPE cmock_line, int jid, void* pointer) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetJoystickUserPointer_CALL_INSTANCE)); + CMOCK_glfwSetJoystickUserPointer_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetJoystickUserPointer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetJoystickUserPointer_CallInstance = CMock_Guts_MemChain(Mock.glfwSetJoystickUserPointer_CallInstance, cmock_guts_index); + Mock.glfwSetJoystickUserPointer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetJoystickUserPointer(cmock_call_instance, jid, pointer); +} + +void glfwSetJoystickUserPointer_AddCallback(CMOCK_glfwSetJoystickUserPointer_CALLBACK Callback) +{ + Mock.glfwSetJoystickUserPointer_IgnoreBool = (char)0; + Mock.glfwSetJoystickUserPointer_CallbackBool = (char)1; + Mock.glfwSetJoystickUserPointer_CallbackFunctionPointer = Callback; +} + +void glfwSetJoystickUserPointer_Stub(CMOCK_glfwSetJoystickUserPointer_CALLBACK Callback) +{ + Mock.glfwSetJoystickUserPointer_IgnoreBool = (char)0; + Mock.glfwSetJoystickUserPointer_CallbackBool = (char)0; + Mock.glfwSetJoystickUserPointer_CallbackFunctionPointer = Callback; +} + +void glfwSetJoystickUserPointer_CMockIgnoreArg_jid(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetJoystickUserPointer_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetJoystickUserPointer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetJoystickUserPointer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_jid = 1; +} + +void glfwSetJoystickUserPointer_CMockIgnoreArg_pointer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetJoystickUserPointer_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetJoystickUserPointer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetJoystickUserPointer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pointer = 1; +} + +void* glfwGetJoystickUserPointer(int jid) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetJoystickUserPointer_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetJoystickUserPointer); + cmock_call_instance = (CMOCK_glfwGetJoystickUserPointer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetJoystickUserPointer_CallInstance); + Mock.glfwGetJoystickUserPointer_CallInstance = CMock_Guts_MemNext(Mock.glfwGetJoystickUserPointer_CallInstance); + if (Mock.glfwGetJoystickUserPointer_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetJoystickUserPointer_FinalReturn; + Mock.glfwGetJoystickUserPointer_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetJoystickUserPointer_CallbackBool && + Mock.glfwGetJoystickUserPointer_CallbackFunctionPointer != NULL) + { + void* cmock_cb_ret = Mock.glfwGetJoystickUserPointer_CallbackFunctionPointer(jid, Mock.glfwGetJoystickUserPointer_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_jid) + { + UNITY_SET_DETAILS(CMockString_glfwGetJoystickUserPointer,CMockString_jid); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_jid, jid, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetJoystickUserPointer_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetJoystickUserPointer_CallbackFunctionPointer(jid, Mock.glfwGetJoystickUserPointer_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwGetJoystickUserPointer(CMOCK_glfwGetJoystickUserPointer_CALL_INSTANCE* cmock_call_instance, int jid); +void CMockExpectParameters_glfwGetJoystickUserPointer(CMOCK_glfwGetJoystickUserPointer_CALL_INSTANCE* cmock_call_instance, int jid) +{ + cmock_call_instance->Expected_jid = jid; + cmock_call_instance->IgnoreArg_jid = 0; +} + +void glfwGetJoystickUserPointer_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, void* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetJoystickUserPointer_CALL_INSTANCE)); + CMOCK_glfwGetJoystickUserPointer_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetJoystickUserPointer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetJoystickUserPointer_CallInstance = CMock_Guts_MemChain(Mock.glfwGetJoystickUserPointer_CallInstance, cmock_guts_index); + Mock.glfwGetJoystickUserPointer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetJoystickUserPointer_IgnoreBool = (char)1; +} + +void glfwGetJoystickUserPointer_CMockStopIgnore(void) +{ + if(Mock.glfwGetJoystickUserPointer_IgnoreBool) + Mock.glfwGetJoystickUserPointer_CallInstance = CMock_Guts_MemNext(Mock.glfwGetJoystickUserPointer_CallInstance); + Mock.glfwGetJoystickUserPointer_IgnoreBool = (char)0; +} + +void glfwGetJoystickUserPointer_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int jid, void* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetJoystickUserPointer_CALL_INSTANCE)); + CMOCK_glfwGetJoystickUserPointer_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetJoystickUserPointer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetJoystickUserPointer_CallInstance = CMock_Guts_MemChain(Mock.glfwGetJoystickUserPointer_CallInstance, cmock_guts_index); + Mock.glfwGetJoystickUserPointer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetJoystickUserPointer(cmock_call_instance, jid); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwGetJoystickUserPointer_AddCallback(CMOCK_glfwGetJoystickUserPointer_CALLBACK Callback) +{ + Mock.glfwGetJoystickUserPointer_IgnoreBool = (char)0; + Mock.glfwGetJoystickUserPointer_CallbackBool = (char)1; + Mock.glfwGetJoystickUserPointer_CallbackFunctionPointer = Callback; +} + +void glfwGetJoystickUserPointer_Stub(CMOCK_glfwGetJoystickUserPointer_CALLBACK Callback) +{ + Mock.glfwGetJoystickUserPointer_IgnoreBool = (char)0; + Mock.glfwGetJoystickUserPointer_CallbackBool = (char)0; + Mock.glfwGetJoystickUserPointer_CallbackFunctionPointer = Callback; +} + +void glfwGetJoystickUserPointer_CMockIgnoreArg_jid(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetJoystickUserPointer_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetJoystickUserPointer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetJoystickUserPointer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_jid = 1; +} + +int glfwJoystickIsGamepad(int jid) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwJoystickIsGamepad_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwJoystickIsGamepad); + cmock_call_instance = (CMOCK_glfwJoystickIsGamepad_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwJoystickIsGamepad_CallInstance); + Mock.glfwJoystickIsGamepad_CallInstance = CMock_Guts_MemNext(Mock.glfwJoystickIsGamepad_CallInstance); + if (Mock.glfwJoystickIsGamepad_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwJoystickIsGamepad_FinalReturn; + Mock.glfwJoystickIsGamepad_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwJoystickIsGamepad_CallbackBool && + Mock.glfwJoystickIsGamepad_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.glfwJoystickIsGamepad_CallbackFunctionPointer(jid, Mock.glfwJoystickIsGamepad_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_jid) + { + UNITY_SET_DETAILS(CMockString_glfwJoystickIsGamepad,CMockString_jid); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_jid, jid, cmock_line, CMockStringMismatch); + } + if (Mock.glfwJoystickIsGamepad_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwJoystickIsGamepad_CallbackFunctionPointer(jid, Mock.glfwJoystickIsGamepad_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwJoystickIsGamepad(CMOCK_glfwJoystickIsGamepad_CALL_INSTANCE* cmock_call_instance, int jid); +void CMockExpectParameters_glfwJoystickIsGamepad(CMOCK_glfwJoystickIsGamepad_CALL_INSTANCE* cmock_call_instance, int jid) +{ + cmock_call_instance->Expected_jid = jid; + cmock_call_instance->IgnoreArg_jid = 0; +} + +void glfwJoystickIsGamepad_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwJoystickIsGamepad_CALL_INSTANCE)); + CMOCK_glfwJoystickIsGamepad_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwJoystickIsGamepad_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwJoystickIsGamepad_CallInstance = CMock_Guts_MemChain(Mock.glfwJoystickIsGamepad_CallInstance, cmock_guts_index); + Mock.glfwJoystickIsGamepad_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwJoystickIsGamepad_IgnoreBool = (char)1; +} + +void glfwJoystickIsGamepad_CMockStopIgnore(void) +{ + if(Mock.glfwJoystickIsGamepad_IgnoreBool) + Mock.glfwJoystickIsGamepad_CallInstance = CMock_Guts_MemNext(Mock.glfwJoystickIsGamepad_CallInstance); + Mock.glfwJoystickIsGamepad_IgnoreBool = (char)0; +} + +void glfwJoystickIsGamepad_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int jid, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwJoystickIsGamepad_CALL_INSTANCE)); + CMOCK_glfwJoystickIsGamepad_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwJoystickIsGamepad_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwJoystickIsGamepad_CallInstance = CMock_Guts_MemChain(Mock.glfwJoystickIsGamepad_CallInstance, cmock_guts_index); + Mock.glfwJoystickIsGamepad_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwJoystickIsGamepad(cmock_call_instance, jid); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwJoystickIsGamepad_AddCallback(CMOCK_glfwJoystickIsGamepad_CALLBACK Callback) +{ + Mock.glfwJoystickIsGamepad_IgnoreBool = (char)0; + Mock.glfwJoystickIsGamepad_CallbackBool = (char)1; + Mock.glfwJoystickIsGamepad_CallbackFunctionPointer = Callback; +} + +void glfwJoystickIsGamepad_Stub(CMOCK_glfwJoystickIsGamepad_CALLBACK Callback) +{ + Mock.glfwJoystickIsGamepad_IgnoreBool = (char)0; + Mock.glfwJoystickIsGamepad_CallbackBool = (char)0; + Mock.glfwJoystickIsGamepad_CallbackFunctionPointer = Callback; +} + +void glfwJoystickIsGamepad_CMockIgnoreArg_jid(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwJoystickIsGamepad_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwJoystickIsGamepad_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwJoystickIsGamepad_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_jid = 1; +} + +GLFWjoystickfun glfwSetJoystickCallback(GLFWjoystickfun callback) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetJoystickCallback_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetJoystickCallback); + cmock_call_instance = (CMOCK_glfwSetJoystickCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetJoystickCallback_CallInstance); + Mock.glfwSetJoystickCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetJoystickCallback_CallInstance); + if (Mock.glfwSetJoystickCallback_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwSetJoystickCallback_FinalReturn; + memcpy((void*)(&Mock.glfwSetJoystickCallback_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(GLFWjoystickfun[sizeof(cmock_call_instance->ReturnVal) == sizeof(GLFWjoystickfun) ? 1 : -1])); /* add GLFWjoystickfun to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwSetJoystickCallback_CallbackBool && + Mock.glfwSetJoystickCallback_CallbackFunctionPointer != NULL) + { + GLFWjoystickfun cmock_cb_ret = Mock.glfwSetJoystickCallback_CallbackFunctionPointer(callback, Mock.glfwSetJoystickCallback_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_callback) + { + UNITY_SET_DETAILS(CMockString_glfwSetJoystickCallback,CMockString_callback); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), sizeof(GLFWjoystickfun), cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetJoystickCallback_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwSetJoystickCallback_CallbackFunctionPointer(callback, Mock.glfwSetJoystickCallback_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwSetJoystickCallback(CMOCK_glfwSetJoystickCallback_CALL_INSTANCE* cmock_call_instance, GLFWjoystickfun callback); +void CMockExpectParameters_glfwSetJoystickCallback(CMOCK_glfwSetJoystickCallback_CALL_INSTANCE* cmock_call_instance, GLFWjoystickfun callback) +{ + memcpy((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), + sizeof(GLFWjoystickfun[sizeof(callback) == sizeof(GLFWjoystickfun) ? 1 : -1])); /* add GLFWjoystickfun to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_callback = 0; +} + +void glfwSetJoystickCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWjoystickfun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetJoystickCallback_CALL_INSTANCE)); + CMOCK_glfwSetJoystickCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetJoystickCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetJoystickCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetJoystickCallback_CallInstance, cmock_guts_index); + Mock.glfwSetJoystickCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwSetJoystickCallback_IgnoreBool = (char)1; +} + +void glfwSetJoystickCallback_CMockStopIgnore(void) +{ + if(Mock.glfwSetJoystickCallback_IgnoreBool) + Mock.glfwSetJoystickCallback_CallInstance = CMock_Guts_MemNext(Mock.glfwSetJoystickCallback_CallInstance); + Mock.glfwSetJoystickCallback_IgnoreBool = (char)0; +} + +void glfwSetJoystickCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWjoystickfun callback, GLFWjoystickfun cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetJoystickCallback_CALL_INSTANCE)); + CMOCK_glfwSetJoystickCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetJoystickCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetJoystickCallback_CallInstance = CMock_Guts_MemChain(Mock.glfwSetJoystickCallback_CallInstance, cmock_guts_index); + Mock.glfwSetJoystickCallback_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetJoystickCallback(cmock_call_instance, callback); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(GLFWjoystickfun[sizeof(cmock_to_return) == sizeof(GLFWjoystickfun) ? 1 : -1])); /* add GLFWjoystickfun to :treat_as_array if this causes an error */ +} + +void glfwSetJoystickCallback_AddCallback(CMOCK_glfwSetJoystickCallback_CALLBACK Callback) +{ + Mock.glfwSetJoystickCallback_IgnoreBool = (char)0; + Mock.glfwSetJoystickCallback_CallbackBool = (char)1; + Mock.glfwSetJoystickCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetJoystickCallback_Stub(CMOCK_glfwSetJoystickCallback_CALLBACK Callback) +{ + Mock.glfwSetJoystickCallback_IgnoreBool = (char)0; + Mock.glfwSetJoystickCallback_CallbackBool = (char)0; + Mock.glfwSetJoystickCallback_CallbackFunctionPointer = Callback; +} + +void glfwSetJoystickCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetJoystickCallback_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetJoystickCallback_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetJoystickCallback_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_callback = 1; +} + +int glfwUpdateGamepadMappings(const char* string) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwUpdateGamepadMappings_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwUpdateGamepadMappings); + cmock_call_instance = (CMOCK_glfwUpdateGamepadMappings_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwUpdateGamepadMappings_CallInstance); + Mock.glfwUpdateGamepadMappings_CallInstance = CMock_Guts_MemNext(Mock.glfwUpdateGamepadMappings_CallInstance); + if (Mock.glfwUpdateGamepadMappings_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwUpdateGamepadMappings_FinalReturn; + Mock.glfwUpdateGamepadMappings_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwUpdateGamepadMappings_CallbackBool && + Mock.glfwUpdateGamepadMappings_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.glfwUpdateGamepadMappings_CallbackFunctionPointer(string, Mock.glfwUpdateGamepadMappings_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_string) + { + UNITY_SET_DETAILS(CMockString_glfwUpdateGamepadMappings,CMockString_string); + UNITY_TEST_ASSERT_EQUAL_STRING(cmock_call_instance->Expected_string, string, cmock_line, CMockStringMismatch); + } + if (Mock.glfwUpdateGamepadMappings_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwUpdateGamepadMappings_CallbackFunctionPointer(string, Mock.glfwUpdateGamepadMappings_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwUpdateGamepadMappings(CMOCK_glfwUpdateGamepadMappings_CALL_INSTANCE* cmock_call_instance, const char* string); +void CMockExpectParameters_glfwUpdateGamepadMappings(CMOCK_glfwUpdateGamepadMappings_CALL_INSTANCE* cmock_call_instance, const char* string) +{ + cmock_call_instance->Expected_string = string; + cmock_call_instance->IgnoreArg_string = 0; +} + +void glfwUpdateGamepadMappings_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwUpdateGamepadMappings_CALL_INSTANCE)); + CMOCK_glfwUpdateGamepadMappings_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwUpdateGamepadMappings_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwUpdateGamepadMappings_CallInstance = CMock_Guts_MemChain(Mock.glfwUpdateGamepadMappings_CallInstance, cmock_guts_index); + Mock.glfwUpdateGamepadMappings_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwUpdateGamepadMappings_IgnoreBool = (char)1; +} + +void glfwUpdateGamepadMappings_CMockStopIgnore(void) +{ + if(Mock.glfwUpdateGamepadMappings_IgnoreBool) + Mock.glfwUpdateGamepadMappings_CallInstance = CMock_Guts_MemNext(Mock.glfwUpdateGamepadMappings_CallInstance); + Mock.glfwUpdateGamepadMappings_IgnoreBool = (char)0; +} + +void glfwUpdateGamepadMappings_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, const char* string, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwUpdateGamepadMappings_CALL_INSTANCE)); + CMOCK_glfwUpdateGamepadMappings_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwUpdateGamepadMappings_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwUpdateGamepadMappings_CallInstance = CMock_Guts_MemChain(Mock.glfwUpdateGamepadMappings_CallInstance, cmock_guts_index); + Mock.glfwUpdateGamepadMappings_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwUpdateGamepadMappings(cmock_call_instance, string); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwUpdateGamepadMappings_AddCallback(CMOCK_glfwUpdateGamepadMappings_CALLBACK Callback) +{ + Mock.glfwUpdateGamepadMappings_IgnoreBool = (char)0; + Mock.glfwUpdateGamepadMappings_CallbackBool = (char)1; + Mock.glfwUpdateGamepadMappings_CallbackFunctionPointer = Callback; +} + +void glfwUpdateGamepadMappings_Stub(CMOCK_glfwUpdateGamepadMappings_CALLBACK Callback) +{ + Mock.glfwUpdateGamepadMappings_IgnoreBool = (char)0; + Mock.glfwUpdateGamepadMappings_CallbackBool = (char)0; + Mock.glfwUpdateGamepadMappings_CallbackFunctionPointer = Callback; +} + +void glfwUpdateGamepadMappings_CMockIgnoreArg_string(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwUpdateGamepadMappings_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwUpdateGamepadMappings_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwUpdateGamepadMappings_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_string = 1; +} + +const char* glfwGetGamepadName(int jid) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetGamepadName_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetGamepadName); + cmock_call_instance = (CMOCK_glfwGetGamepadName_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetGamepadName_CallInstance); + Mock.glfwGetGamepadName_CallInstance = CMock_Guts_MemNext(Mock.glfwGetGamepadName_CallInstance); + if (Mock.glfwGetGamepadName_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetGamepadName_FinalReturn; + Mock.glfwGetGamepadName_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetGamepadName_CallbackBool && + Mock.glfwGetGamepadName_CallbackFunctionPointer != NULL) + { + const char* cmock_cb_ret = Mock.glfwGetGamepadName_CallbackFunctionPointer(jid, Mock.glfwGetGamepadName_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_jid) + { + UNITY_SET_DETAILS(CMockString_glfwGetGamepadName,CMockString_jid); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_jid, jid, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetGamepadName_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetGamepadName_CallbackFunctionPointer(jid, Mock.glfwGetGamepadName_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwGetGamepadName(CMOCK_glfwGetGamepadName_CALL_INSTANCE* cmock_call_instance, int jid); +void CMockExpectParameters_glfwGetGamepadName(CMOCK_glfwGetGamepadName_CALL_INSTANCE* cmock_call_instance, int jid) +{ + cmock_call_instance->Expected_jid = jid; + cmock_call_instance->IgnoreArg_jid = 0; +} + +void glfwGetGamepadName_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, const char* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetGamepadName_CALL_INSTANCE)); + CMOCK_glfwGetGamepadName_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetGamepadName_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetGamepadName_CallInstance = CMock_Guts_MemChain(Mock.glfwGetGamepadName_CallInstance, cmock_guts_index); + Mock.glfwGetGamepadName_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetGamepadName_IgnoreBool = (char)1; +} + +void glfwGetGamepadName_CMockStopIgnore(void) +{ + if(Mock.glfwGetGamepadName_IgnoreBool) + Mock.glfwGetGamepadName_CallInstance = CMock_Guts_MemNext(Mock.glfwGetGamepadName_CallInstance); + Mock.glfwGetGamepadName_IgnoreBool = (char)0; +} + +void glfwGetGamepadName_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int jid, const char* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetGamepadName_CALL_INSTANCE)); + CMOCK_glfwGetGamepadName_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetGamepadName_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetGamepadName_CallInstance = CMock_Guts_MemChain(Mock.glfwGetGamepadName_CallInstance, cmock_guts_index); + Mock.glfwGetGamepadName_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetGamepadName(cmock_call_instance, jid); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwGetGamepadName_AddCallback(CMOCK_glfwGetGamepadName_CALLBACK Callback) +{ + Mock.glfwGetGamepadName_IgnoreBool = (char)0; + Mock.glfwGetGamepadName_CallbackBool = (char)1; + Mock.glfwGetGamepadName_CallbackFunctionPointer = Callback; +} + +void glfwGetGamepadName_Stub(CMOCK_glfwGetGamepadName_CALLBACK Callback) +{ + Mock.glfwGetGamepadName_IgnoreBool = (char)0; + Mock.glfwGetGamepadName_CallbackBool = (char)0; + Mock.glfwGetGamepadName_CallbackFunctionPointer = Callback; +} + +void glfwGetGamepadName_CMockIgnoreArg_jid(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetGamepadName_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetGamepadName_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetGamepadName_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_jid = 1; +} + +int glfwGetGamepadState(int jid, GLFWgamepadstate* state) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetGamepadState_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetGamepadState); + cmock_call_instance = (CMOCK_glfwGetGamepadState_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetGamepadState_CallInstance); + Mock.glfwGetGamepadState_CallInstance = CMock_Guts_MemNext(Mock.glfwGetGamepadState_CallInstance); + if (Mock.glfwGetGamepadState_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetGamepadState_FinalReturn; + Mock.glfwGetGamepadState_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetGamepadState_CallbackBool && + Mock.glfwGetGamepadState_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.glfwGetGamepadState_CallbackFunctionPointer(jid, state, Mock.glfwGetGamepadState_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_jid) + { + UNITY_SET_DETAILS(CMockString_glfwGetGamepadState,CMockString_jid); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_jid, jid, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_state) + { + UNITY_SET_DETAILS(CMockString_glfwGetGamepadState,CMockString_state); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_state, state, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetGamepadState_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetGamepadState_CallbackFunctionPointer(jid, state, Mock.glfwGetGamepadState_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwGetGamepadState(CMOCK_glfwGetGamepadState_CALL_INSTANCE* cmock_call_instance, int jid, GLFWgamepadstate* state); +void CMockExpectParameters_glfwGetGamepadState(CMOCK_glfwGetGamepadState_CALL_INSTANCE* cmock_call_instance, int jid, GLFWgamepadstate* state) +{ + cmock_call_instance->Expected_jid = jid; + cmock_call_instance->IgnoreArg_jid = 0; + cmock_call_instance->Expected_state = state; + cmock_call_instance->IgnoreArg_state = 0; +} + +void glfwGetGamepadState_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetGamepadState_CALL_INSTANCE)); + CMOCK_glfwGetGamepadState_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetGamepadState_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetGamepadState_CallInstance = CMock_Guts_MemChain(Mock.glfwGetGamepadState_CallInstance, cmock_guts_index); + Mock.glfwGetGamepadState_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetGamepadState_IgnoreBool = (char)1; +} + +void glfwGetGamepadState_CMockStopIgnore(void) +{ + if(Mock.glfwGetGamepadState_IgnoreBool) + Mock.glfwGetGamepadState_CallInstance = CMock_Guts_MemNext(Mock.glfwGetGamepadState_CallInstance); + Mock.glfwGetGamepadState_IgnoreBool = (char)0; +} + +void glfwGetGamepadState_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int jid, GLFWgamepadstate* state, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetGamepadState_CALL_INSTANCE)); + CMOCK_glfwGetGamepadState_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetGamepadState_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetGamepadState_CallInstance = CMock_Guts_MemChain(Mock.glfwGetGamepadState_CallInstance, cmock_guts_index); + Mock.glfwGetGamepadState_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetGamepadState(cmock_call_instance, jid, state); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwGetGamepadState_AddCallback(CMOCK_glfwGetGamepadState_CALLBACK Callback) +{ + Mock.glfwGetGamepadState_IgnoreBool = (char)0; + Mock.glfwGetGamepadState_CallbackBool = (char)1; + Mock.glfwGetGamepadState_CallbackFunctionPointer = Callback; +} + +void glfwGetGamepadState_Stub(CMOCK_glfwGetGamepadState_CALLBACK Callback) +{ + Mock.glfwGetGamepadState_IgnoreBool = (char)0; + Mock.glfwGetGamepadState_CallbackBool = (char)0; + Mock.glfwGetGamepadState_CallbackFunctionPointer = Callback; +} + +void glfwGetGamepadState_CMockIgnoreArg_jid(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetGamepadState_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetGamepadState_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetGamepadState_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_jid = 1; +} + +void glfwGetGamepadState_CMockIgnoreArg_state(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetGamepadState_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetGamepadState_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetGamepadState_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_state = 1; +} + +void glfwSetClipboardString(GLFWwindow* window, const char* string) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetClipboardString_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetClipboardString); + cmock_call_instance = (CMOCK_glfwSetClipboardString_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetClipboardString_CallInstance); + Mock.glfwSetClipboardString_CallInstance = CMock_Guts_MemNext(Mock.glfwSetClipboardString_CallInstance); + if (Mock.glfwSetClipboardString_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwSetClipboardString_CallbackBool && + Mock.glfwSetClipboardString_CallbackFunctionPointer != NULL) + { + Mock.glfwSetClipboardString_CallbackFunctionPointer(window, string, Mock.glfwSetClipboardString_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSetClipboardString,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_string) + { + UNITY_SET_DETAILS(CMockString_glfwSetClipboardString,CMockString_string); + UNITY_TEST_ASSERT_EQUAL_STRING(cmock_call_instance->Expected_string, string, cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetClipboardString_CallbackFunctionPointer != NULL) + { + Mock.glfwSetClipboardString_CallbackFunctionPointer(window, string, Mock.glfwSetClipboardString_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwSetClipboardString(CMOCK_glfwSetClipboardString_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, const char* string); +void CMockExpectParameters_glfwSetClipboardString(CMOCK_glfwSetClipboardString_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window, const char* string) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + cmock_call_instance->Expected_string = string; + cmock_call_instance->IgnoreArg_string = 0; +} + +void glfwSetClipboardString_CMockIgnore(void) +{ + Mock.glfwSetClipboardString_IgnoreBool = (char)1; +} + +void glfwSetClipboardString_CMockStopIgnore(void) +{ + Mock.glfwSetClipboardString_IgnoreBool = (char)0; +} + +void glfwSetClipboardString_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, const char* string) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetClipboardString_CALL_INSTANCE)); + CMOCK_glfwSetClipboardString_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetClipboardString_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetClipboardString_CallInstance = CMock_Guts_MemChain(Mock.glfwSetClipboardString_CallInstance, cmock_guts_index); + Mock.glfwSetClipboardString_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetClipboardString(cmock_call_instance, window, string); +} + +void glfwSetClipboardString_AddCallback(CMOCK_glfwSetClipboardString_CALLBACK Callback) +{ + Mock.glfwSetClipboardString_IgnoreBool = (char)0; + Mock.glfwSetClipboardString_CallbackBool = (char)1; + Mock.glfwSetClipboardString_CallbackFunctionPointer = Callback; +} + +void glfwSetClipboardString_Stub(CMOCK_glfwSetClipboardString_CALLBACK Callback) +{ + Mock.glfwSetClipboardString_IgnoreBool = (char)0; + Mock.glfwSetClipboardString_CallbackBool = (char)0; + Mock.glfwSetClipboardString_CallbackFunctionPointer = Callback; +} + +void glfwSetClipboardString_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetClipboardString_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetClipboardString_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetClipboardString_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSetClipboardString_CMockIgnoreArg_string(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetClipboardString_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetClipboardString_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetClipboardString_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_string = 1; +} + +const char* glfwGetClipboardString(GLFWwindow* window) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetClipboardString_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetClipboardString); + cmock_call_instance = (CMOCK_glfwGetClipboardString_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetClipboardString_CallInstance); + Mock.glfwGetClipboardString_CallInstance = CMock_Guts_MemNext(Mock.glfwGetClipboardString_CallInstance); + if (Mock.glfwGetClipboardString_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetClipboardString_FinalReturn; + Mock.glfwGetClipboardString_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetClipboardString_CallbackBool && + Mock.glfwGetClipboardString_CallbackFunctionPointer != NULL) + { + const char* cmock_cb_ret = Mock.glfwGetClipboardString_CallbackFunctionPointer(window, Mock.glfwGetClipboardString_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwGetClipboardString,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetClipboardString_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetClipboardString_CallbackFunctionPointer(window, Mock.glfwGetClipboardString_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwGetClipboardString(CMOCK_glfwGetClipboardString_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window); +void CMockExpectParameters_glfwGetClipboardString(CMOCK_glfwGetClipboardString_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; +} + +void glfwGetClipboardString_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, const char* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetClipboardString_CALL_INSTANCE)); + CMOCK_glfwGetClipboardString_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetClipboardString_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetClipboardString_CallInstance = CMock_Guts_MemChain(Mock.glfwGetClipboardString_CallInstance, cmock_guts_index); + Mock.glfwGetClipboardString_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetClipboardString_IgnoreBool = (char)1; +} + +void glfwGetClipboardString_CMockStopIgnore(void) +{ + if(Mock.glfwGetClipboardString_IgnoreBool) + Mock.glfwGetClipboardString_CallInstance = CMock_Guts_MemNext(Mock.glfwGetClipboardString_CallInstance); + Mock.glfwGetClipboardString_IgnoreBool = (char)0; +} + +void glfwGetClipboardString_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, const char* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetClipboardString_CALL_INSTANCE)); + CMOCK_glfwGetClipboardString_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetClipboardString_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetClipboardString_CallInstance = CMock_Guts_MemChain(Mock.glfwGetClipboardString_CallInstance, cmock_guts_index); + Mock.glfwGetClipboardString_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetClipboardString(cmock_call_instance, window); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwGetClipboardString_AddCallback(CMOCK_glfwGetClipboardString_CALLBACK Callback) +{ + Mock.glfwGetClipboardString_IgnoreBool = (char)0; + Mock.glfwGetClipboardString_CallbackBool = (char)1; + Mock.glfwGetClipboardString_CallbackFunctionPointer = Callback; +} + +void glfwGetClipboardString_Stub(CMOCK_glfwGetClipboardString_CALLBACK Callback) +{ + Mock.glfwGetClipboardString_IgnoreBool = (char)0; + Mock.glfwGetClipboardString_CallbackBool = (char)0; + Mock.glfwGetClipboardString_CallbackFunctionPointer = Callback; +} + +void glfwGetClipboardString_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetClipboardString_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetClipboardString_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetClipboardString_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +double glfwGetTime(void) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetTime_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetTime); + cmock_call_instance = (CMOCK_glfwGetTime_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetTime_CallInstance); + Mock.glfwGetTime_CallInstance = CMock_Guts_MemNext(Mock.glfwGetTime_CallInstance); + if (Mock.glfwGetTime_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetTime_FinalReturn; + Mock.glfwGetTime_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetTime_CallbackBool && + Mock.glfwGetTime_CallbackFunctionPointer != NULL) + { + double cmock_cb_ret = Mock.glfwGetTime_CallbackFunctionPointer(Mock.glfwGetTime_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (Mock.glfwGetTime_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetTime_CallbackFunctionPointer(Mock.glfwGetTime_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void glfwGetTime_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, double cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetTime_CALL_INSTANCE)); + CMOCK_glfwGetTime_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetTime_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetTime_CallInstance = CMock_Guts_MemChain(Mock.glfwGetTime_CallInstance, cmock_guts_index); + Mock.glfwGetTime_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetTime_IgnoreBool = (char)1; +} + +void glfwGetTime_CMockStopIgnore(void) +{ + if(Mock.glfwGetTime_IgnoreBool) + Mock.glfwGetTime_CallInstance = CMock_Guts_MemNext(Mock.glfwGetTime_CallInstance); + Mock.glfwGetTime_IgnoreBool = (char)0; +} + +void glfwGetTime_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, double cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetTime_CALL_INSTANCE)); + CMOCK_glfwGetTime_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetTime_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetTime_CallInstance = CMock_Guts_MemChain(Mock.glfwGetTime_CallInstance, cmock_guts_index); + Mock.glfwGetTime_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwGetTime_AddCallback(CMOCK_glfwGetTime_CALLBACK Callback) +{ + Mock.glfwGetTime_IgnoreBool = (char)0; + Mock.glfwGetTime_CallbackBool = (char)1; + Mock.glfwGetTime_CallbackFunctionPointer = Callback; +} + +void glfwGetTime_Stub(CMOCK_glfwGetTime_CALLBACK Callback) +{ + Mock.glfwGetTime_IgnoreBool = (char)0; + Mock.glfwGetTime_CallbackBool = (char)0; + Mock.glfwGetTime_CallbackFunctionPointer = Callback; +} + +void glfwSetTime(double time) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSetTime_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSetTime); + cmock_call_instance = (CMOCK_glfwSetTime_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSetTime_CallInstance); + Mock.glfwSetTime_CallInstance = CMock_Guts_MemNext(Mock.glfwSetTime_CallInstance); + if (Mock.glfwSetTime_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwSetTime_CallbackBool && + Mock.glfwSetTime_CallbackFunctionPointer != NULL) + { + Mock.glfwSetTime_CallbackFunctionPointer(time, Mock.glfwSetTime_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_time) + { + UNITY_SET_DETAILS(CMockString_glfwSetTime,CMockString_time); + UNITY_TEST_ASSERT_EQUAL_FLOAT(cmock_call_instance->Expected_time, time, cmock_line, CMockStringMismatch); + } + if (Mock.glfwSetTime_CallbackFunctionPointer != NULL) + { + Mock.glfwSetTime_CallbackFunctionPointer(time, Mock.glfwSetTime_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwSetTime(CMOCK_glfwSetTime_CALL_INSTANCE* cmock_call_instance, double time); +void CMockExpectParameters_glfwSetTime(CMOCK_glfwSetTime_CALL_INSTANCE* cmock_call_instance, double time) +{ + cmock_call_instance->Expected_time = time; + cmock_call_instance->IgnoreArg_time = 0; +} + +void glfwSetTime_CMockIgnore(void) +{ + Mock.glfwSetTime_IgnoreBool = (char)1; +} + +void glfwSetTime_CMockStopIgnore(void) +{ + Mock.glfwSetTime_IgnoreBool = (char)0; +} + +void glfwSetTime_CMockExpect(UNITY_LINE_TYPE cmock_line, double time) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSetTime_CALL_INSTANCE)); + CMOCK_glfwSetTime_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetTime_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSetTime_CallInstance = CMock_Guts_MemChain(Mock.glfwSetTime_CallInstance, cmock_guts_index); + Mock.glfwSetTime_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSetTime(cmock_call_instance, time); +} + +void glfwSetTime_AddCallback(CMOCK_glfwSetTime_CALLBACK Callback) +{ + Mock.glfwSetTime_IgnoreBool = (char)0; + Mock.glfwSetTime_CallbackBool = (char)1; + Mock.glfwSetTime_CallbackFunctionPointer = Callback; +} + +void glfwSetTime_Stub(CMOCK_glfwSetTime_CALLBACK Callback) +{ + Mock.glfwSetTime_IgnoreBool = (char)0; + Mock.glfwSetTime_CallbackBool = (char)0; + Mock.glfwSetTime_CallbackFunctionPointer = Callback; +} + +void glfwSetTime_CMockIgnoreArg_time(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSetTime_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSetTime_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSetTime_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_time = 1; +} + +uint64_t glfwGetTimerValue(void) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetTimerValue_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetTimerValue); + cmock_call_instance = (CMOCK_glfwGetTimerValue_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetTimerValue_CallInstance); + Mock.glfwGetTimerValue_CallInstance = CMock_Guts_MemNext(Mock.glfwGetTimerValue_CallInstance); + if (Mock.glfwGetTimerValue_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetTimerValue_FinalReturn; + memcpy((void*)(&Mock.glfwGetTimerValue_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(uint64_t[sizeof(cmock_call_instance->ReturnVal) == sizeof(uint64_t) ? 1 : -1])); /* add uint64_t to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetTimerValue_CallbackBool && + Mock.glfwGetTimerValue_CallbackFunctionPointer != NULL) + { + uint64_t cmock_cb_ret = Mock.glfwGetTimerValue_CallbackFunctionPointer(Mock.glfwGetTimerValue_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (Mock.glfwGetTimerValue_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetTimerValue_CallbackFunctionPointer(Mock.glfwGetTimerValue_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void glfwGetTimerValue_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, uint64_t cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetTimerValue_CALL_INSTANCE)); + CMOCK_glfwGetTimerValue_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetTimerValue_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetTimerValue_CallInstance = CMock_Guts_MemChain(Mock.glfwGetTimerValue_CallInstance, cmock_guts_index); + Mock.glfwGetTimerValue_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetTimerValue_IgnoreBool = (char)1; +} + +void glfwGetTimerValue_CMockStopIgnore(void) +{ + if(Mock.glfwGetTimerValue_IgnoreBool) + Mock.glfwGetTimerValue_CallInstance = CMock_Guts_MemNext(Mock.glfwGetTimerValue_CallInstance); + Mock.glfwGetTimerValue_IgnoreBool = (char)0; +} + +void glfwGetTimerValue_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, uint64_t cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetTimerValue_CALL_INSTANCE)); + CMOCK_glfwGetTimerValue_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetTimerValue_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetTimerValue_CallInstance = CMock_Guts_MemChain(Mock.glfwGetTimerValue_CallInstance, cmock_guts_index); + Mock.glfwGetTimerValue_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(uint64_t[sizeof(cmock_to_return) == sizeof(uint64_t) ? 1 : -1])); /* add uint64_t to :treat_as_array if this causes an error */ +} + +void glfwGetTimerValue_AddCallback(CMOCK_glfwGetTimerValue_CALLBACK Callback) +{ + Mock.glfwGetTimerValue_IgnoreBool = (char)0; + Mock.glfwGetTimerValue_CallbackBool = (char)1; + Mock.glfwGetTimerValue_CallbackFunctionPointer = Callback; +} + +void glfwGetTimerValue_Stub(CMOCK_glfwGetTimerValue_CALLBACK Callback) +{ + Mock.glfwGetTimerValue_IgnoreBool = (char)0; + Mock.glfwGetTimerValue_CallbackBool = (char)0; + Mock.glfwGetTimerValue_CallbackFunctionPointer = Callback; +} + +uint64_t glfwGetTimerFrequency(void) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetTimerFrequency_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetTimerFrequency); + cmock_call_instance = (CMOCK_glfwGetTimerFrequency_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetTimerFrequency_CallInstance); + Mock.glfwGetTimerFrequency_CallInstance = CMock_Guts_MemNext(Mock.glfwGetTimerFrequency_CallInstance); + if (Mock.glfwGetTimerFrequency_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetTimerFrequency_FinalReturn; + memcpy((void*)(&Mock.glfwGetTimerFrequency_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(uint64_t[sizeof(cmock_call_instance->ReturnVal) == sizeof(uint64_t) ? 1 : -1])); /* add uint64_t to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetTimerFrequency_CallbackBool && + Mock.glfwGetTimerFrequency_CallbackFunctionPointer != NULL) + { + uint64_t cmock_cb_ret = Mock.glfwGetTimerFrequency_CallbackFunctionPointer(Mock.glfwGetTimerFrequency_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (Mock.glfwGetTimerFrequency_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetTimerFrequency_CallbackFunctionPointer(Mock.glfwGetTimerFrequency_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void glfwGetTimerFrequency_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, uint64_t cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetTimerFrequency_CALL_INSTANCE)); + CMOCK_glfwGetTimerFrequency_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetTimerFrequency_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetTimerFrequency_CallInstance = CMock_Guts_MemChain(Mock.glfwGetTimerFrequency_CallInstance, cmock_guts_index); + Mock.glfwGetTimerFrequency_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetTimerFrequency_IgnoreBool = (char)1; +} + +void glfwGetTimerFrequency_CMockStopIgnore(void) +{ + if(Mock.glfwGetTimerFrequency_IgnoreBool) + Mock.glfwGetTimerFrequency_CallInstance = CMock_Guts_MemNext(Mock.glfwGetTimerFrequency_CallInstance); + Mock.glfwGetTimerFrequency_IgnoreBool = (char)0; +} + +void glfwGetTimerFrequency_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, uint64_t cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetTimerFrequency_CALL_INSTANCE)); + CMOCK_glfwGetTimerFrequency_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetTimerFrequency_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetTimerFrequency_CallInstance = CMock_Guts_MemChain(Mock.glfwGetTimerFrequency_CallInstance, cmock_guts_index); + Mock.glfwGetTimerFrequency_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(uint64_t[sizeof(cmock_to_return) == sizeof(uint64_t) ? 1 : -1])); /* add uint64_t to :treat_as_array if this causes an error */ +} + +void glfwGetTimerFrequency_AddCallback(CMOCK_glfwGetTimerFrequency_CALLBACK Callback) +{ + Mock.glfwGetTimerFrequency_IgnoreBool = (char)0; + Mock.glfwGetTimerFrequency_CallbackBool = (char)1; + Mock.glfwGetTimerFrequency_CallbackFunctionPointer = Callback; +} + +void glfwGetTimerFrequency_Stub(CMOCK_glfwGetTimerFrequency_CALLBACK Callback) +{ + Mock.glfwGetTimerFrequency_IgnoreBool = (char)0; + Mock.glfwGetTimerFrequency_CallbackBool = (char)0; + Mock.glfwGetTimerFrequency_CallbackFunctionPointer = Callback; +} + +void glfwMakeContextCurrent(GLFWwindow* window) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwMakeContextCurrent_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwMakeContextCurrent); + cmock_call_instance = (CMOCK_glfwMakeContextCurrent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwMakeContextCurrent_CallInstance); + Mock.glfwMakeContextCurrent_CallInstance = CMock_Guts_MemNext(Mock.glfwMakeContextCurrent_CallInstance); + if (Mock.glfwMakeContextCurrent_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwMakeContextCurrent_CallbackBool && + Mock.glfwMakeContextCurrent_CallbackFunctionPointer != NULL) + { + Mock.glfwMakeContextCurrent_CallbackFunctionPointer(window, Mock.glfwMakeContextCurrent_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwMakeContextCurrent,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (Mock.glfwMakeContextCurrent_CallbackFunctionPointer != NULL) + { + Mock.glfwMakeContextCurrent_CallbackFunctionPointer(window, Mock.glfwMakeContextCurrent_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwMakeContextCurrent(CMOCK_glfwMakeContextCurrent_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window); +void CMockExpectParameters_glfwMakeContextCurrent(CMOCK_glfwMakeContextCurrent_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; +} + +void glfwMakeContextCurrent_CMockIgnore(void) +{ + Mock.glfwMakeContextCurrent_IgnoreBool = (char)1; +} + +void glfwMakeContextCurrent_CMockStopIgnore(void) +{ + Mock.glfwMakeContextCurrent_IgnoreBool = (char)0; +} + +void glfwMakeContextCurrent_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwMakeContextCurrent_CALL_INSTANCE)); + CMOCK_glfwMakeContextCurrent_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwMakeContextCurrent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwMakeContextCurrent_CallInstance = CMock_Guts_MemChain(Mock.glfwMakeContextCurrent_CallInstance, cmock_guts_index); + Mock.glfwMakeContextCurrent_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwMakeContextCurrent(cmock_call_instance, window); +} + +void glfwMakeContextCurrent_AddCallback(CMOCK_glfwMakeContextCurrent_CALLBACK Callback) +{ + Mock.glfwMakeContextCurrent_IgnoreBool = (char)0; + Mock.glfwMakeContextCurrent_CallbackBool = (char)1; + Mock.glfwMakeContextCurrent_CallbackFunctionPointer = Callback; +} + +void glfwMakeContextCurrent_Stub(CMOCK_glfwMakeContextCurrent_CALLBACK Callback) +{ + Mock.glfwMakeContextCurrent_IgnoreBool = (char)0; + Mock.glfwMakeContextCurrent_CallbackBool = (char)0; + Mock.glfwMakeContextCurrent_CallbackFunctionPointer = Callback; +} + +void glfwMakeContextCurrent_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwMakeContextCurrent_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwMakeContextCurrent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwMakeContextCurrent_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +GLFWwindow* glfwGetCurrentContext(void) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetCurrentContext_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetCurrentContext); + cmock_call_instance = (CMOCK_glfwGetCurrentContext_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetCurrentContext_CallInstance); + Mock.glfwGetCurrentContext_CallInstance = CMock_Guts_MemNext(Mock.glfwGetCurrentContext_CallInstance); + if (Mock.glfwGetCurrentContext_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetCurrentContext_FinalReturn; + Mock.glfwGetCurrentContext_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetCurrentContext_CallbackBool && + Mock.glfwGetCurrentContext_CallbackFunctionPointer != NULL) + { + GLFWwindow* cmock_cb_ret = Mock.glfwGetCurrentContext_CallbackFunctionPointer(Mock.glfwGetCurrentContext_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (Mock.glfwGetCurrentContext_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetCurrentContext_CallbackFunctionPointer(Mock.glfwGetCurrentContext_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void glfwGetCurrentContext_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetCurrentContext_CALL_INSTANCE)); + CMOCK_glfwGetCurrentContext_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetCurrentContext_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetCurrentContext_CallInstance = CMock_Guts_MemChain(Mock.glfwGetCurrentContext_CallInstance, cmock_guts_index); + Mock.glfwGetCurrentContext_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetCurrentContext_IgnoreBool = (char)1; +} + +void glfwGetCurrentContext_CMockStopIgnore(void) +{ + if(Mock.glfwGetCurrentContext_IgnoreBool) + Mock.glfwGetCurrentContext_CallInstance = CMock_Guts_MemNext(Mock.glfwGetCurrentContext_CallInstance); + Mock.glfwGetCurrentContext_IgnoreBool = (char)0; +} + +void glfwGetCurrentContext_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetCurrentContext_CALL_INSTANCE)); + CMOCK_glfwGetCurrentContext_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetCurrentContext_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetCurrentContext_CallInstance = CMock_Guts_MemChain(Mock.glfwGetCurrentContext_CallInstance, cmock_guts_index); + Mock.glfwGetCurrentContext_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwGetCurrentContext_AddCallback(CMOCK_glfwGetCurrentContext_CALLBACK Callback) +{ + Mock.glfwGetCurrentContext_IgnoreBool = (char)0; + Mock.glfwGetCurrentContext_CallbackBool = (char)1; + Mock.glfwGetCurrentContext_CallbackFunctionPointer = Callback; +} + +void glfwGetCurrentContext_Stub(CMOCK_glfwGetCurrentContext_CALLBACK Callback) +{ + Mock.glfwGetCurrentContext_IgnoreBool = (char)0; + Mock.glfwGetCurrentContext_CallbackBool = (char)0; + Mock.glfwGetCurrentContext_CallbackFunctionPointer = Callback; +} + +void glfwSwapBuffers(GLFWwindow* window) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSwapBuffers_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSwapBuffers); + cmock_call_instance = (CMOCK_glfwSwapBuffers_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSwapBuffers_CallInstance); + Mock.glfwSwapBuffers_CallInstance = CMock_Guts_MemNext(Mock.glfwSwapBuffers_CallInstance); + if (Mock.glfwSwapBuffers_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwSwapBuffers_CallbackBool && + Mock.glfwSwapBuffers_CallbackFunctionPointer != NULL) + { + Mock.glfwSwapBuffers_CallbackFunctionPointer(window, Mock.glfwSwapBuffers_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwSwapBuffers,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (Mock.glfwSwapBuffers_CallbackFunctionPointer != NULL) + { + Mock.glfwSwapBuffers_CallbackFunctionPointer(window, Mock.glfwSwapBuffers_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwSwapBuffers(CMOCK_glfwSwapBuffers_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window); +void CMockExpectParameters_glfwSwapBuffers(CMOCK_glfwSwapBuffers_CALL_INSTANCE* cmock_call_instance, GLFWwindow* window) +{ + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; +} + +void glfwSwapBuffers_CMockIgnore(void) +{ + Mock.glfwSwapBuffers_IgnoreBool = (char)1; +} + +void glfwSwapBuffers_CMockStopIgnore(void) +{ + Mock.glfwSwapBuffers_IgnoreBool = (char)0; +} + +void glfwSwapBuffers_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSwapBuffers_CALL_INSTANCE)); + CMOCK_glfwSwapBuffers_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSwapBuffers_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSwapBuffers_CallInstance = CMock_Guts_MemChain(Mock.glfwSwapBuffers_CallInstance, cmock_guts_index); + Mock.glfwSwapBuffers_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSwapBuffers(cmock_call_instance, window); +} + +void glfwSwapBuffers_AddCallback(CMOCK_glfwSwapBuffers_CALLBACK Callback) +{ + Mock.glfwSwapBuffers_IgnoreBool = (char)0; + Mock.glfwSwapBuffers_CallbackBool = (char)1; + Mock.glfwSwapBuffers_CallbackFunctionPointer = Callback; +} + +void glfwSwapBuffers_Stub(CMOCK_glfwSwapBuffers_CALLBACK Callback) +{ + Mock.glfwSwapBuffers_IgnoreBool = (char)0; + Mock.glfwSwapBuffers_CallbackBool = (char)0; + Mock.glfwSwapBuffers_CallbackFunctionPointer = Callback; +} + +void glfwSwapBuffers_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSwapBuffers_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSwapBuffers_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSwapBuffers_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwSwapInterval(int interval) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwSwapInterval_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwSwapInterval); + cmock_call_instance = (CMOCK_glfwSwapInterval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwSwapInterval_CallInstance); + Mock.glfwSwapInterval_CallInstance = CMock_Guts_MemNext(Mock.glfwSwapInterval_CallInstance); + if (Mock.glfwSwapInterval_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.glfwSwapInterval_CallbackBool && + Mock.glfwSwapInterval_CallbackFunctionPointer != NULL) + { + Mock.glfwSwapInterval_CallbackFunctionPointer(interval, Mock.glfwSwapInterval_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_interval) + { + UNITY_SET_DETAILS(CMockString_glfwSwapInterval,CMockString_interval); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_interval, interval, cmock_line, CMockStringMismatch); + } + if (Mock.glfwSwapInterval_CallbackFunctionPointer != NULL) + { + Mock.glfwSwapInterval_CallbackFunctionPointer(interval, Mock.glfwSwapInterval_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_glfwSwapInterval(CMOCK_glfwSwapInterval_CALL_INSTANCE* cmock_call_instance, int interval); +void CMockExpectParameters_glfwSwapInterval(CMOCK_glfwSwapInterval_CALL_INSTANCE* cmock_call_instance, int interval) +{ + cmock_call_instance->Expected_interval = interval; + cmock_call_instance->IgnoreArg_interval = 0; +} + +void glfwSwapInterval_CMockIgnore(void) +{ + Mock.glfwSwapInterval_IgnoreBool = (char)1; +} + +void glfwSwapInterval_CMockStopIgnore(void) +{ + Mock.glfwSwapInterval_IgnoreBool = (char)0; +} + +void glfwSwapInterval_CMockExpect(UNITY_LINE_TYPE cmock_line, int interval) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwSwapInterval_CALL_INSTANCE)); + CMOCK_glfwSwapInterval_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSwapInterval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwSwapInterval_CallInstance = CMock_Guts_MemChain(Mock.glfwSwapInterval_CallInstance, cmock_guts_index); + Mock.glfwSwapInterval_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwSwapInterval(cmock_call_instance, interval); +} + +void glfwSwapInterval_AddCallback(CMOCK_glfwSwapInterval_CALLBACK Callback) +{ + Mock.glfwSwapInterval_IgnoreBool = (char)0; + Mock.glfwSwapInterval_CallbackBool = (char)1; + Mock.glfwSwapInterval_CallbackFunctionPointer = Callback; +} + +void glfwSwapInterval_Stub(CMOCK_glfwSwapInterval_CALLBACK Callback) +{ + Mock.glfwSwapInterval_IgnoreBool = (char)0; + Mock.glfwSwapInterval_CallbackBool = (char)0; + Mock.glfwSwapInterval_CallbackFunctionPointer = Callback; +} + +void glfwSwapInterval_CMockIgnoreArg_interval(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwSwapInterval_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwSwapInterval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwSwapInterval_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_interval = 1; +} + +int glfwExtensionSupported(const char* extension) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwExtensionSupported_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwExtensionSupported); + cmock_call_instance = (CMOCK_glfwExtensionSupported_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwExtensionSupported_CallInstance); + Mock.glfwExtensionSupported_CallInstance = CMock_Guts_MemNext(Mock.glfwExtensionSupported_CallInstance); + if (Mock.glfwExtensionSupported_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwExtensionSupported_FinalReturn; + Mock.glfwExtensionSupported_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwExtensionSupported_CallbackBool && + Mock.glfwExtensionSupported_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.glfwExtensionSupported_CallbackFunctionPointer(extension, Mock.glfwExtensionSupported_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_extension) + { + UNITY_SET_DETAILS(CMockString_glfwExtensionSupported,CMockString_extension); + UNITY_TEST_ASSERT_EQUAL_STRING(cmock_call_instance->Expected_extension, extension, cmock_line, CMockStringMismatch); + } + if (Mock.glfwExtensionSupported_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwExtensionSupported_CallbackFunctionPointer(extension, Mock.glfwExtensionSupported_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwExtensionSupported(CMOCK_glfwExtensionSupported_CALL_INSTANCE* cmock_call_instance, const char* extension); +void CMockExpectParameters_glfwExtensionSupported(CMOCK_glfwExtensionSupported_CALL_INSTANCE* cmock_call_instance, const char* extension) +{ + cmock_call_instance->Expected_extension = extension; + cmock_call_instance->IgnoreArg_extension = 0; +} + +void glfwExtensionSupported_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwExtensionSupported_CALL_INSTANCE)); + CMOCK_glfwExtensionSupported_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwExtensionSupported_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwExtensionSupported_CallInstance = CMock_Guts_MemChain(Mock.glfwExtensionSupported_CallInstance, cmock_guts_index); + Mock.glfwExtensionSupported_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwExtensionSupported_IgnoreBool = (char)1; +} + +void glfwExtensionSupported_CMockStopIgnore(void) +{ + if(Mock.glfwExtensionSupported_IgnoreBool) + Mock.glfwExtensionSupported_CallInstance = CMock_Guts_MemNext(Mock.glfwExtensionSupported_CallInstance); + Mock.glfwExtensionSupported_IgnoreBool = (char)0; +} + +void glfwExtensionSupported_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, const char* extension, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwExtensionSupported_CALL_INSTANCE)); + CMOCK_glfwExtensionSupported_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwExtensionSupported_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwExtensionSupported_CallInstance = CMock_Guts_MemChain(Mock.glfwExtensionSupported_CallInstance, cmock_guts_index); + Mock.glfwExtensionSupported_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwExtensionSupported(cmock_call_instance, extension); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwExtensionSupported_AddCallback(CMOCK_glfwExtensionSupported_CALLBACK Callback) +{ + Mock.glfwExtensionSupported_IgnoreBool = (char)0; + Mock.glfwExtensionSupported_CallbackBool = (char)1; + Mock.glfwExtensionSupported_CallbackFunctionPointer = Callback; +} + +void glfwExtensionSupported_Stub(CMOCK_glfwExtensionSupported_CALLBACK Callback) +{ + Mock.glfwExtensionSupported_IgnoreBool = (char)0; + Mock.glfwExtensionSupported_CallbackBool = (char)0; + Mock.glfwExtensionSupported_CallbackFunctionPointer = Callback; +} + +void glfwExtensionSupported_CMockIgnoreArg_extension(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwExtensionSupported_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwExtensionSupported_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwExtensionSupported_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_extension = 1; +} + +GLFWglproc glfwGetProcAddress(const char* procname) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetProcAddress_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetProcAddress); + cmock_call_instance = (CMOCK_glfwGetProcAddress_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetProcAddress_CallInstance); + Mock.glfwGetProcAddress_CallInstance = CMock_Guts_MemNext(Mock.glfwGetProcAddress_CallInstance); + if (Mock.glfwGetProcAddress_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetProcAddress_FinalReturn; + memcpy((void*)(&Mock.glfwGetProcAddress_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(GLFWglproc[sizeof(cmock_call_instance->ReturnVal) == sizeof(GLFWglproc) ? 1 : -1])); /* add GLFWglproc to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetProcAddress_CallbackBool && + Mock.glfwGetProcAddress_CallbackFunctionPointer != NULL) + { + GLFWglproc cmock_cb_ret = Mock.glfwGetProcAddress_CallbackFunctionPointer(procname, Mock.glfwGetProcAddress_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_procname) + { + UNITY_SET_DETAILS(CMockString_glfwGetProcAddress,CMockString_procname); + UNITY_TEST_ASSERT_EQUAL_STRING(cmock_call_instance->Expected_procname, procname, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetProcAddress_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetProcAddress_CallbackFunctionPointer(procname, Mock.glfwGetProcAddress_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwGetProcAddress(CMOCK_glfwGetProcAddress_CALL_INSTANCE* cmock_call_instance, const char* procname); +void CMockExpectParameters_glfwGetProcAddress(CMOCK_glfwGetProcAddress_CALL_INSTANCE* cmock_call_instance, const char* procname) +{ + cmock_call_instance->Expected_procname = procname; + cmock_call_instance->IgnoreArg_procname = 0; +} + +void glfwGetProcAddress_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWglproc cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetProcAddress_CALL_INSTANCE)); + CMOCK_glfwGetProcAddress_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetProcAddress_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetProcAddress_CallInstance = CMock_Guts_MemChain(Mock.glfwGetProcAddress_CallInstance, cmock_guts_index); + Mock.glfwGetProcAddress_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetProcAddress_IgnoreBool = (char)1; +} + +void glfwGetProcAddress_CMockStopIgnore(void) +{ + if(Mock.glfwGetProcAddress_IgnoreBool) + Mock.glfwGetProcAddress_CallInstance = CMock_Guts_MemNext(Mock.glfwGetProcAddress_CallInstance); + Mock.glfwGetProcAddress_IgnoreBool = (char)0; +} + +void glfwGetProcAddress_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, const char* procname, GLFWglproc cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetProcAddress_CALL_INSTANCE)); + CMOCK_glfwGetProcAddress_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetProcAddress_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetProcAddress_CallInstance = CMock_Guts_MemChain(Mock.glfwGetProcAddress_CallInstance, cmock_guts_index); + Mock.glfwGetProcAddress_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetProcAddress(cmock_call_instance, procname); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(GLFWglproc[sizeof(cmock_to_return) == sizeof(GLFWglproc) ? 1 : -1])); /* add GLFWglproc to :treat_as_array if this causes an error */ +} + +void glfwGetProcAddress_AddCallback(CMOCK_glfwGetProcAddress_CALLBACK Callback) +{ + Mock.glfwGetProcAddress_IgnoreBool = (char)0; + Mock.glfwGetProcAddress_CallbackBool = (char)1; + Mock.glfwGetProcAddress_CallbackFunctionPointer = Callback; +} + +void glfwGetProcAddress_Stub(CMOCK_glfwGetProcAddress_CALLBACK Callback) +{ + Mock.glfwGetProcAddress_IgnoreBool = (char)0; + Mock.glfwGetProcAddress_CallbackBool = (char)0; + Mock.glfwGetProcAddress_CallbackFunctionPointer = Callback; +} + +void glfwGetProcAddress_CMockIgnoreArg_procname(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetProcAddress_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetProcAddress_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetProcAddress_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_procname = 1; +} + +int glfwVulkanSupported(void) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwVulkanSupported_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwVulkanSupported); + cmock_call_instance = (CMOCK_glfwVulkanSupported_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwVulkanSupported_CallInstance); + Mock.glfwVulkanSupported_CallInstance = CMock_Guts_MemNext(Mock.glfwVulkanSupported_CallInstance); + if (Mock.glfwVulkanSupported_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwVulkanSupported_FinalReturn; + Mock.glfwVulkanSupported_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwVulkanSupported_CallbackBool && + Mock.glfwVulkanSupported_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.glfwVulkanSupported_CallbackFunctionPointer(Mock.glfwVulkanSupported_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (Mock.glfwVulkanSupported_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwVulkanSupported_CallbackFunctionPointer(Mock.glfwVulkanSupported_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void glfwVulkanSupported_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwVulkanSupported_CALL_INSTANCE)); + CMOCK_glfwVulkanSupported_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwVulkanSupported_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwVulkanSupported_CallInstance = CMock_Guts_MemChain(Mock.glfwVulkanSupported_CallInstance, cmock_guts_index); + Mock.glfwVulkanSupported_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwVulkanSupported_IgnoreBool = (char)1; +} + +void glfwVulkanSupported_CMockStopIgnore(void) +{ + if(Mock.glfwVulkanSupported_IgnoreBool) + Mock.glfwVulkanSupported_CallInstance = CMock_Guts_MemNext(Mock.glfwVulkanSupported_CallInstance); + Mock.glfwVulkanSupported_IgnoreBool = (char)0; +} + +void glfwVulkanSupported_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwVulkanSupported_CALL_INSTANCE)); + CMOCK_glfwVulkanSupported_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwVulkanSupported_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwVulkanSupported_CallInstance = CMock_Guts_MemChain(Mock.glfwVulkanSupported_CallInstance, cmock_guts_index); + Mock.glfwVulkanSupported_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwVulkanSupported_AddCallback(CMOCK_glfwVulkanSupported_CALLBACK Callback) +{ + Mock.glfwVulkanSupported_IgnoreBool = (char)0; + Mock.glfwVulkanSupported_CallbackBool = (char)1; + Mock.glfwVulkanSupported_CallbackFunctionPointer = Callback; +} + +void glfwVulkanSupported_Stub(CMOCK_glfwVulkanSupported_CALLBACK Callback) +{ + Mock.glfwVulkanSupported_IgnoreBool = (char)0; + Mock.glfwVulkanSupported_CallbackBool = (char)0; + Mock.glfwVulkanSupported_CallbackFunctionPointer = Callback; +} + +const char** glfwGetRequiredInstanceExtensions(uint32_t* count) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetRequiredInstanceExtensions_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetRequiredInstanceExtensions); + cmock_call_instance = (CMOCK_glfwGetRequiredInstanceExtensions_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetRequiredInstanceExtensions_CallInstance); + Mock.glfwGetRequiredInstanceExtensions_CallInstance = CMock_Guts_MemNext(Mock.glfwGetRequiredInstanceExtensions_CallInstance); + if (Mock.glfwGetRequiredInstanceExtensions_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetRequiredInstanceExtensions_FinalReturn; + Mock.glfwGetRequiredInstanceExtensions_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetRequiredInstanceExtensions_CallbackBool && + Mock.glfwGetRequiredInstanceExtensions_CallbackFunctionPointer != NULL) + { + const char** cmock_cb_ret = Mock.glfwGetRequiredInstanceExtensions_CallbackFunctionPointer(count, Mock.glfwGetRequiredInstanceExtensions_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_count) + { + UNITY_SET_DETAILS(CMockString_glfwGetRequiredInstanceExtensions,CMockString_count); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_count, count, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetRequiredInstanceExtensions_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetRequiredInstanceExtensions_CallbackFunctionPointer(count, Mock.glfwGetRequiredInstanceExtensions_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwGetRequiredInstanceExtensions(CMOCK_glfwGetRequiredInstanceExtensions_CALL_INSTANCE* cmock_call_instance, uint32_t* count); +void CMockExpectParameters_glfwGetRequiredInstanceExtensions(CMOCK_glfwGetRequiredInstanceExtensions_CALL_INSTANCE* cmock_call_instance, uint32_t* count) +{ + cmock_call_instance->Expected_count = count; + cmock_call_instance->IgnoreArg_count = 0; +} + +void glfwGetRequiredInstanceExtensions_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, const char** cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetRequiredInstanceExtensions_CALL_INSTANCE)); + CMOCK_glfwGetRequiredInstanceExtensions_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetRequiredInstanceExtensions_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetRequiredInstanceExtensions_CallInstance = CMock_Guts_MemChain(Mock.glfwGetRequiredInstanceExtensions_CallInstance, cmock_guts_index); + Mock.glfwGetRequiredInstanceExtensions_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetRequiredInstanceExtensions_IgnoreBool = (char)1; +} + +void glfwGetRequiredInstanceExtensions_CMockStopIgnore(void) +{ + if(Mock.glfwGetRequiredInstanceExtensions_IgnoreBool) + Mock.glfwGetRequiredInstanceExtensions_CallInstance = CMock_Guts_MemNext(Mock.glfwGetRequiredInstanceExtensions_CallInstance); + Mock.glfwGetRequiredInstanceExtensions_IgnoreBool = (char)0; +} + +void glfwGetRequiredInstanceExtensions_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, uint32_t* count, const char** cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetRequiredInstanceExtensions_CALL_INSTANCE)); + CMOCK_glfwGetRequiredInstanceExtensions_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetRequiredInstanceExtensions_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetRequiredInstanceExtensions_CallInstance = CMock_Guts_MemChain(Mock.glfwGetRequiredInstanceExtensions_CallInstance, cmock_guts_index); + Mock.glfwGetRequiredInstanceExtensions_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetRequiredInstanceExtensions(cmock_call_instance, count); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwGetRequiredInstanceExtensions_AddCallback(CMOCK_glfwGetRequiredInstanceExtensions_CALLBACK Callback) +{ + Mock.glfwGetRequiredInstanceExtensions_IgnoreBool = (char)0; + Mock.glfwGetRequiredInstanceExtensions_CallbackBool = (char)1; + Mock.glfwGetRequiredInstanceExtensions_CallbackFunctionPointer = Callback; +} + +void glfwGetRequiredInstanceExtensions_Stub(CMOCK_glfwGetRequiredInstanceExtensions_CALLBACK Callback) +{ + Mock.glfwGetRequiredInstanceExtensions_IgnoreBool = (char)0; + Mock.glfwGetRequiredInstanceExtensions_CallbackBool = (char)0; + Mock.glfwGetRequiredInstanceExtensions_CallbackFunctionPointer = Callback; +} + +void glfwGetRequiredInstanceExtensions_CMockIgnoreArg_count(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetRequiredInstanceExtensions_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetRequiredInstanceExtensions_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetRequiredInstanceExtensions_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_count = 1; +} + +GLFWvkproc glfwGetInstanceProcAddress(VkInstance instance, const char* procname) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetInstanceProcAddress_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetInstanceProcAddress); + cmock_call_instance = (CMOCK_glfwGetInstanceProcAddress_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetInstanceProcAddress_CallInstance); + Mock.glfwGetInstanceProcAddress_CallInstance = CMock_Guts_MemNext(Mock.glfwGetInstanceProcAddress_CallInstance); + if (Mock.glfwGetInstanceProcAddress_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetInstanceProcAddress_FinalReturn; + memcpy((void*)(&Mock.glfwGetInstanceProcAddress_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(GLFWvkproc[sizeof(cmock_call_instance->ReturnVal) == sizeof(GLFWvkproc) ? 1 : -1])); /* add GLFWvkproc to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetInstanceProcAddress_CallbackBool && + Mock.glfwGetInstanceProcAddress_CallbackFunctionPointer != NULL) + { + GLFWvkproc cmock_cb_ret = Mock.glfwGetInstanceProcAddress_CallbackFunctionPointer(instance, procname, Mock.glfwGetInstanceProcAddress_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_instance) + { + UNITY_SET_DETAILS(CMockString_glfwGetInstanceProcAddress,CMockString_instance); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), sizeof(VkInstance), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_procname) + { + UNITY_SET_DETAILS(CMockString_glfwGetInstanceProcAddress,CMockString_procname); + UNITY_TEST_ASSERT_EQUAL_STRING(cmock_call_instance->Expected_procname, procname, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetInstanceProcAddress_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetInstanceProcAddress_CallbackFunctionPointer(instance, procname, Mock.glfwGetInstanceProcAddress_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwGetInstanceProcAddress(CMOCK_glfwGetInstanceProcAddress_CALL_INSTANCE* cmock_call_instance, VkInstance instance, const char* procname); +void CMockExpectParameters_glfwGetInstanceProcAddress(CMOCK_glfwGetInstanceProcAddress_CALL_INSTANCE* cmock_call_instance, VkInstance instance, const char* procname) +{ + memcpy((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), + sizeof(VkInstance[sizeof(instance) == sizeof(VkInstance) ? 1 : -1])); /* add VkInstance to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_instance = 0; + cmock_call_instance->Expected_procname = procname; + cmock_call_instance->IgnoreArg_procname = 0; +} + +void glfwGetInstanceProcAddress_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWvkproc cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetInstanceProcAddress_CALL_INSTANCE)); + CMOCK_glfwGetInstanceProcAddress_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetInstanceProcAddress_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetInstanceProcAddress_CallInstance = CMock_Guts_MemChain(Mock.glfwGetInstanceProcAddress_CallInstance, cmock_guts_index); + Mock.glfwGetInstanceProcAddress_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetInstanceProcAddress_IgnoreBool = (char)1; +} + +void glfwGetInstanceProcAddress_CMockStopIgnore(void) +{ + if(Mock.glfwGetInstanceProcAddress_IgnoreBool) + Mock.glfwGetInstanceProcAddress_CallInstance = CMock_Guts_MemNext(Mock.glfwGetInstanceProcAddress_CallInstance); + Mock.glfwGetInstanceProcAddress_IgnoreBool = (char)0; +} + +void glfwGetInstanceProcAddress_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkInstance instance, const char* procname, GLFWvkproc cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetInstanceProcAddress_CALL_INSTANCE)); + CMOCK_glfwGetInstanceProcAddress_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetInstanceProcAddress_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetInstanceProcAddress_CallInstance = CMock_Guts_MemChain(Mock.glfwGetInstanceProcAddress_CallInstance, cmock_guts_index); + Mock.glfwGetInstanceProcAddress_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetInstanceProcAddress(cmock_call_instance, instance, procname); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(GLFWvkproc[sizeof(cmock_to_return) == sizeof(GLFWvkproc) ? 1 : -1])); /* add GLFWvkproc to :treat_as_array if this causes an error */ +} + +void glfwGetInstanceProcAddress_AddCallback(CMOCK_glfwGetInstanceProcAddress_CALLBACK Callback) +{ + Mock.glfwGetInstanceProcAddress_IgnoreBool = (char)0; + Mock.glfwGetInstanceProcAddress_CallbackBool = (char)1; + Mock.glfwGetInstanceProcAddress_CallbackFunctionPointer = Callback; +} + +void glfwGetInstanceProcAddress_Stub(CMOCK_glfwGetInstanceProcAddress_CALLBACK Callback) +{ + Mock.glfwGetInstanceProcAddress_IgnoreBool = (char)0; + Mock.glfwGetInstanceProcAddress_CallbackBool = (char)0; + Mock.glfwGetInstanceProcAddress_CallbackFunctionPointer = Callback; +} + +void glfwGetInstanceProcAddress_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetInstanceProcAddress_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetInstanceProcAddress_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetInstanceProcAddress_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_instance = 1; +} + +void glfwGetInstanceProcAddress_CMockIgnoreArg_procname(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetInstanceProcAddress_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetInstanceProcAddress_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetInstanceProcAddress_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_procname = 1; +} + +int glfwGetPhysicalDevicePresentationSupport(VkInstance instance, VkPhysicalDevice device, uint32_t queuefamily) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwGetPhysicalDevicePresentationSupport_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwGetPhysicalDevicePresentationSupport); + cmock_call_instance = (CMOCK_glfwGetPhysicalDevicePresentationSupport_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwGetPhysicalDevicePresentationSupport_CallInstance); + Mock.glfwGetPhysicalDevicePresentationSupport_CallInstance = CMock_Guts_MemNext(Mock.glfwGetPhysicalDevicePresentationSupport_CallInstance); + if (Mock.glfwGetPhysicalDevicePresentationSupport_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwGetPhysicalDevicePresentationSupport_FinalReturn; + Mock.glfwGetPhysicalDevicePresentationSupport_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwGetPhysicalDevicePresentationSupport_CallbackBool && + Mock.glfwGetPhysicalDevicePresentationSupport_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.glfwGetPhysicalDevicePresentationSupport_CallbackFunctionPointer(instance, device, queuefamily, Mock.glfwGetPhysicalDevicePresentationSupport_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_instance) + { + UNITY_SET_DETAILS(CMockString_glfwGetPhysicalDevicePresentationSupport,CMockString_instance); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), sizeof(VkInstance), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_glfwGetPhysicalDevicePresentationSupport,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queuefamily) + { + UNITY_SET_DETAILS(CMockString_glfwGetPhysicalDevicePresentationSupport,CMockString_queuefamily); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_queuefamily, queuefamily, cmock_line, CMockStringMismatch); + } + if (Mock.glfwGetPhysicalDevicePresentationSupport_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwGetPhysicalDevicePresentationSupport_CallbackFunctionPointer(instance, device, queuefamily, Mock.glfwGetPhysicalDevicePresentationSupport_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwGetPhysicalDevicePresentationSupport(CMOCK_glfwGetPhysicalDevicePresentationSupport_CALL_INSTANCE* cmock_call_instance, VkInstance instance, VkPhysicalDevice device, uint32_t queuefamily); +void CMockExpectParameters_glfwGetPhysicalDevicePresentationSupport(CMOCK_glfwGetPhysicalDevicePresentationSupport_CALL_INSTANCE* cmock_call_instance, VkInstance instance, VkPhysicalDevice device, uint32_t queuefamily) +{ + memcpy((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), + sizeof(VkInstance[sizeof(instance) == sizeof(VkInstance) ? 1 : -1])); /* add VkInstance to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_instance = 0; + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkPhysicalDevice[sizeof(device) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_queuefamily = queuefamily; + cmock_call_instance->IgnoreArg_queuefamily = 0; +} + +void glfwGetPhysicalDevicePresentationSupport_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetPhysicalDevicePresentationSupport_CALL_INSTANCE)); + CMOCK_glfwGetPhysicalDevicePresentationSupport_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetPhysicalDevicePresentationSupport_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetPhysicalDevicePresentationSupport_CallInstance = CMock_Guts_MemChain(Mock.glfwGetPhysicalDevicePresentationSupport_CallInstance, cmock_guts_index); + Mock.glfwGetPhysicalDevicePresentationSupport_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwGetPhysicalDevicePresentationSupport_IgnoreBool = (char)1; +} + +void glfwGetPhysicalDevicePresentationSupport_CMockStopIgnore(void) +{ + if(Mock.glfwGetPhysicalDevicePresentationSupport_IgnoreBool) + Mock.glfwGetPhysicalDevicePresentationSupport_CallInstance = CMock_Guts_MemNext(Mock.glfwGetPhysicalDevicePresentationSupport_CallInstance); + Mock.glfwGetPhysicalDevicePresentationSupport_IgnoreBool = (char)0; +} + +void glfwGetPhysicalDevicePresentationSupport_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkInstance instance, VkPhysicalDevice device, uint32_t queuefamily, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwGetPhysicalDevicePresentationSupport_CALL_INSTANCE)); + CMOCK_glfwGetPhysicalDevicePresentationSupport_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetPhysicalDevicePresentationSupport_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwGetPhysicalDevicePresentationSupport_CallInstance = CMock_Guts_MemChain(Mock.glfwGetPhysicalDevicePresentationSupport_CallInstance, cmock_guts_index); + Mock.glfwGetPhysicalDevicePresentationSupport_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwGetPhysicalDevicePresentationSupport(cmock_call_instance, instance, device, queuefamily); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void glfwGetPhysicalDevicePresentationSupport_AddCallback(CMOCK_glfwGetPhysicalDevicePresentationSupport_CALLBACK Callback) +{ + Mock.glfwGetPhysicalDevicePresentationSupport_IgnoreBool = (char)0; + Mock.glfwGetPhysicalDevicePresentationSupport_CallbackBool = (char)1; + Mock.glfwGetPhysicalDevicePresentationSupport_CallbackFunctionPointer = Callback; +} + +void glfwGetPhysicalDevicePresentationSupport_Stub(CMOCK_glfwGetPhysicalDevicePresentationSupport_CALLBACK Callback) +{ + Mock.glfwGetPhysicalDevicePresentationSupport_IgnoreBool = (char)0; + Mock.glfwGetPhysicalDevicePresentationSupport_CallbackBool = (char)0; + Mock.glfwGetPhysicalDevicePresentationSupport_CallbackFunctionPointer = Callback; +} + +void glfwGetPhysicalDevicePresentationSupport_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetPhysicalDevicePresentationSupport_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetPhysicalDevicePresentationSupport_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetPhysicalDevicePresentationSupport_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_instance = 1; +} + +void glfwGetPhysicalDevicePresentationSupport_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetPhysicalDevicePresentationSupport_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetPhysicalDevicePresentationSupport_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetPhysicalDevicePresentationSupport_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void glfwGetPhysicalDevicePresentationSupport_CMockIgnoreArg_queuefamily(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwGetPhysicalDevicePresentationSupport_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwGetPhysicalDevicePresentationSupport_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwGetPhysicalDevicePresentationSupport_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queuefamily = 1; +} + +VkResult glfwCreateWindowSurface(VkInstance instance, GLFWwindow* window, const VkAllocationCallbacks* allocator, VkSurfaceKHR* surface) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_glfwCreateWindowSurface_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_glfwCreateWindowSurface); + cmock_call_instance = (CMOCK_glfwCreateWindowSurface_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.glfwCreateWindowSurface_CallInstance); + Mock.glfwCreateWindowSurface_CallInstance = CMock_Guts_MemNext(Mock.glfwCreateWindowSurface_CallInstance); + if (Mock.glfwCreateWindowSurface_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.glfwCreateWindowSurface_FinalReturn; + memcpy((void*)(&Mock.glfwCreateWindowSurface_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.glfwCreateWindowSurface_CallbackBool && + Mock.glfwCreateWindowSurface_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.glfwCreateWindowSurface_CallbackFunctionPointer(instance, window, allocator, surface, Mock.glfwCreateWindowSurface_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->IgnoreArg_instance) + { + UNITY_SET_DETAILS(CMockString_glfwCreateWindowSurface,CMockString_instance); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), sizeof(VkInstance), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_window) + { + UNITY_SET_DETAILS(CMockString_glfwCreateWindowSurface,CMockString_window); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_window, window, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_allocator) + { + UNITY_SET_DETAILS(CMockString_glfwCreateWindowSurface,CMockString_allocator); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_allocator, allocator, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_surface) + { + UNITY_SET_DETAILS(CMockString_glfwCreateWindowSurface,CMockString_surface); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_surface, surface, cmock_line, CMockStringMismatch); + } + if (Mock.glfwCreateWindowSurface_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.glfwCreateWindowSurface_CallbackFunctionPointer(instance, window, allocator, surface, Mock.glfwCreateWindowSurface_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_glfwCreateWindowSurface(CMOCK_glfwCreateWindowSurface_CALL_INSTANCE* cmock_call_instance, VkInstance instance, GLFWwindow* window, const VkAllocationCallbacks* allocator, VkSurfaceKHR* surface); +void CMockExpectParameters_glfwCreateWindowSurface(CMOCK_glfwCreateWindowSurface_CALL_INSTANCE* cmock_call_instance, VkInstance instance, GLFWwindow* window, const VkAllocationCallbacks* allocator, VkSurfaceKHR* surface) +{ + memcpy((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), + sizeof(VkInstance[sizeof(instance) == sizeof(VkInstance) ? 1 : -1])); /* add VkInstance to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_instance = 0; + cmock_call_instance->Expected_window = window; + cmock_call_instance->IgnoreArg_window = 0; + cmock_call_instance->Expected_allocator = allocator; + cmock_call_instance->IgnoreArg_allocator = 0; + cmock_call_instance->Expected_surface = surface; + cmock_call_instance->IgnoreArg_surface = 0; +} + +void glfwCreateWindowSurface_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwCreateWindowSurface_CALL_INSTANCE)); + CMOCK_glfwCreateWindowSurface_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwCreateWindowSurface_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwCreateWindowSurface_CallInstance = CMock_Guts_MemChain(Mock.glfwCreateWindowSurface_CallInstance, cmock_guts_index); + Mock.glfwCreateWindowSurface_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.glfwCreateWindowSurface_IgnoreBool = (char)1; +} + +void glfwCreateWindowSurface_CMockStopIgnore(void) +{ + if(Mock.glfwCreateWindowSurface_IgnoreBool) + Mock.glfwCreateWindowSurface_CallInstance = CMock_Guts_MemNext(Mock.glfwCreateWindowSurface_CallInstance); + Mock.glfwCreateWindowSurface_IgnoreBool = (char)0; +} + +void glfwCreateWindowSurface_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkInstance instance, GLFWwindow* window, const VkAllocationCallbacks* allocator, VkSurfaceKHR* surface, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_glfwCreateWindowSurface_CALL_INSTANCE)); + CMOCK_glfwCreateWindowSurface_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwCreateWindowSurface_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.glfwCreateWindowSurface_CallInstance = CMock_Guts_MemChain(Mock.glfwCreateWindowSurface_CallInstance, cmock_guts_index); + Mock.glfwCreateWindowSurface_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + CMockExpectParameters_glfwCreateWindowSurface(cmock_call_instance, instance, window, allocator, surface); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void glfwCreateWindowSurface_AddCallback(CMOCK_glfwCreateWindowSurface_CALLBACK Callback) +{ + Mock.glfwCreateWindowSurface_IgnoreBool = (char)0; + Mock.glfwCreateWindowSurface_CallbackBool = (char)1; + Mock.glfwCreateWindowSurface_CallbackFunctionPointer = Callback; +} + +void glfwCreateWindowSurface_Stub(CMOCK_glfwCreateWindowSurface_CALLBACK Callback) +{ + Mock.glfwCreateWindowSurface_IgnoreBool = (char)0; + Mock.glfwCreateWindowSurface_CallbackBool = (char)0; + Mock.glfwCreateWindowSurface_CallbackFunctionPointer = Callback; +} + +void glfwCreateWindowSurface_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwCreateWindowSurface_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwCreateWindowSurface_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwCreateWindowSurface_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_instance = 1; +} + +void glfwCreateWindowSurface_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwCreateWindowSurface_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwCreateWindowSurface_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwCreateWindowSurface_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_window = 1; +} + +void glfwCreateWindowSurface_CMockIgnoreArg_allocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwCreateWindowSurface_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwCreateWindowSurface_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwCreateWindowSurface_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_allocator = 1; +} + +void glfwCreateWindowSurface_CMockIgnoreArg_surface(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_glfwCreateWindowSurface_CALL_INSTANCE* cmock_call_instance = (CMOCK_glfwCreateWindowSurface_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.glfwCreateWindowSurface_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_surface = 1; +} + diff --git a/tests/src/mocks/GLFW/Mockglfw3.h b/tests/src/mocks/GLFW/Mockglfw3.h new file mode 100644 index 00000000..313f0a24 --- /dev/null +++ b/tests/src/mocks/GLFW/Mockglfw3.h @@ -0,0 +1,1647 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ +#ifndef _MOCKGLFW3_H +#define _MOCKGLFW3_H + +#include "unity.h" +#include "vulkan/vulkan.h" +#include "GLFW/glfw3.h" + +/* Ignore the following warnings, since we are copying code */ +#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__) +#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0))) +#pragma GCC diagnostic push +#endif +#if !defined(__clang__) +#pragma GCC diagnostic ignored "-Wpragmas" +#endif +#pragma GCC diagnostic ignored "-Wunknown-pragmas" +#pragma GCC diagnostic ignored "-Wduplicate-decl-specifier" +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +void Mockglfw3_Init(void); +void Mockglfw3_Destroy(void); +void Mockglfw3_Verify(void); + + + + +#define glfwInit_IgnoreAndReturn(cmock_retval) glfwInit_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwInit_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define glfwInit_StopIgnore() glfwInit_CMockStopIgnore() +void glfwInit_CMockStopIgnore(void); +#define glfwInit_ExpectAndReturn(cmock_retval) glfwInit_CMockExpectAndReturn(__LINE__, cmock_retval) +void glfwInit_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +typedef int (* CMOCK_glfwInit_CALLBACK)(int cmock_num_calls); +void glfwInit_AddCallback(CMOCK_glfwInit_CALLBACK Callback); +void glfwInit_Stub(CMOCK_glfwInit_CALLBACK Callback); +#define glfwInit_StubWithCallback glfwInit_AddCallback +#define glfwTerminate_Ignore() glfwTerminate_CMockIgnore() +void glfwTerminate_CMockIgnore(void); +#define glfwTerminate_StopIgnore() glfwTerminate_CMockStopIgnore() +void glfwTerminate_CMockStopIgnore(void); +#define glfwTerminate_Expect() glfwTerminate_CMockExpect(__LINE__) +void glfwTerminate_CMockExpect(UNITY_LINE_TYPE cmock_line); +typedef void (* CMOCK_glfwTerminate_CALLBACK)(int cmock_num_calls); +void glfwTerminate_AddCallback(CMOCK_glfwTerminate_CALLBACK Callback); +void glfwTerminate_Stub(CMOCK_glfwTerminate_CALLBACK Callback); +#define glfwTerminate_StubWithCallback glfwTerminate_AddCallback +#define glfwInitHint_Ignore() glfwInitHint_CMockIgnore() +void glfwInitHint_CMockIgnore(void); +#define glfwInitHint_StopIgnore() glfwInitHint_CMockStopIgnore() +void glfwInitHint_CMockStopIgnore(void); +#define glfwInitHint_Expect(hint, value) glfwInitHint_CMockExpect(__LINE__, hint, value) +void glfwInitHint_CMockExpect(UNITY_LINE_TYPE cmock_line, int hint, int value); +typedef void (* CMOCK_glfwInitHint_CALLBACK)(int hint, int value, int cmock_num_calls); +void glfwInitHint_AddCallback(CMOCK_glfwInitHint_CALLBACK Callback); +void glfwInitHint_Stub(CMOCK_glfwInitHint_CALLBACK Callback); +#define glfwInitHint_StubWithCallback glfwInitHint_AddCallback +#define glfwInitHint_IgnoreArg_hint() glfwInitHint_CMockIgnoreArg_hint(__LINE__) +void glfwInitHint_CMockIgnoreArg_hint(UNITY_LINE_TYPE cmock_line); +#define glfwInitHint_IgnoreArg_value() glfwInitHint_CMockIgnoreArg_value(__LINE__) +void glfwInitHint_CMockIgnoreArg_value(UNITY_LINE_TYPE cmock_line); +#define glfwGetVersion_Ignore() glfwGetVersion_CMockIgnore() +void glfwGetVersion_CMockIgnore(void); +#define glfwGetVersion_StopIgnore() glfwGetVersion_CMockStopIgnore() +void glfwGetVersion_CMockStopIgnore(void); +#define glfwGetVersion_Expect(major, minor, rev) glfwGetVersion_CMockExpect(__LINE__, major, minor, rev) +void glfwGetVersion_CMockExpect(UNITY_LINE_TYPE cmock_line, int* major, int* minor, int* rev); +typedef void (* CMOCK_glfwGetVersion_CALLBACK)(int* major, int* minor, int* rev, int cmock_num_calls); +void glfwGetVersion_AddCallback(CMOCK_glfwGetVersion_CALLBACK Callback); +void glfwGetVersion_Stub(CMOCK_glfwGetVersion_CALLBACK Callback); +#define glfwGetVersion_StubWithCallback glfwGetVersion_AddCallback +#define glfwGetVersion_IgnoreArg_major() glfwGetVersion_CMockIgnoreArg_major(__LINE__) +void glfwGetVersion_CMockIgnoreArg_major(UNITY_LINE_TYPE cmock_line); +#define glfwGetVersion_IgnoreArg_minor() glfwGetVersion_CMockIgnoreArg_minor(__LINE__) +void glfwGetVersion_CMockIgnoreArg_minor(UNITY_LINE_TYPE cmock_line); +#define glfwGetVersion_IgnoreArg_rev() glfwGetVersion_CMockIgnoreArg_rev(__LINE__) +void glfwGetVersion_CMockIgnoreArg_rev(UNITY_LINE_TYPE cmock_line); +#define glfwGetVersionString_IgnoreAndReturn(cmock_retval) glfwGetVersionString_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetVersionString_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, const char* cmock_to_return); +#define glfwGetVersionString_StopIgnore() glfwGetVersionString_CMockStopIgnore() +void glfwGetVersionString_CMockStopIgnore(void); +#define glfwGetVersionString_ExpectAndReturn(cmock_retval) glfwGetVersionString_CMockExpectAndReturn(__LINE__, cmock_retval) +void glfwGetVersionString_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, const char* cmock_to_return); +typedef const char* (* CMOCK_glfwGetVersionString_CALLBACK)(int cmock_num_calls); +void glfwGetVersionString_AddCallback(CMOCK_glfwGetVersionString_CALLBACK Callback); +void glfwGetVersionString_Stub(CMOCK_glfwGetVersionString_CALLBACK Callback); +#define glfwGetVersionString_StubWithCallback glfwGetVersionString_AddCallback +#define glfwGetError_IgnoreAndReturn(cmock_retval) glfwGetError_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetError_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define glfwGetError_StopIgnore() glfwGetError_CMockStopIgnore() +void glfwGetError_CMockStopIgnore(void); +#define glfwGetError_ExpectAndReturn(description, cmock_retval) glfwGetError_CMockExpectAndReturn(__LINE__, description, cmock_retval) +void glfwGetError_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, const char** description, int cmock_to_return); +typedef int (* CMOCK_glfwGetError_CALLBACK)(const char** description, int cmock_num_calls); +void glfwGetError_AddCallback(CMOCK_glfwGetError_CALLBACK Callback); +void glfwGetError_Stub(CMOCK_glfwGetError_CALLBACK Callback); +#define glfwGetError_StubWithCallback glfwGetError_AddCallback +#define glfwGetError_IgnoreArg_description() glfwGetError_CMockIgnoreArg_description(__LINE__) +void glfwGetError_CMockIgnoreArg_description(UNITY_LINE_TYPE cmock_line); +#define glfwSetErrorCallback_IgnoreAndReturn(cmock_retval) glfwSetErrorCallback_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwSetErrorCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWerrorfun cmock_to_return); +#define glfwSetErrorCallback_StopIgnore() glfwSetErrorCallback_CMockStopIgnore() +void glfwSetErrorCallback_CMockStopIgnore(void); +#define glfwSetErrorCallback_ExpectAndReturn(callback, cmock_retval) glfwSetErrorCallback_CMockExpectAndReturn(__LINE__, callback, cmock_retval) +void glfwSetErrorCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWerrorfun callback, GLFWerrorfun cmock_to_return); +typedef GLFWerrorfun (* CMOCK_glfwSetErrorCallback_CALLBACK)(GLFWerrorfun callback, int cmock_num_calls); +void glfwSetErrorCallback_AddCallback(CMOCK_glfwSetErrorCallback_CALLBACK Callback); +void glfwSetErrorCallback_Stub(CMOCK_glfwSetErrorCallback_CALLBACK Callback); +#define glfwSetErrorCallback_StubWithCallback glfwSetErrorCallback_AddCallback +#define glfwSetErrorCallback_IgnoreArg_callback() glfwSetErrorCallback_CMockIgnoreArg_callback(__LINE__) +void glfwSetErrorCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line); +#define glfwGetMonitors_IgnoreAndReturn(cmock_retval) glfwGetMonitors_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetMonitors_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWmonitor** cmock_to_return); +#define glfwGetMonitors_StopIgnore() glfwGetMonitors_CMockStopIgnore() +void glfwGetMonitors_CMockStopIgnore(void); +#define glfwGetMonitors_ExpectAndReturn(count, cmock_retval) glfwGetMonitors_CMockExpectAndReturn(__LINE__, count, cmock_retval) +void glfwGetMonitors_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int* count, GLFWmonitor** cmock_to_return); +typedef GLFWmonitor** (* CMOCK_glfwGetMonitors_CALLBACK)(int* count, int cmock_num_calls); +void glfwGetMonitors_AddCallback(CMOCK_glfwGetMonitors_CALLBACK Callback); +void glfwGetMonitors_Stub(CMOCK_glfwGetMonitors_CALLBACK Callback); +#define glfwGetMonitors_StubWithCallback glfwGetMonitors_AddCallback +#define glfwGetMonitors_IgnoreArg_count() glfwGetMonitors_CMockIgnoreArg_count(__LINE__) +void glfwGetMonitors_CMockIgnoreArg_count(UNITY_LINE_TYPE cmock_line); +#define glfwGetPrimaryMonitor_IgnoreAndReturn(cmock_retval) glfwGetPrimaryMonitor_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetPrimaryMonitor_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWmonitor* cmock_to_return); +#define glfwGetPrimaryMonitor_StopIgnore() glfwGetPrimaryMonitor_CMockStopIgnore() +void glfwGetPrimaryMonitor_CMockStopIgnore(void); +#define glfwGetPrimaryMonitor_ExpectAndReturn(cmock_retval) glfwGetPrimaryMonitor_CMockExpectAndReturn(__LINE__, cmock_retval) +void glfwGetPrimaryMonitor_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWmonitor* cmock_to_return); +typedef GLFWmonitor* (* CMOCK_glfwGetPrimaryMonitor_CALLBACK)(int cmock_num_calls); +void glfwGetPrimaryMonitor_AddCallback(CMOCK_glfwGetPrimaryMonitor_CALLBACK Callback); +void glfwGetPrimaryMonitor_Stub(CMOCK_glfwGetPrimaryMonitor_CALLBACK Callback); +#define glfwGetPrimaryMonitor_StubWithCallback glfwGetPrimaryMonitor_AddCallback +#define glfwGetMonitorPos_Ignore() glfwGetMonitorPos_CMockIgnore() +void glfwGetMonitorPos_CMockIgnore(void); +#define glfwGetMonitorPos_StopIgnore() glfwGetMonitorPos_CMockStopIgnore() +void glfwGetMonitorPos_CMockStopIgnore(void); +#define glfwGetMonitorPos_Expect(monitor, xpos, ypos) glfwGetMonitorPos_CMockExpect(__LINE__, monitor, xpos, ypos) +void glfwGetMonitorPos_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWmonitor* monitor, int* xpos, int* ypos); +typedef void (* CMOCK_glfwGetMonitorPos_CALLBACK)(GLFWmonitor* monitor, int* xpos, int* ypos, int cmock_num_calls); +void glfwGetMonitorPos_AddCallback(CMOCK_glfwGetMonitorPos_CALLBACK Callback); +void glfwGetMonitorPos_Stub(CMOCK_glfwGetMonitorPos_CALLBACK Callback); +#define glfwGetMonitorPos_StubWithCallback glfwGetMonitorPos_AddCallback +#define glfwGetMonitorPos_IgnoreArg_monitor() glfwGetMonitorPos_CMockIgnoreArg_monitor(__LINE__) +void glfwGetMonitorPos_CMockIgnoreArg_monitor(UNITY_LINE_TYPE cmock_line); +#define glfwGetMonitorPos_IgnoreArg_xpos() glfwGetMonitorPos_CMockIgnoreArg_xpos(__LINE__) +void glfwGetMonitorPos_CMockIgnoreArg_xpos(UNITY_LINE_TYPE cmock_line); +#define glfwGetMonitorPos_IgnoreArg_ypos() glfwGetMonitorPos_CMockIgnoreArg_ypos(__LINE__) +void glfwGetMonitorPos_CMockIgnoreArg_ypos(UNITY_LINE_TYPE cmock_line); +#define glfwGetMonitorWorkarea_Ignore() glfwGetMonitorWorkarea_CMockIgnore() +void glfwGetMonitorWorkarea_CMockIgnore(void); +#define glfwGetMonitorWorkarea_StopIgnore() glfwGetMonitorWorkarea_CMockStopIgnore() +void glfwGetMonitorWorkarea_CMockStopIgnore(void); +#define glfwGetMonitorWorkarea_Expect(monitor, xpos, ypos, width, height) glfwGetMonitorWorkarea_CMockExpect(__LINE__, monitor, xpos, ypos, width, height) +void glfwGetMonitorWorkarea_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWmonitor* monitor, int* xpos, int* ypos, int* width, int* height); +typedef void (* CMOCK_glfwGetMonitorWorkarea_CALLBACK)(GLFWmonitor* monitor, int* xpos, int* ypos, int* width, int* height, int cmock_num_calls); +void glfwGetMonitorWorkarea_AddCallback(CMOCK_glfwGetMonitorWorkarea_CALLBACK Callback); +void glfwGetMonitorWorkarea_Stub(CMOCK_glfwGetMonitorWorkarea_CALLBACK Callback); +#define glfwGetMonitorWorkarea_StubWithCallback glfwGetMonitorWorkarea_AddCallback +#define glfwGetMonitorWorkarea_IgnoreArg_monitor() glfwGetMonitorWorkarea_CMockIgnoreArg_monitor(__LINE__) +void glfwGetMonitorWorkarea_CMockIgnoreArg_monitor(UNITY_LINE_TYPE cmock_line); +#define glfwGetMonitorWorkarea_IgnoreArg_xpos() glfwGetMonitorWorkarea_CMockIgnoreArg_xpos(__LINE__) +void glfwGetMonitorWorkarea_CMockIgnoreArg_xpos(UNITY_LINE_TYPE cmock_line); +#define glfwGetMonitorWorkarea_IgnoreArg_ypos() glfwGetMonitorWorkarea_CMockIgnoreArg_ypos(__LINE__) +void glfwGetMonitorWorkarea_CMockIgnoreArg_ypos(UNITY_LINE_TYPE cmock_line); +#define glfwGetMonitorWorkarea_IgnoreArg_width() glfwGetMonitorWorkarea_CMockIgnoreArg_width(__LINE__) +void glfwGetMonitorWorkarea_CMockIgnoreArg_width(UNITY_LINE_TYPE cmock_line); +#define glfwGetMonitorWorkarea_IgnoreArg_height() glfwGetMonitorWorkarea_CMockIgnoreArg_height(__LINE__) +void glfwGetMonitorWorkarea_CMockIgnoreArg_height(UNITY_LINE_TYPE cmock_line); +#define glfwGetMonitorPhysicalSize_Ignore() glfwGetMonitorPhysicalSize_CMockIgnore() +void glfwGetMonitorPhysicalSize_CMockIgnore(void); +#define glfwGetMonitorPhysicalSize_StopIgnore() glfwGetMonitorPhysicalSize_CMockStopIgnore() +void glfwGetMonitorPhysicalSize_CMockStopIgnore(void); +#define glfwGetMonitorPhysicalSize_Expect(monitor, widthMM, heightMM) glfwGetMonitorPhysicalSize_CMockExpect(__LINE__, monitor, widthMM, heightMM) +void glfwGetMonitorPhysicalSize_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWmonitor* monitor, int* widthMM, int* heightMM); +typedef void (* CMOCK_glfwGetMonitorPhysicalSize_CALLBACK)(GLFWmonitor* monitor, int* widthMM, int* heightMM, int cmock_num_calls); +void glfwGetMonitorPhysicalSize_AddCallback(CMOCK_glfwGetMonitorPhysicalSize_CALLBACK Callback); +void glfwGetMonitorPhysicalSize_Stub(CMOCK_glfwGetMonitorPhysicalSize_CALLBACK Callback); +#define glfwGetMonitorPhysicalSize_StubWithCallback glfwGetMonitorPhysicalSize_AddCallback +#define glfwGetMonitorPhysicalSize_IgnoreArg_monitor() glfwGetMonitorPhysicalSize_CMockIgnoreArg_monitor(__LINE__) +void glfwGetMonitorPhysicalSize_CMockIgnoreArg_monitor(UNITY_LINE_TYPE cmock_line); +#define glfwGetMonitorPhysicalSize_IgnoreArg_widthMM() glfwGetMonitorPhysicalSize_CMockIgnoreArg_widthMM(__LINE__) +void glfwGetMonitorPhysicalSize_CMockIgnoreArg_widthMM(UNITY_LINE_TYPE cmock_line); +#define glfwGetMonitorPhysicalSize_IgnoreArg_heightMM() glfwGetMonitorPhysicalSize_CMockIgnoreArg_heightMM(__LINE__) +void glfwGetMonitorPhysicalSize_CMockIgnoreArg_heightMM(UNITY_LINE_TYPE cmock_line); +#define glfwGetMonitorContentScale_Ignore() glfwGetMonitorContentScale_CMockIgnore() +void glfwGetMonitorContentScale_CMockIgnore(void); +#define glfwGetMonitorContentScale_StopIgnore() glfwGetMonitorContentScale_CMockStopIgnore() +void glfwGetMonitorContentScale_CMockStopIgnore(void); +#define glfwGetMonitorContentScale_Expect(monitor, xscale, yscale) glfwGetMonitorContentScale_CMockExpect(__LINE__, monitor, xscale, yscale) +void glfwGetMonitorContentScale_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWmonitor* monitor, float* xscale, float* yscale); +typedef void (* CMOCK_glfwGetMonitorContentScale_CALLBACK)(GLFWmonitor* monitor, float* xscale, float* yscale, int cmock_num_calls); +void glfwGetMonitorContentScale_AddCallback(CMOCK_glfwGetMonitorContentScale_CALLBACK Callback); +void glfwGetMonitorContentScale_Stub(CMOCK_glfwGetMonitorContentScale_CALLBACK Callback); +#define glfwGetMonitorContentScale_StubWithCallback glfwGetMonitorContentScale_AddCallback +#define glfwGetMonitorContentScale_IgnoreArg_monitor() glfwGetMonitorContentScale_CMockIgnoreArg_monitor(__LINE__) +void glfwGetMonitorContentScale_CMockIgnoreArg_monitor(UNITY_LINE_TYPE cmock_line); +#define glfwGetMonitorContentScale_IgnoreArg_xscale() glfwGetMonitorContentScale_CMockIgnoreArg_xscale(__LINE__) +void glfwGetMonitorContentScale_CMockIgnoreArg_xscale(UNITY_LINE_TYPE cmock_line); +#define glfwGetMonitorContentScale_IgnoreArg_yscale() glfwGetMonitorContentScale_CMockIgnoreArg_yscale(__LINE__) +void glfwGetMonitorContentScale_CMockIgnoreArg_yscale(UNITY_LINE_TYPE cmock_line); +#define glfwGetMonitorName_IgnoreAndReturn(cmock_retval) glfwGetMonitorName_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetMonitorName_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, const char* cmock_to_return); +#define glfwGetMonitorName_StopIgnore() glfwGetMonitorName_CMockStopIgnore() +void glfwGetMonitorName_CMockStopIgnore(void); +#define glfwGetMonitorName_ExpectAndReturn(monitor, cmock_retval) glfwGetMonitorName_CMockExpectAndReturn(__LINE__, monitor, cmock_retval) +void glfwGetMonitorName_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWmonitor* monitor, const char* cmock_to_return); +typedef const char* (* CMOCK_glfwGetMonitorName_CALLBACK)(GLFWmonitor* monitor, int cmock_num_calls); +void glfwGetMonitorName_AddCallback(CMOCK_glfwGetMonitorName_CALLBACK Callback); +void glfwGetMonitorName_Stub(CMOCK_glfwGetMonitorName_CALLBACK Callback); +#define glfwGetMonitorName_StubWithCallback glfwGetMonitorName_AddCallback +#define glfwGetMonitorName_IgnoreArg_monitor() glfwGetMonitorName_CMockIgnoreArg_monitor(__LINE__) +void glfwGetMonitorName_CMockIgnoreArg_monitor(UNITY_LINE_TYPE cmock_line); +#define glfwSetMonitorUserPointer_Ignore() glfwSetMonitorUserPointer_CMockIgnore() +void glfwSetMonitorUserPointer_CMockIgnore(void); +#define glfwSetMonitorUserPointer_StopIgnore() glfwSetMonitorUserPointer_CMockStopIgnore() +void glfwSetMonitorUserPointer_CMockStopIgnore(void); +#define glfwSetMonitorUserPointer_Expect(monitor, pointer) glfwSetMonitorUserPointer_CMockExpect(__LINE__, monitor, pointer) +void glfwSetMonitorUserPointer_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWmonitor* monitor, void* pointer); +typedef void (* CMOCK_glfwSetMonitorUserPointer_CALLBACK)(GLFWmonitor* monitor, void* pointer, int cmock_num_calls); +void glfwSetMonitorUserPointer_AddCallback(CMOCK_glfwSetMonitorUserPointer_CALLBACK Callback); +void glfwSetMonitorUserPointer_Stub(CMOCK_glfwSetMonitorUserPointer_CALLBACK Callback); +#define glfwSetMonitorUserPointer_StubWithCallback glfwSetMonitorUserPointer_AddCallback +#define glfwSetMonitorUserPointer_IgnoreArg_monitor() glfwSetMonitorUserPointer_CMockIgnoreArg_monitor(__LINE__) +void glfwSetMonitorUserPointer_CMockIgnoreArg_monitor(UNITY_LINE_TYPE cmock_line); +#define glfwSetMonitorUserPointer_IgnoreArg_pointer() glfwSetMonitorUserPointer_CMockIgnoreArg_pointer(__LINE__) +void glfwSetMonitorUserPointer_CMockIgnoreArg_pointer(UNITY_LINE_TYPE cmock_line); +#define glfwGetMonitorUserPointer_IgnoreAndReturn(cmock_retval) glfwGetMonitorUserPointer_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetMonitorUserPointer_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, void* cmock_to_return); +#define glfwGetMonitorUserPointer_StopIgnore() glfwGetMonitorUserPointer_CMockStopIgnore() +void glfwGetMonitorUserPointer_CMockStopIgnore(void); +#define glfwGetMonitorUserPointer_ExpectAndReturn(monitor, cmock_retval) glfwGetMonitorUserPointer_CMockExpectAndReturn(__LINE__, monitor, cmock_retval) +void glfwGetMonitorUserPointer_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWmonitor* monitor, void* cmock_to_return); +typedef void* (* CMOCK_glfwGetMonitorUserPointer_CALLBACK)(GLFWmonitor* monitor, int cmock_num_calls); +void glfwGetMonitorUserPointer_AddCallback(CMOCK_glfwGetMonitorUserPointer_CALLBACK Callback); +void glfwGetMonitorUserPointer_Stub(CMOCK_glfwGetMonitorUserPointer_CALLBACK Callback); +#define glfwGetMonitorUserPointer_StubWithCallback glfwGetMonitorUserPointer_AddCallback +#define glfwGetMonitorUserPointer_IgnoreArg_monitor() glfwGetMonitorUserPointer_CMockIgnoreArg_monitor(__LINE__) +void glfwGetMonitorUserPointer_CMockIgnoreArg_monitor(UNITY_LINE_TYPE cmock_line); +#define glfwSetMonitorCallback_IgnoreAndReturn(cmock_retval) glfwSetMonitorCallback_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwSetMonitorCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWmonitorfun cmock_to_return); +#define glfwSetMonitorCallback_StopIgnore() glfwSetMonitorCallback_CMockStopIgnore() +void glfwSetMonitorCallback_CMockStopIgnore(void); +#define glfwSetMonitorCallback_ExpectAndReturn(callback, cmock_retval) glfwSetMonitorCallback_CMockExpectAndReturn(__LINE__, callback, cmock_retval) +void glfwSetMonitorCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWmonitorfun callback, GLFWmonitorfun cmock_to_return); +typedef GLFWmonitorfun (* CMOCK_glfwSetMonitorCallback_CALLBACK)(GLFWmonitorfun callback, int cmock_num_calls); +void glfwSetMonitorCallback_AddCallback(CMOCK_glfwSetMonitorCallback_CALLBACK Callback); +void glfwSetMonitorCallback_Stub(CMOCK_glfwSetMonitorCallback_CALLBACK Callback); +#define glfwSetMonitorCallback_StubWithCallback glfwSetMonitorCallback_AddCallback +#define glfwSetMonitorCallback_IgnoreArg_callback() glfwSetMonitorCallback_CMockIgnoreArg_callback(__LINE__) +void glfwSetMonitorCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line); +#define glfwGetVideoModes_IgnoreAndReturn(cmock_retval) glfwGetVideoModes_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetVideoModes_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, const GLFWvidmode* cmock_to_return); +#define glfwGetVideoModes_StopIgnore() glfwGetVideoModes_CMockStopIgnore() +void glfwGetVideoModes_CMockStopIgnore(void); +#define glfwGetVideoModes_ExpectAndReturn(monitor, count, cmock_retval) glfwGetVideoModes_CMockExpectAndReturn(__LINE__, monitor, count, cmock_retval) +void glfwGetVideoModes_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWmonitor* monitor, int* count, const GLFWvidmode* cmock_to_return); +typedef const GLFWvidmode* (* CMOCK_glfwGetVideoModes_CALLBACK)(GLFWmonitor* monitor, int* count, int cmock_num_calls); +void glfwGetVideoModes_AddCallback(CMOCK_glfwGetVideoModes_CALLBACK Callback); +void glfwGetVideoModes_Stub(CMOCK_glfwGetVideoModes_CALLBACK Callback); +#define glfwGetVideoModes_StubWithCallback glfwGetVideoModes_AddCallback +#define glfwGetVideoModes_IgnoreArg_monitor() glfwGetVideoModes_CMockIgnoreArg_monitor(__LINE__) +void glfwGetVideoModes_CMockIgnoreArg_monitor(UNITY_LINE_TYPE cmock_line); +#define glfwGetVideoModes_IgnoreArg_count() glfwGetVideoModes_CMockIgnoreArg_count(__LINE__) +void glfwGetVideoModes_CMockIgnoreArg_count(UNITY_LINE_TYPE cmock_line); +#define glfwGetVideoMode_IgnoreAndReturn(cmock_retval) glfwGetVideoMode_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetVideoMode_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, const GLFWvidmode* cmock_to_return); +#define glfwGetVideoMode_StopIgnore() glfwGetVideoMode_CMockStopIgnore() +void glfwGetVideoMode_CMockStopIgnore(void); +#define glfwGetVideoMode_ExpectAndReturn(monitor, cmock_retval) glfwGetVideoMode_CMockExpectAndReturn(__LINE__, monitor, cmock_retval) +void glfwGetVideoMode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWmonitor* monitor, const GLFWvidmode* cmock_to_return); +typedef const GLFWvidmode* (* CMOCK_glfwGetVideoMode_CALLBACK)(GLFWmonitor* monitor, int cmock_num_calls); +void glfwGetVideoMode_AddCallback(CMOCK_glfwGetVideoMode_CALLBACK Callback); +void glfwGetVideoMode_Stub(CMOCK_glfwGetVideoMode_CALLBACK Callback); +#define glfwGetVideoMode_StubWithCallback glfwGetVideoMode_AddCallback +#define glfwGetVideoMode_IgnoreArg_monitor() glfwGetVideoMode_CMockIgnoreArg_monitor(__LINE__) +void glfwGetVideoMode_CMockIgnoreArg_monitor(UNITY_LINE_TYPE cmock_line); +#define glfwSetGamma_Ignore() glfwSetGamma_CMockIgnore() +void glfwSetGamma_CMockIgnore(void); +#define glfwSetGamma_StopIgnore() glfwSetGamma_CMockStopIgnore() +void glfwSetGamma_CMockStopIgnore(void); +#define glfwSetGamma_Expect(monitor, gamma) glfwSetGamma_CMockExpect(__LINE__, monitor, gamma) +void glfwSetGamma_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWmonitor* monitor, float gamma); +typedef void (* CMOCK_glfwSetGamma_CALLBACK)(GLFWmonitor* monitor, float gamma, int cmock_num_calls); +void glfwSetGamma_AddCallback(CMOCK_glfwSetGamma_CALLBACK Callback); +void glfwSetGamma_Stub(CMOCK_glfwSetGamma_CALLBACK Callback); +#define glfwSetGamma_StubWithCallback glfwSetGamma_AddCallback +#define glfwSetGamma_IgnoreArg_monitor() glfwSetGamma_CMockIgnoreArg_monitor(__LINE__) +void glfwSetGamma_CMockIgnoreArg_monitor(UNITY_LINE_TYPE cmock_line); +#define glfwSetGamma_IgnoreArg_gamma() glfwSetGamma_CMockIgnoreArg_gamma(__LINE__) +void glfwSetGamma_CMockIgnoreArg_gamma(UNITY_LINE_TYPE cmock_line); +#define glfwGetGammaRamp_IgnoreAndReturn(cmock_retval) glfwGetGammaRamp_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetGammaRamp_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, const GLFWgammaramp* cmock_to_return); +#define glfwGetGammaRamp_StopIgnore() glfwGetGammaRamp_CMockStopIgnore() +void glfwGetGammaRamp_CMockStopIgnore(void); +#define glfwGetGammaRamp_ExpectAndReturn(monitor, cmock_retval) glfwGetGammaRamp_CMockExpectAndReturn(__LINE__, monitor, cmock_retval) +void glfwGetGammaRamp_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWmonitor* monitor, const GLFWgammaramp* cmock_to_return); +typedef const GLFWgammaramp* (* CMOCK_glfwGetGammaRamp_CALLBACK)(GLFWmonitor* monitor, int cmock_num_calls); +void glfwGetGammaRamp_AddCallback(CMOCK_glfwGetGammaRamp_CALLBACK Callback); +void glfwGetGammaRamp_Stub(CMOCK_glfwGetGammaRamp_CALLBACK Callback); +#define glfwGetGammaRamp_StubWithCallback glfwGetGammaRamp_AddCallback +#define glfwGetGammaRamp_IgnoreArg_monitor() glfwGetGammaRamp_CMockIgnoreArg_monitor(__LINE__) +void glfwGetGammaRamp_CMockIgnoreArg_monitor(UNITY_LINE_TYPE cmock_line); +#define glfwSetGammaRamp_Ignore() glfwSetGammaRamp_CMockIgnore() +void glfwSetGammaRamp_CMockIgnore(void); +#define glfwSetGammaRamp_StopIgnore() glfwSetGammaRamp_CMockStopIgnore() +void glfwSetGammaRamp_CMockStopIgnore(void); +#define glfwSetGammaRamp_Expect(monitor, ramp) glfwSetGammaRamp_CMockExpect(__LINE__, monitor, ramp) +void glfwSetGammaRamp_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWmonitor* monitor, const GLFWgammaramp* ramp); +typedef void (* CMOCK_glfwSetGammaRamp_CALLBACK)(GLFWmonitor* monitor, const GLFWgammaramp* ramp, int cmock_num_calls); +void glfwSetGammaRamp_AddCallback(CMOCK_glfwSetGammaRamp_CALLBACK Callback); +void glfwSetGammaRamp_Stub(CMOCK_glfwSetGammaRamp_CALLBACK Callback); +#define glfwSetGammaRamp_StubWithCallback glfwSetGammaRamp_AddCallback +#define glfwSetGammaRamp_IgnoreArg_monitor() glfwSetGammaRamp_CMockIgnoreArg_monitor(__LINE__) +void glfwSetGammaRamp_CMockIgnoreArg_monitor(UNITY_LINE_TYPE cmock_line); +#define glfwSetGammaRamp_IgnoreArg_ramp() glfwSetGammaRamp_CMockIgnoreArg_ramp(__LINE__) +void glfwSetGammaRamp_CMockIgnoreArg_ramp(UNITY_LINE_TYPE cmock_line); +#define glfwDefaultWindowHints_Ignore() glfwDefaultWindowHints_CMockIgnore() +void glfwDefaultWindowHints_CMockIgnore(void); +#define glfwDefaultWindowHints_StopIgnore() glfwDefaultWindowHints_CMockStopIgnore() +void glfwDefaultWindowHints_CMockStopIgnore(void); +#define glfwDefaultWindowHints_Expect() glfwDefaultWindowHints_CMockExpect(__LINE__) +void glfwDefaultWindowHints_CMockExpect(UNITY_LINE_TYPE cmock_line); +typedef void (* CMOCK_glfwDefaultWindowHints_CALLBACK)(int cmock_num_calls); +void glfwDefaultWindowHints_AddCallback(CMOCK_glfwDefaultWindowHints_CALLBACK Callback); +void glfwDefaultWindowHints_Stub(CMOCK_glfwDefaultWindowHints_CALLBACK Callback); +#define glfwDefaultWindowHints_StubWithCallback glfwDefaultWindowHints_AddCallback +#define glfwWindowHint_Ignore() glfwWindowHint_CMockIgnore() +void glfwWindowHint_CMockIgnore(void); +#define glfwWindowHint_StopIgnore() glfwWindowHint_CMockStopIgnore() +void glfwWindowHint_CMockStopIgnore(void); +#define glfwWindowHint_Expect(hint, value) glfwWindowHint_CMockExpect(__LINE__, hint, value) +void glfwWindowHint_CMockExpect(UNITY_LINE_TYPE cmock_line, int hint, int value); +typedef void (* CMOCK_glfwWindowHint_CALLBACK)(int hint, int value, int cmock_num_calls); +void glfwWindowHint_AddCallback(CMOCK_glfwWindowHint_CALLBACK Callback); +void glfwWindowHint_Stub(CMOCK_glfwWindowHint_CALLBACK Callback); +#define glfwWindowHint_StubWithCallback glfwWindowHint_AddCallback +#define glfwWindowHint_IgnoreArg_hint() glfwWindowHint_CMockIgnoreArg_hint(__LINE__) +void glfwWindowHint_CMockIgnoreArg_hint(UNITY_LINE_TYPE cmock_line); +#define glfwWindowHint_IgnoreArg_value() glfwWindowHint_CMockIgnoreArg_value(__LINE__) +void glfwWindowHint_CMockIgnoreArg_value(UNITY_LINE_TYPE cmock_line); +#define glfwWindowHintString_Ignore() glfwWindowHintString_CMockIgnore() +void glfwWindowHintString_CMockIgnore(void); +#define glfwWindowHintString_StopIgnore() glfwWindowHintString_CMockStopIgnore() +void glfwWindowHintString_CMockStopIgnore(void); +#define glfwWindowHintString_Expect(hint, value) glfwWindowHintString_CMockExpect(__LINE__, hint, value) +void glfwWindowHintString_CMockExpect(UNITY_LINE_TYPE cmock_line, int hint, const char* value); +typedef void (* CMOCK_glfwWindowHintString_CALLBACK)(int hint, const char* value, int cmock_num_calls); +void glfwWindowHintString_AddCallback(CMOCK_glfwWindowHintString_CALLBACK Callback); +void glfwWindowHintString_Stub(CMOCK_glfwWindowHintString_CALLBACK Callback); +#define glfwWindowHintString_StubWithCallback glfwWindowHintString_AddCallback +#define glfwWindowHintString_IgnoreArg_hint() glfwWindowHintString_CMockIgnoreArg_hint(__LINE__) +void glfwWindowHintString_CMockIgnoreArg_hint(UNITY_LINE_TYPE cmock_line); +#define glfwWindowHintString_IgnoreArg_value() glfwWindowHintString_CMockIgnoreArg_value(__LINE__) +void glfwWindowHintString_CMockIgnoreArg_value(UNITY_LINE_TYPE cmock_line); +#define glfwCreateWindow_IgnoreAndReturn(cmock_retval) glfwCreateWindow_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwCreateWindow_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* cmock_to_return); +#define glfwCreateWindow_StopIgnore() glfwCreateWindow_CMockStopIgnore() +void glfwCreateWindow_CMockStopIgnore(void); +#define glfwCreateWindow_ExpectAndReturn(width, height, title, monitor, share, cmock_retval) glfwCreateWindow_CMockExpectAndReturn(__LINE__, width, height, title, monitor, share, cmock_retval) +void glfwCreateWindow_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int width, int height, const char* title, GLFWmonitor* monitor, GLFWwindow* share, GLFWwindow* cmock_to_return); +typedef GLFWwindow* (* CMOCK_glfwCreateWindow_CALLBACK)(int width, int height, const char* title, GLFWmonitor* monitor, GLFWwindow* share, int cmock_num_calls); +void glfwCreateWindow_AddCallback(CMOCK_glfwCreateWindow_CALLBACK Callback); +void glfwCreateWindow_Stub(CMOCK_glfwCreateWindow_CALLBACK Callback); +#define glfwCreateWindow_StubWithCallback glfwCreateWindow_AddCallback +#define glfwCreateWindow_IgnoreArg_width() glfwCreateWindow_CMockIgnoreArg_width(__LINE__) +void glfwCreateWindow_CMockIgnoreArg_width(UNITY_LINE_TYPE cmock_line); +#define glfwCreateWindow_IgnoreArg_height() glfwCreateWindow_CMockIgnoreArg_height(__LINE__) +void glfwCreateWindow_CMockIgnoreArg_height(UNITY_LINE_TYPE cmock_line); +#define glfwCreateWindow_IgnoreArg_title() glfwCreateWindow_CMockIgnoreArg_title(__LINE__) +void glfwCreateWindow_CMockIgnoreArg_title(UNITY_LINE_TYPE cmock_line); +#define glfwCreateWindow_IgnoreArg_monitor() glfwCreateWindow_CMockIgnoreArg_monitor(__LINE__) +void glfwCreateWindow_CMockIgnoreArg_monitor(UNITY_LINE_TYPE cmock_line); +#define glfwCreateWindow_IgnoreArg_share() glfwCreateWindow_CMockIgnoreArg_share(__LINE__) +void glfwCreateWindow_CMockIgnoreArg_share(UNITY_LINE_TYPE cmock_line); +#define glfwDestroyWindow_Ignore() glfwDestroyWindow_CMockIgnore() +void glfwDestroyWindow_CMockIgnore(void); +#define glfwDestroyWindow_StopIgnore() glfwDestroyWindow_CMockStopIgnore() +void glfwDestroyWindow_CMockStopIgnore(void); +#define glfwDestroyWindow_Expect(window) glfwDestroyWindow_CMockExpect(__LINE__, window) +void glfwDestroyWindow_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window); +typedef void (* CMOCK_glfwDestroyWindow_CALLBACK)(GLFWwindow* window, int cmock_num_calls); +void glfwDestroyWindow_AddCallback(CMOCK_glfwDestroyWindow_CALLBACK Callback); +void glfwDestroyWindow_Stub(CMOCK_glfwDestroyWindow_CALLBACK Callback); +#define glfwDestroyWindow_StubWithCallback glfwDestroyWindow_AddCallback +#define glfwDestroyWindow_IgnoreArg_window() glfwDestroyWindow_CMockIgnoreArg_window(__LINE__) +void glfwDestroyWindow_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwWindowShouldClose_IgnoreAndReturn(cmock_retval) glfwWindowShouldClose_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwWindowShouldClose_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define glfwWindowShouldClose_StopIgnore() glfwWindowShouldClose_CMockStopIgnore() +void glfwWindowShouldClose_CMockStopIgnore(void); +#define glfwWindowShouldClose_ExpectAndReturn(window, cmock_retval) glfwWindowShouldClose_CMockExpectAndReturn(__LINE__, window, cmock_retval) +void glfwWindowShouldClose_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int cmock_to_return); +typedef int (* CMOCK_glfwWindowShouldClose_CALLBACK)(GLFWwindow* window, int cmock_num_calls); +void glfwWindowShouldClose_AddCallback(CMOCK_glfwWindowShouldClose_CALLBACK Callback); +void glfwWindowShouldClose_Stub(CMOCK_glfwWindowShouldClose_CALLBACK Callback); +#define glfwWindowShouldClose_StubWithCallback glfwWindowShouldClose_AddCallback +#define glfwWindowShouldClose_IgnoreArg_window() glfwWindowShouldClose_CMockIgnoreArg_window(__LINE__) +void glfwWindowShouldClose_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowShouldClose_Ignore() glfwSetWindowShouldClose_CMockIgnore() +void glfwSetWindowShouldClose_CMockIgnore(void); +#define glfwSetWindowShouldClose_StopIgnore() glfwSetWindowShouldClose_CMockStopIgnore() +void glfwSetWindowShouldClose_CMockStopIgnore(void); +#define glfwSetWindowShouldClose_Expect(window, value) glfwSetWindowShouldClose_CMockExpect(__LINE__, window, value) +void glfwSetWindowShouldClose_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int value); +typedef void (* CMOCK_glfwSetWindowShouldClose_CALLBACK)(GLFWwindow* window, int value, int cmock_num_calls); +void glfwSetWindowShouldClose_AddCallback(CMOCK_glfwSetWindowShouldClose_CALLBACK Callback); +void glfwSetWindowShouldClose_Stub(CMOCK_glfwSetWindowShouldClose_CALLBACK Callback); +#define glfwSetWindowShouldClose_StubWithCallback glfwSetWindowShouldClose_AddCallback +#define glfwSetWindowShouldClose_IgnoreArg_window() glfwSetWindowShouldClose_CMockIgnoreArg_window(__LINE__) +void glfwSetWindowShouldClose_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowShouldClose_IgnoreArg_value() glfwSetWindowShouldClose_CMockIgnoreArg_value(__LINE__) +void glfwSetWindowShouldClose_CMockIgnoreArg_value(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowTitle_Ignore() glfwSetWindowTitle_CMockIgnore() +void glfwSetWindowTitle_CMockIgnore(void); +#define glfwSetWindowTitle_StopIgnore() glfwSetWindowTitle_CMockStopIgnore() +void glfwSetWindowTitle_CMockStopIgnore(void); +#define glfwSetWindowTitle_Expect(window, title) glfwSetWindowTitle_CMockExpect(__LINE__, window, title) +void glfwSetWindowTitle_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, const char* title); +typedef void (* CMOCK_glfwSetWindowTitle_CALLBACK)(GLFWwindow* window, const char* title, int cmock_num_calls); +void glfwSetWindowTitle_AddCallback(CMOCK_glfwSetWindowTitle_CALLBACK Callback); +void glfwSetWindowTitle_Stub(CMOCK_glfwSetWindowTitle_CALLBACK Callback); +#define glfwSetWindowTitle_StubWithCallback glfwSetWindowTitle_AddCallback +#define glfwSetWindowTitle_IgnoreArg_window() glfwSetWindowTitle_CMockIgnoreArg_window(__LINE__) +void glfwSetWindowTitle_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowTitle_IgnoreArg_title() glfwSetWindowTitle_CMockIgnoreArg_title(__LINE__) +void glfwSetWindowTitle_CMockIgnoreArg_title(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowIcon_Ignore() glfwSetWindowIcon_CMockIgnore() +void glfwSetWindowIcon_CMockIgnore(void); +#define glfwSetWindowIcon_StopIgnore() glfwSetWindowIcon_CMockStopIgnore() +void glfwSetWindowIcon_CMockStopIgnore(void); +#define glfwSetWindowIcon_Expect(window, count, images) glfwSetWindowIcon_CMockExpect(__LINE__, window, count, images) +void glfwSetWindowIcon_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int count, const GLFWimage* images); +typedef void (* CMOCK_glfwSetWindowIcon_CALLBACK)(GLFWwindow* window, int count, const GLFWimage* images, int cmock_num_calls); +void glfwSetWindowIcon_AddCallback(CMOCK_glfwSetWindowIcon_CALLBACK Callback); +void glfwSetWindowIcon_Stub(CMOCK_glfwSetWindowIcon_CALLBACK Callback); +#define glfwSetWindowIcon_StubWithCallback glfwSetWindowIcon_AddCallback +#define glfwSetWindowIcon_IgnoreArg_window() glfwSetWindowIcon_CMockIgnoreArg_window(__LINE__) +void glfwSetWindowIcon_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowIcon_IgnoreArg_count() glfwSetWindowIcon_CMockIgnoreArg_count(__LINE__) +void glfwSetWindowIcon_CMockIgnoreArg_count(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowIcon_IgnoreArg_images() glfwSetWindowIcon_CMockIgnoreArg_images(__LINE__) +void glfwSetWindowIcon_CMockIgnoreArg_images(UNITY_LINE_TYPE cmock_line); +#define glfwGetWindowPos_Ignore() glfwGetWindowPos_CMockIgnore() +void glfwGetWindowPos_CMockIgnore(void); +#define glfwGetWindowPos_StopIgnore() glfwGetWindowPos_CMockStopIgnore() +void glfwGetWindowPos_CMockStopIgnore(void); +#define glfwGetWindowPos_Expect(window, xpos, ypos) glfwGetWindowPos_CMockExpect(__LINE__, window, xpos, ypos) +void glfwGetWindowPos_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int* xpos, int* ypos); +typedef void (* CMOCK_glfwGetWindowPos_CALLBACK)(GLFWwindow* window, int* xpos, int* ypos, int cmock_num_calls); +void glfwGetWindowPos_AddCallback(CMOCK_glfwGetWindowPos_CALLBACK Callback); +void glfwGetWindowPos_Stub(CMOCK_glfwGetWindowPos_CALLBACK Callback); +#define glfwGetWindowPos_StubWithCallback glfwGetWindowPos_AddCallback +#define glfwGetWindowPos_IgnoreArg_window() glfwGetWindowPos_CMockIgnoreArg_window(__LINE__) +void glfwGetWindowPos_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwGetWindowPos_IgnoreArg_xpos() glfwGetWindowPos_CMockIgnoreArg_xpos(__LINE__) +void glfwGetWindowPos_CMockIgnoreArg_xpos(UNITY_LINE_TYPE cmock_line); +#define glfwGetWindowPos_IgnoreArg_ypos() glfwGetWindowPos_CMockIgnoreArg_ypos(__LINE__) +void glfwGetWindowPos_CMockIgnoreArg_ypos(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowPos_Ignore() glfwSetWindowPos_CMockIgnore() +void glfwSetWindowPos_CMockIgnore(void); +#define glfwSetWindowPos_StopIgnore() glfwSetWindowPos_CMockStopIgnore() +void glfwSetWindowPos_CMockStopIgnore(void); +#define glfwSetWindowPos_Expect(window, xpos, ypos) glfwSetWindowPos_CMockExpect(__LINE__, window, xpos, ypos) +void glfwSetWindowPos_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int xpos, int ypos); +typedef void (* CMOCK_glfwSetWindowPos_CALLBACK)(GLFWwindow* window, int xpos, int ypos, int cmock_num_calls); +void glfwSetWindowPos_AddCallback(CMOCK_glfwSetWindowPos_CALLBACK Callback); +void glfwSetWindowPos_Stub(CMOCK_glfwSetWindowPos_CALLBACK Callback); +#define glfwSetWindowPos_StubWithCallback glfwSetWindowPos_AddCallback +#define glfwSetWindowPos_IgnoreArg_window() glfwSetWindowPos_CMockIgnoreArg_window(__LINE__) +void glfwSetWindowPos_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowPos_IgnoreArg_xpos() glfwSetWindowPos_CMockIgnoreArg_xpos(__LINE__) +void glfwSetWindowPos_CMockIgnoreArg_xpos(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowPos_IgnoreArg_ypos() glfwSetWindowPos_CMockIgnoreArg_ypos(__LINE__) +void glfwSetWindowPos_CMockIgnoreArg_ypos(UNITY_LINE_TYPE cmock_line); +#define glfwGetWindowSize_Ignore() glfwGetWindowSize_CMockIgnore() +void glfwGetWindowSize_CMockIgnore(void); +#define glfwGetWindowSize_StopIgnore() glfwGetWindowSize_CMockStopIgnore() +void glfwGetWindowSize_CMockStopIgnore(void); +#define glfwGetWindowSize_Expect(window, width, height) glfwGetWindowSize_CMockExpect(__LINE__, window, width, height) +void glfwGetWindowSize_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int* width, int* height); +typedef void (* CMOCK_glfwGetWindowSize_CALLBACK)(GLFWwindow* window, int* width, int* height, int cmock_num_calls); +void glfwGetWindowSize_AddCallback(CMOCK_glfwGetWindowSize_CALLBACK Callback); +void glfwGetWindowSize_Stub(CMOCK_glfwGetWindowSize_CALLBACK Callback); +#define glfwGetWindowSize_StubWithCallback glfwGetWindowSize_AddCallback +#define glfwGetWindowSize_IgnoreArg_window() glfwGetWindowSize_CMockIgnoreArg_window(__LINE__) +void glfwGetWindowSize_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwGetWindowSize_IgnoreArg_width() glfwGetWindowSize_CMockIgnoreArg_width(__LINE__) +void glfwGetWindowSize_CMockIgnoreArg_width(UNITY_LINE_TYPE cmock_line); +#define glfwGetWindowSize_IgnoreArg_height() glfwGetWindowSize_CMockIgnoreArg_height(__LINE__) +void glfwGetWindowSize_CMockIgnoreArg_height(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowSizeLimits_Ignore() glfwSetWindowSizeLimits_CMockIgnore() +void glfwSetWindowSizeLimits_CMockIgnore(void); +#define glfwSetWindowSizeLimits_StopIgnore() glfwSetWindowSizeLimits_CMockStopIgnore() +void glfwSetWindowSizeLimits_CMockStopIgnore(void); +#define glfwSetWindowSizeLimits_Expect(window, minwidth, minheight, maxwidth, maxheight) glfwSetWindowSizeLimits_CMockExpect(__LINE__, window, minwidth, minheight, maxwidth, maxheight) +void glfwSetWindowSizeLimits_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int minwidth, int minheight, int maxwidth, int maxheight); +typedef void (* CMOCK_glfwSetWindowSizeLimits_CALLBACK)(GLFWwindow* window, int minwidth, int minheight, int maxwidth, int maxheight, int cmock_num_calls); +void glfwSetWindowSizeLimits_AddCallback(CMOCK_glfwSetWindowSizeLimits_CALLBACK Callback); +void glfwSetWindowSizeLimits_Stub(CMOCK_glfwSetWindowSizeLimits_CALLBACK Callback); +#define glfwSetWindowSizeLimits_StubWithCallback glfwSetWindowSizeLimits_AddCallback +#define glfwSetWindowSizeLimits_IgnoreArg_window() glfwSetWindowSizeLimits_CMockIgnoreArg_window(__LINE__) +void glfwSetWindowSizeLimits_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowSizeLimits_IgnoreArg_minwidth() glfwSetWindowSizeLimits_CMockIgnoreArg_minwidth(__LINE__) +void glfwSetWindowSizeLimits_CMockIgnoreArg_minwidth(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowSizeLimits_IgnoreArg_minheight() glfwSetWindowSizeLimits_CMockIgnoreArg_minheight(__LINE__) +void glfwSetWindowSizeLimits_CMockIgnoreArg_minheight(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowSizeLimits_IgnoreArg_maxwidth() glfwSetWindowSizeLimits_CMockIgnoreArg_maxwidth(__LINE__) +void glfwSetWindowSizeLimits_CMockIgnoreArg_maxwidth(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowSizeLimits_IgnoreArg_maxheight() glfwSetWindowSizeLimits_CMockIgnoreArg_maxheight(__LINE__) +void glfwSetWindowSizeLimits_CMockIgnoreArg_maxheight(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowAspectRatio_Ignore() glfwSetWindowAspectRatio_CMockIgnore() +void glfwSetWindowAspectRatio_CMockIgnore(void); +#define glfwSetWindowAspectRatio_StopIgnore() glfwSetWindowAspectRatio_CMockStopIgnore() +void glfwSetWindowAspectRatio_CMockStopIgnore(void); +#define glfwSetWindowAspectRatio_Expect(window, numer, denom) glfwSetWindowAspectRatio_CMockExpect(__LINE__, window, numer, denom) +void glfwSetWindowAspectRatio_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int numer, int denom); +typedef void (* CMOCK_glfwSetWindowAspectRatio_CALLBACK)(GLFWwindow* window, int numer, int denom, int cmock_num_calls); +void glfwSetWindowAspectRatio_AddCallback(CMOCK_glfwSetWindowAspectRatio_CALLBACK Callback); +void glfwSetWindowAspectRatio_Stub(CMOCK_glfwSetWindowAspectRatio_CALLBACK Callback); +#define glfwSetWindowAspectRatio_StubWithCallback glfwSetWindowAspectRatio_AddCallback +#define glfwSetWindowAspectRatio_IgnoreArg_window() glfwSetWindowAspectRatio_CMockIgnoreArg_window(__LINE__) +void glfwSetWindowAspectRatio_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowAspectRatio_IgnoreArg_numer() glfwSetWindowAspectRatio_CMockIgnoreArg_numer(__LINE__) +void glfwSetWindowAspectRatio_CMockIgnoreArg_numer(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowAspectRatio_IgnoreArg_denom() glfwSetWindowAspectRatio_CMockIgnoreArg_denom(__LINE__) +void glfwSetWindowAspectRatio_CMockIgnoreArg_denom(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowSize_Ignore() glfwSetWindowSize_CMockIgnore() +void glfwSetWindowSize_CMockIgnore(void); +#define glfwSetWindowSize_StopIgnore() glfwSetWindowSize_CMockStopIgnore() +void glfwSetWindowSize_CMockStopIgnore(void); +#define glfwSetWindowSize_Expect(window, width, height) glfwSetWindowSize_CMockExpect(__LINE__, window, width, height) +void glfwSetWindowSize_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int width, int height); +typedef void (* CMOCK_glfwSetWindowSize_CALLBACK)(GLFWwindow* window, int width, int height, int cmock_num_calls); +void glfwSetWindowSize_AddCallback(CMOCK_glfwSetWindowSize_CALLBACK Callback); +void glfwSetWindowSize_Stub(CMOCK_glfwSetWindowSize_CALLBACK Callback); +#define glfwSetWindowSize_StubWithCallback glfwSetWindowSize_AddCallback +#define glfwSetWindowSize_IgnoreArg_window() glfwSetWindowSize_CMockIgnoreArg_window(__LINE__) +void glfwSetWindowSize_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowSize_IgnoreArg_width() glfwSetWindowSize_CMockIgnoreArg_width(__LINE__) +void glfwSetWindowSize_CMockIgnoreArg_width(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowSize_IgnoreArg_height() glfwSetWindowSize_CMockIgnoreArg_height(__LINE__) +void glfwSetWindowSize_CMockIgnoreArg_height(UNITY_LINE_TYPE cmock_line); +#define glfwGetFramebufferSize_Ignore() glfwGetFramebufferSize_CMockIgnore() +void glfwGetFramebufferSize_CMockIgnore(void); +#define glfwGetFramebufferSize_StopIgnore() glfwGetFramebufferSize_CMockStopIgnore() +void glfwGetFramebufferSize_CMockStopIgnore(void); +#define glfwGetFramebufferSize_Expect(window, width, height) glfwGetFramebufferSize_CMockExpect(__LINE__, window, width, height) +void glfwGetFramebufferSize_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int* width, int* height); +typedef void (* CMOCK_glfwGetFramebufferSize_CALLBACK)(GLFWwindow* window, int* width, int* height, int cmock_num_calls); +void glfwGetFramebufferSize_AddCallback(CMOCK_glfwGetFramebufferSize_CALLBACK Callback); +void glfwGetFramebufferSize_Stub(CMOCK_glfwGetFramebufferSize_CALLBACK Callback); +#define glfwGetFramebufferSize_StubWithCallback glfwGetFramebufferSize_AddCallback +#define glfwGetFramebufferSize_IgnoreArg_window() glfwGetFramebufferSize_CMockIgnoreArg_window(__LINE__) +void glfwGetFramebufferSize_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwGetFramebufferSize_IgnoreArg_width() glfwGetFramebufferSize_CMockIgnoreArg_width(__LINE__) +void glfwGetFramebufferSize_CMockIgnoreArg_width(UNITY_LINE_TYPE cmock_line); +#define glfwGetFramebufferSize_IgnoreArg_height() glfwGetFramebufferSize_CMockIgnoreArg_height(__LINE__) +void glfwGetFramebufferSize_CMockIgnoreArg_height(UNITY_LINE_TYPE cmock_line); +#define glfwGetWindowFrameSize_Ignore() glfwGetWindowFrameSize_CMockIgnore() +void glfwGetWindowFrameSize_CMockIgnore(void); +#define glfwGetWindowFrameSize_StopIgnore() glfwGetWindowFrameSize_CMockStopIgnore() +void glfwGetWindowFrameSize_CMockStopIgnore(void); +#define glfwGetWindowFrameSize_Expect(window, left, top, right, bottom) glfwGetWindowFrameSize_CMockExpect(__LINE__, window, left, top, right, bottom) +void glfwGetWindowFrameSize_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int* left, int* top, int* right, int* bottom); +typedef void (* CMOCK_glfwGetWindowFrameSize_CALLBACK)(GLFWwindow* window, int* left, int* top, int* right, int* bottom, int cmock_num_calls); +void glfwGetWindowFrameSize_AddCallback(CMOCK_glfwGetWindowFrameSize_CALLBACK Callback); +void glfwGetWindowFrameSize_Stub(CMOCK_glfwGetWindowFrameSize_CALLBACK Callback); +#define glfwGetWindowFrameSize_StubWithCallback glfwGetWindowFrameSize_AddCallback +#define glfwGetWindowFrameSize_IgnoreArg_window() glfwGetWindowFrameSize_CMockIgnoreArg_window(__LINE__) +void glfwGetWindowFrameSize_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwGetWindowFrameSize_IgnoreArg_left() glfwGetWindowFrameSize_CMockIgnoreArg_left(__LINE__) +void glfwGetWindowFrameSize_CMockIgnoreArg_left(UNITY_LINE_TYPE cmock_line); +#define glfwGetWindowFrameSize_IgnoreArg_top() glfwGetWindowFrameSize_CMockIgnoreArg_top(__LINE__) +void glfwGetWindowFrameSize_CMockIgnoreArg_top(UNITY_LINE_TYPE cmock_line); +#define glfwGetWindowFrameSize_IgnoreArg_right() glfwGetWindowFrameSize_CMockIgnoreArg_right(__LINE__) +void glfwGetWindowFrameSize_CMockIgnoreArg_right(UNITY_LINE_TYPE cmock_line); +#define glfwGetWindowFrameSize_IgnoreArg_bottom() glfwGetWindowFrameSize_CMockIgnoreArg_bottom(__LINE__) +void glfwGetWindowFrameSize_CMockIgnoreArg_bottom(UNITY_LINE_TYPE cmock_line); +#define glfwGetWindowContentScale_Ignore() glfwGetWindowContentScale_CMockIgnore() +void glfwGetWindowContentScale_CMockIgnore(void); +#define glfwGetWindowContentScale_StopIgnore() glfwGetWindowContentScale_CMockStopIgnore() +void glfwGetWindowContentScale_CMockStopIgnore(void); +#define glfwGetWindowContentScale_Expect(window, xscale, yscale) glfwGetWindowContentScale_CMockExpect(__LINE__, window, xscale, yscale) +void glfwGetWindowContentScale_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, float* xscale, float* yscale); +typedef void (* CMOCK_glfwGetWindowContentScale_CALLBACK)(GLFWwindow* window, float* xscale, float* yscale, int cmock_num_calls); +void glfwGetWindowContentScale_AddCallback(CMOCK_glfwGetWindowContentScale_CALLBACK Callback); +void glfwGetWindowContentScale_Stub(CMOCK_glfwGetWindowContentScale_CALLBACK Callback); +#define glfwGetWindowContentScale_StubWithCallback glfwGetWindowContentScale_AddCallback +#define glfwGetWindowContentScale_IgnoreArg_window() glfwGetWindowContentScale_CMockIgnoreArg_window(__LINE__) +void glfwGetWindowContentScale_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwGetWindowContentScale_IgnoreArg_xscale() glfwGetWindowContentScale_CMockIgnoreArg_xscale(__LINE__) +void glfwGetWindowContentScale_CMockIgnoreArg_xscale(UNITY_LINE_TYPE cmock_line); +#define glfwGetWindowContentScale_IgnoreArg_yscale() glfwGetWindowContentScale_CMockIgnoreArg_yscale(__LINE__) +void glfwGetWindowContentScale_CMockIgnoreArg_yscale(UNITY_LINE_TYPE cmock_line); +#define glfwGetWindowOpacity_IgnoreAndReturn(cmock_retval) glfwGetWindowOpacity_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetWindowOpacity_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, float cmock_to_return); +#define glfwGetWindowOpacity_StopIgnore() glfwGetWindowOpacity_CMockStopIgnore() +void glfwGetWindowOpacity_CMockStopIgnore(void); +#define glfwGetWindowOpacity_ExpectAndReturn(window, cmock_retval) glfwGetWindowOpacity_CMockExpectAndReturn(__LINE__, window, cmock_retval) +void glfwGetWindowOpacity_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, float cmock_to_return); +typedef float (* CMOCK_glfwGetWindowOpacity_CALLBACK)(GLFWwindow* window, int cmock_num_calls); +void glfwGetWindowOpacity_AddCallback(CMOCK_glfwGetWindowOpacity_CALLBACK Callback); +void glfwGetWindowOpacity_Stub(CMOCK_glfwGetWindowOpacity_CALLBACK Callback); +#define glfwGetWindowOpacity_StubWithCallback glfwGetWindowOpacity_AddCallback +#define glfwGetWindowOpacity_IgnoreArg_window() glfwGetWindowOpacity_CMockIgnoreArg_window(__LINE__) +void glfwGetWindowOpacity_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowOpacity_Ignore() glfwSetWindowOpacity_CMockIgnore() +void glfwSetWindowOpacity_CMockIgnore(void); +#define glfwSetWindowOpacity_StopIgnore() glfwSetWindowOpacity_CMockStopIgnore() +void glfwSetWindowOpacity_CMockStopIgnore(void); +#define glfwSetWindowOpacity_Expect(window, opacity) glfwSetWindowOpacity_CMockExpect(__LINE__, window, opacity) +void glfwSetWindowOpacity_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, float opacity); +typedef void (* CMOCK_glfwSetWindowOpacity_CALLBACK)(GLFWwindow* window, float opacity, int cmock_num_calls); +void glfwSetWindowOpacity_AddCallback(CMOCK_glfwSetWindowOpacity_CALLBACK Callback); +void glfwSetWindowOpacity_Stub(CMOCK_glfwSetWindowOpacity_CALLBACK Callback); +#define glfwSetWindowOpacity_StubWithCallback glfwSetWindowOpacity_AddCallback +#define glfwSetWindowOpacity_IgnoreArg_window() glfwSetWindowOpacity_CMockIgnoreArg_window(__LINE__) +void glfwSetWindowOpacity_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowOpacity_IgnoreArg_opacity() glfwSetWindowOpacity_CMockIgnoreArg_opacity(__LINE__) +void glfwSetWindowOpacity_CMockIgnoreArg_opacity(UNITY_LINE_TYPE cmock_line); +#define glfwIconifyWindow_Ignore() glfwIconifyWindow_CMockIgnore() +void glfwIconifyWindow_CMockIgnore(void); +#define glfwIconifyWindow_StopIgnore() glfwIconifyWindow_CMockStopIgnore() +void glfwIconifyWindow_CMockStopIgnore(void); +#define glfwIconifyWindow_Expect(window) glfwIconifyWindow_CMockExpect(__LINE__, window) +void glfwIconifyWindow_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window); +typedef void (* CMOCK_glfwIconifyWindow_CALLBACK)(GLFWwindow* window, int cmock_num_calls); +void glfwIconifyWindow_AddCallback(CMOCK_glfwIconifyWindow_CALLBACK Callback); +void glfwIconifyWindow_Stub(CMOCK_glfwIconifyWindow_CALLBACK Callback); +#define glfwIconifyWindow_StubWithCallback glfwIconifyWindow_AddCallback +#define glfwIconifyWindow_IgnoreArg_window() glfwIconifyWindow_CMockIgnoreArg_window(__LINE__) +void glfwIconifyWindow_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwRestoreWindow_Ignore() glfwRestoreWindow_CMockIgnore() +void glfwRestoreWindow_CMockIgnore(void); +#define glfwRestoreWindow_StopIgnore() glfwRestoreWindow_CMockStopIgnore() +void glfwRestoreWindow_CMockStopIgnore(void); +#define glfwRestoreWindow_Expect(window) glfwRestoreWindow_CMockExpect(__LINE__, window) +void glfwRestoreWindow_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window); +typedef void (* CMOCK_glfwRestoreWindow_CALLBACK)(GLFWwindow* window, int cmock_num_calls); +void glfwRestoreWindow_AddCallback(CMOCK_glfwRestoreWindow_CALLBACK Callback); +void glfwRestoreWindow_Stub(CMOCK_glfwRestoreWindow_CALLBACK Callback); +#define glfwRestoreWindow_StubWithCallback glfwRestoreWindow_AddCallback +#define glfwRestoreWindow_IgnoreArg_window() glfwRestoreWindow_CMockIgnoreArg_window(__LINE__) +void glfwRestoreWindow_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwMaximizeWindow_Ignore() glfwMaximizeWindow_CMockIgnore() +void glfwMaximizeWindow_CMockIgnore(void); +#define glfwMaximizeWindow_StopIgnore() glfwMaximizeWindow_CMockStopIgnore() +void glfwMaximizeWindow_CMockStopIgnore(void); +#define glfwMaximizeWindow_Expect(window) glfwMaximizeWindow_CMockExpect(__LINE__, window) +void glfwMaximizeWindow_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window); +typedef void (* CMOCK_glfwMaximizeWindow_CALLBACK)(GLFWwindow* window, int cmock_num_calls); +void glfwMaximizeWindow_AddCallback(CMOCK_glfwMaximizeWindow_CALLBACK Callback); +void glfwMaximizeWindow_Stub(CMOCK_glfwMaximizeWindow_CALLBACK Callback); +#define glfwMaximizeWindow_StubWithCallback glfwMaximizeWindow_AddCallback +#define glfwMaximizeWindow_IgnoreArg_window() glfwMaximizeWindow_CMockIgnoreArg_window(__LINE__) +void glfwMaximizeWindow_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwShowWindow_Ignore() glfwShowWindow_CMockIgnore() +void glfwShowWindow_CMockIgnore(void); +#define glfwShowWindow_StopIgnore() glfwShowWindow_CMockStopIgnore() +void glfwShowWindow_CMockStopIgnore(void); +#define glfwShowWindow_Expect(window) glfwShowWindow_CMockExpect(__LINE__, window) +void glfwShowWindow_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window); +typedef void (* CMOCK_glfwShowWindow_CALLBACK)(GLFWwindow* window, int cmock_num_calls); +void glfwShowWindow_AddCallback(CMOCK_glfwShowWindow_CALLBACK Callback); +void glfwShowWindow_Stub(CMOCK_glfwShowWindow_CALLBACK Callback); +#define glfwShowWindow_StubWithCallback glfwShowWindow_AddCallback +#define glfwShowWindow_IgnoreArg_window() glfwShowWindow_CMockIgnoreArg_window(__LINE__) +void glfwShowWindow_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwHideWindow_Ignore() glfwHideWindow_CMockIgnore() +void glfwHideWindow_CMockIgnore(void); +#define glfwHideWindow_StopIgnore() glfwHideWindow_CMockStopIgnore() +void glfwHideWindow_CMockStopIgnore(void); +#define glfwHideWindow_Expect(window) glfwHideWindow_CMockExpect(__LINE__, window) +void glfwHideWindow_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window); +typedef void (* CMOCK_glfwHideWindow_CALLBACK)(GLFWwindow* window, int cmock_num_calls); +void glfwHideWindow_AddCallback(CMOCK_glfwHideWindow_CALLBACK Callback); +void glfwHideWindow_Stub(CMOCK_glfwHideWindow_CALLBACK Callback); +#define glfwHideWindow_StubWithCallback glfwHideWindow_AddCallback +#define glfwHideWindow_IgnoreArg_window() glfwHideWindow_CMockIgnoreArg_window(__LINE__) +void glfwHideWindow_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwFocusWindow_Ignore() glfwFocusWindow_CMockIgnore() +void glfwFocusWindow_CMockIgnore(void); +#define glfwFocusWindow_StopIgnore() glfwFocusWindow_CMockStopIgnore() +void glfwFocusWindow_CMockStopIgnore(void); +#define glfwFocusWindow_Expect(window) glfwFocusWindow_CMockExpect(__LINE__, window) +void glfwFocusWindow_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window); +typedef void (* CMOCK_glfwFocusWindow_CALLBACK)(GLFWwindow* window, int cmock_num_calls); +void glfwFocusWindow_AddCallback(CMOCK_glfwFocusWindow_CALLBACK Callback); +void glfwFocusWindow_Stub(CMOCK_glfwFocusWindow_CALLBACK Callback); +#define glfwFocusWindow_StubWithCallback glfwFocusWindow_AddCallback +#define glfwFocusWindow_IgnoreArg_window() glfwFocusWindow_CMockIgnoreArg_window(__LINE__) +void glfwFocusWindow_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwRequestWindowAttention_Ignore() glfwRequestWindowAttention_CMockIgnore() +void glfwRequestWindowAttention_CMockIgnore(void); +#define glfwRequestWindowAttention_StopIgnore() glfwRequestWindowAttention_CMockStopIgnore() +void glfwRequestWindowAttention_CMockStopIgnore(void); +#define glfwRequestWindowAttention_Expect(window) glfwRequestWindowAttention_CMockExpect(__LINE__, window) +void glfwRequestWindowAttention_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window); +typedef void (* CMOCK_glfwRequestWindowAttention_CALLBACK)(GLFWwindow* window, int cmock_num_calls); +void glfwRequestWindowAttention_AddCallback(CMOCK_glfwRequestWindowAttention_CALLBACK Callback); +void glfwRequestWindowAttention_Stub(CMOCK_glfwRequestWindowAttention_CALLBACK Callback); +#define glfwRequestWindowAttention_StubWithCallback glfwRequestWindowAttention_AddCallback +#define glfwRequestWindowAttention_IgnoreArg_window() glfwRequestWindowAttention_CMockIgnoreArg_window(__LINE__) +void glfwRequestWindowAttention_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwGetWindowMonitor_IgnoreAndReturn(cmock_retval) glfwGetWindowMonitor_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetWindowMonitor_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWmonitor* cmock_to_return); +#define glfwGetWindowMonitor_StopIgnore() glfwGetWindowMonitor_CMockStopIgnore() +void glfwGetWindowMonitor_CMockStopIgnore(void); +#define glfwGetWindowMonitor_ExpectAndReturn(window, cmock_retval) glfwGetWindowMonitor_CMockExpectAndReturn(__LINE__, window, cmock_retval) +void glfwGetWindowMonitor_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWmonitor* cmock_to_return); +typedef GLFWmonitor* (* CMOCK_glfwGetWindowMonitor_CALLBACK)(GLFWwindow* window, int cmock_num_calls); +void glfwGetWindowMonitor_AddCallback(CMOCK_glfwGetWindowMonitor_CALLBACK Callback); +void glfwGetWindowMonitor_Stub(CMOCK_glfwGetWindowMonitor_CALLBACK Callback); +#define glfwGetWindowMonitor_StubWithCallback glfwGetWindowMonitor_AddCallback +#define glfwGetWindowMonitor_IgnoreArg_window() glfwGetWindowMonitor_CMockIgnoreArg_window(__LINE__) +void glfwGetWindowMonitor_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowMonitor_Ignore() glfwSetWindowMonitor_CMockIgnore() +void glfwSetWindowMonitor_CMockIgnore(void); +#define glfwSetWindowMonitor_StopIgnore() glfwSetWindowMonitor_CMockStopIgnore() +void glfwSetWindowMonitor_CMockStopIgnore(void); +#define glfwSetWindowMonitor_Expect(window, monitor, xpos, ypos, width, height, refreshRate) glfwSetWindowMonitor_CMockExpect(__LINE__, window, monitor, xpos, ypos, width, height, refreshRate) +void glfwSetWindowMonitor_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWmonitor* monitor, int xpos, int ypos, int width, int height, int refreshRate); +typedef void (* CMOCK_glfwSetWindowMonitor_CALLBACK)(GLFWwindow* window, GLFWmonitor* monitor, int xpos, int ypos, int width, int height, int refreshRate, int cmock_num_calls); +void glfwSetWindowMonitor_AddCallback(CMOCK_glfwSetWindowMonitor_CALLBACK Callback); +void glfwSetWindowMonitor_Stub(CMOCK_glfwSetWindowMonitor_CALLBACK Callback); +#define glfwSetWindowMonitor_StubWithCallback glfwSetWindowMonitor_AddCallback +#define glfwSetWindowMonitor_IgnoreArg_window() glfwSetWindowMonitor_CMockIgnoreArg_window(__LINE__) +void glfwSetWindowMonitor_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowMonitor_IgnoreArg_monitor() glfwSetWindowMonitor_CMockIgnoreArg_monitor(__LINE__) +void glfwSetWindowMonitor_CMockIgnoreArg_monitor(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowMonitor_IgnoreArg_xpos() glfwSetWindowMonitor_CMockIgnoreArg_xpos(__LINE__) +void glfwSetWindowMonitor_CMockIgnoreArg_xpos(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowMonitor_IgnoreArg_ypos() glfwSetWindowMonitor_CMockIgnoreArg_ypos(__LINE__) +void glfwSetWindowMonitor_CMockIgnoreArg_ypos(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowMonitor_IgnoreArg_width() glfwSetWindowMonitor_CMockIgnoreArg_width(__LINE__) +void glfwSetWindowMonitor_CMockIgnoreArg_width(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowMonitor_IgnoreArg_height() glfwSetWindowMonitor_CMockIgnoreArg_height(__LINE__) +void glfwSetWindowMonitor_CMockIgnoreArg_height(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowMonitor_IgnoreArg_refreshRate() glfwSetWindowMonitor_CMockIgnoreArg_refreshRate(__LINE__) +void glfwSetWindowMonitor_CMockIgnoreArg_refreshRate(UNITY_LINE_TYPE cmock_line); +#define glfwGetWindowAttrib_IgnoreAndReturn(cmock_retval) glfwGetWindowAttrib_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetWindowAttrib_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define glfwGetWindowAttrib_StopIgnore() glfwGetWindowAttrib_CMockStopIgnore() +void glfwGetWindowAttrib_CMockStopIgnore(void); +#define glfwGetWindowAttrib_ExpectAndReturn(window, attrib, cmock_retval) glfwGetWindowAttrib_CMockExpectAndReturn(__LINE__, window, attrib, cmock_retval) +void glfwGetWindowAttrib_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int attrib, int cmock_to_return); +typedef int (* CMOCK_glfwGetWindowAttrib_CALLBACK)(GLFWwindow* window, int attrib, int cmock_num_calls); +void glfwGetWindowAttrib_AddCallback(CMOCK_glfwGetWindowAttrib_CALLBACK Callback); +void glfwGetWindowAttrib_Stub(CMOCK_glfwGetWindowAttrib_CALLBACK Callback); +#define glfwGetWindowAttrib_StubWithCallback glfwGetWindowAttrib_AddCallback +#define glfwGetWindowAttrib_IgnoreArg_window() glfwGetWindowAttrib_CMockIgnoreArg_window(__LINE__) +void glfwGetWindowAttrib_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwGetWindowAttrib_IgnoreArg_attrib() glfwGetWindowAttrib_CMockIgnoreArg_attrib(__LINE__) +void glfwGetWindowAttrib_CMockIgnoreArg_attrib(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowAttrib_Ignore() glfwSetWindowAttrib_CMockIgnore() +void glfwSetWindowAttrib_CMockIgnore(void); +#define glfwSetWindowAttrib_StopIgnore() glfwSetWindowAttrib_CMockStopIgnore() +void glfwSetWindowAttrib_CMockStopIgnore(void); +#define glfwSetWindowAttrib_Expect(window, attrib, value) glfwSetWindowAttrib_CMockExpect(__LINE__, window, attrib, value) +void glfwSetWindowAttrib_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int attrib, int value); +typedef void (* CMOCK_glfwSetWindowAttrib_CALLBACK)(GLFWwindow* window, int attrib, int value, int cmock_num_calls); +void glfwSetWindowAttrib_AddCallback(CMOCK_glfwSetWindowAttrib_CALLBACK Callback); +void glfwSetWindowAttrib_Stub(CMOCK_glfwSetWindowAttrib_CALLBACK Callback); +#define glfwSetWindowAttrib_StubWithCallback glfwSetWindowAttrib_AddCallback +#define glfwSetWindowAttrib_IgnoreArg_window() glfwSetWindowAttrib_CMockIgnoreArg_window(__LINE__) +void glfwSetWindowAttrib_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowAttrib_IgnoreArg_attrib() glfwSetWindowAttrib_CMockIgnoreArg_attrib(__LINE__) +void glfwSetWindowAttrib_CMockIgnoreArg_attrib(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowAttrib_IgnoreArg_value() glfwSetWindowAttrib_CMockIgnoreArg_value(__LINE__) +void glfwSetWindowAttrib_CMockIgnoreArg_value(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowUserPointer_Ignore() glfwSetWindowUserPointer_CMockIgnore() +void glfwSetWindowUserPointer_CMockIgnore(void); +#define glfwSetWindowUserPointer_StopIgnore() glfwSetWindowUserPointer_CMockStopIgnore() +void glfwSetWindowUserPointer_CMockStopIgnore(void); +#define glfwSetWindowUserPointer_Expect(window, pointer) glfwSetWindowUserPointer_CMockExpect(__LINE__, window, pointer) +void glfwSetWindowUserPointer_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, void* pointer); +typedef void (* CMOCK_glfwSetWindowUserPointer_CALLBACK)(GLFWwindow* window, void* pointer, int cmock_num_calls); +void glfwSetWindowUserPointer_AddCallback(CMOCK_glfwSetWindowUserPointer_CALLBACK Callback); +void glfwSetWindowUserPointer_Stub(CMOCK_glfwSetWindowUserPointer_CALLBACK Callback); +#define glfwSetWindowUserPointer_StubWithCallback glfwSetWindowUserPointer_AddCallback +#define glfwSetWindowUserPointer_IgnoreArg_window() glfwSetWindowUserPointer_CMockIgnoreArg_window(__LINE__) +void glfwSetWindowUserPointer_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowUserPointer_IgnoreArg_pointer() glfwSetWindowUserPointer_CMockIgnoreArg_pointer(__LINE__) +void glfwSetWindowUserPointer_CMockIgnoreArg_pointer(UNITY_LINE_TYPE cmock_line); +#define glfwGetWindowUserPointer_IgnoreAndReturn(cmock_retval) glfwGetWindowUserPointer_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetWindowUserPointer_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, void* cmock_to_return); +#define glfwGetWindowUserPointer_StopIgnore() glfwGetWindowUserPointer_CMockStopIgnore() +void glfwGetWindowUserPointer_CMockStopIgnore(void); +#define glfwGetWindowUserPointer_ExpectAndReturn(window, cmock_retval) glfwGetWindowUserPointer_CMockExpectAndReturn(__LINE__, window, cmock_retval) +void glfwGetWindowUserPointer_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, void* cmock_to_return); +typedef void* (* CMOCK_glfwGetWindowUserPointer_CALLBACK)(GLFWwindow* window, int cmock_num_calls); +void glfwGetWindowUserPointer_AddCallback(CMOCK_glfwGetWindowUserPointer_CALLBACK Callback); +void glfwGetWindowUserPointer_Stub(CMOCK_glfwGetWindowUserPointer_CALLBACK Callback); +#define glfwGetWindowUserPointer_StubWithCallback glfwGetWindowUserPointer_AddCallback +#define glfwGetWindowUserPointer_IgnoreArg_window() glfwGetWindowUserPointer_CMockIgnoreArg_window(__LINE__) +void glfwGetWindowUserPointer_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowPosCallback_IgnoreAndReturn(cmock_retval) glfwSetWindowPosCallback_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwSetWindowPosCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindowposfun cmock_to_return); +#define glfwSetWindowPosCallback_StopIgnore() glfwSetWindowPosCallback_CMockStopIgnore() +void glfwSetWindowPosCallback_CMockStopIgnore(void); +#define glfwSetWindowPosCallback_ExpectAndReturn(window, callback, cmock_retval) glfwSetWindowPosCallback_CMockExpectAndReturn(__LINE__, window, callback, cmock_retval) +void glfwSetWindowPosCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWwindowposfun callback, GLFWwindowposfun cmock_to_return); +typedef GLFWwindowposfun (* CMOCK_glfwSetWindowPosCallback_CALLBACK)(GLFWwindow* window, GLFWwindowposfun callback, int cmock_num_calls); +void glfwSetWindowPosCallback_AddCallback(CMOCK_glfwSetWindowPosCallback_CALLBACK Callback); +void glfwSetWindowPosCallback_Stub(CMOCK_glfwSetWindowPosCallback_CALLBACK Callback); +#define glfwSetWindowPosCallback_StubWithCallback glfwSetWindowPosCallback_AddCallback +#define glfwSetWindowPosCallback_IgnoreArg_window() glfwSetWindowPosCallback_CMockIgnoreArg_window(__LINE__) +void glfwSetWindowPosCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowPosCallback_IgnoreArg_callback() glfwSetWindowPosCallback_CMockIgnoreArg_callback(__LINE__) +void glfwSetWindowPosCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowSizeCallback_IgnoreAndReturn(cmock_retval) glfwSetWindowSizeCallback_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwSetWindowSizeCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindowsizefun cmock_to_return); +#define glfwSetWindowSizeCallback_StopIgnore() glfwSetWindowSizeCallback_CMockStopIgnore() +void glfwSetWindowSizeCallback_CMockStopIgnore(void); +#define glfwSetWindowSizeCallback_ExpectAndReturn(window, callback, cmock_retval) glfwSetWindowSizeCallback_CMockExpectAndReturn(__LINE__, window, callback, cmock_retval) +void glfwSetWindowSizeCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWwindowsizefun callback, GLFWwindowsizefun cmock_to_return); +typedef GLFWwindowsizefun (* CMOCK_glfwSetWindowSizeCallback_CALLBACK)(GLFWwindow* window, GLFWwindowsizefun callback, int cmock_num_calls); +void glfwSetWindowSizeCallback_AddCallback(CMOCK_glfwSetWindowSizeCallback_CALLBACK Callback); +void glfwSetWindowSizeCallback_Stub(CMOCK_glfwSetWindowSizeCallback_CALLBACK Callback); +#define glfwSetWindowSizeCallback_StubWithCallback glfwSetWindowSizeCallback_AddCallback +#define glfwSetWindowSizeCallback_IgnoreArg_window() glfwSetWindowSizeCallback_CMockIgnoreArg_window(__LINE__) +void glfwSetWindowSizeCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowSizeCallback_IgnoreArg_callback() glfwSetWindowSizeCallback_CMockIgnoreArg_callback(__LINE__) +void glfwSetWindowSizeCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowCloseCallback_IgnoreAndReturn(cmock_retval) glfwSetWindowCloseCallback_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwSetWindowCloseCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindowclosefun cmock_to_return); +#define glfwSetWindowCloseCallback_StopIgnore() glfwSetWindowCloseCallback_CMockStopIgnore() +void glfwSetWindowCloseCallback_CMockStopIgnore(void); +#define glfwSetWindowCloseCallback_ExpectAndReturn(window, callback, cmock_retval) glfwSetWindowCloseCallback_CMockExpectAndReturn(__LINE__, window, callback, cmock_retval) +void glfwSetWindowCloseCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWwindowclosefun callback, GLFWwindowclosefun cmock_to_return); +typedef GLFWwindowclosefun (* CMOCK_glfwSetWindowCloseCallback_CALLBACK)(GLFWwindow* window, GLFWwindowclosefun callback, int cmock_num_calls); +void glfwSetWindowCloseCallback_AddCallback(CMOCK_glfwSetWindowCloseCallback_CALLBACK Callback); +void glfwSetWindowCloseCallback_Stub(CMOCK_glfwSetWindowCloseCallback_CALLBACK Callback); +#define glfwSetWindowCloseCallback_StubWithCallback glfwSetWindowCloseCallback_AddCallback +#define glfwSetWindowCloseCallback_IgnoreArg_window() glfwSetWindowCloseCallback_CMockIgnoreArg_window(__LINE__) +void glfwSetWindowCloseCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowCloseCallback_IgnoreArg_callback() glfwSetWindowCloseCallback_CMockIgnoreArg_callback(__LINE__) +void glfwSetWindowCloseCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowRefreshCallback_IgnoreAndReturn(cmock_retval) glfwSetWindowRefreshCallback_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwSetWindowRefreshCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindowrefreshfun cmock_to_return); +#define glfwSetWindowRefreshCallback_StopIgnore() glfwSetWindowRefreshCallback_CMockStopIgnore() +void glfwSetWindowRefreshCallback_CMockStopIgnore(void); +#define glfwSetWindowRefreshCallback_ExpectAndReturn(window, callback, cmock_retval) glfwSetWindowRefreshCallback_CMockExpectAndReturn(__LINE__, window, callback, cmock_retval) +void glfwSetWindowRefreshCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWwindowrefreshfun callback, GLFWwindowrefreshfun cmock_to_return); +typedef GLFWwindowrefreshfun (* CMOCK_glfwSetWindowRefreshCallback_CALLBACK)(GLFWwindow* window, GLFWwindowrefreshfun callback, int cmock_num_calls); +void glfwSetWindowRefreshCallback_AddCallback(CMOCK_glfwSetWindowRefreshCallback_CALLBACK Callback); +void glfwSetWindowRefreshCallback_Stub(CMOCK_glfwSetWindowRefreshCallback_CALLBACK Callback); +#define glfwSetWindowRefreshCallback_StubWithCallback glfwSetWindowRefreshCallback_AddCallback +#define glfwSetWindowRefreshCallback_IgnoreArg_window() glfwSetWindowRefreshCallback_CMockIgnoreArg_window(__LINE__) +void glfwSetWindowRefreshCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowRefreshCallback_IgnoreArg_callback() glfwSetWindowRefreshCallback_CMockIgnoreArg_callback(__LINE__) +void glfwSetWindowRefreshCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowFocusCallback_IgnoreAndReturn(cmock_retval) glfwSetWindowFocusCallback_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwSetWindowFocusCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindowfocusfun cmock_to_return); +#define glfwSetWindowFocusCallback_StopIgnore() glfwSetWindowFocusCallback_CMockStopIgnore() +void glfwSetWindowFocusCallback_CMockStopIgnore(void); +#define glfwSetWindowFocusCallback_ExpectAndReturn(window, callback, cmock_retval) glfwSetWindowFocusCallback_CMockExpectAndReturn(__LINE__, window, callback, cmock_retval) +void glfwSetWindowFocusCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWwindowfocusfun callback, GLFWwindowfocusfun cmock_to_return); +typedef GLFWwindowfocusfun (* CMOCK_glfwSetWindowFocusCallback_CALLBACK)(GLFWwindow* window, GLFWwindowfocusfun callback, int cmock_num_calls); +void glfwSetWindowFocusCallback_AddCallback(CMOCK_glfwSetWindowFocusCallback_CALLBACK Callback); +void glfwSetWindowFocusCallback_Stub(CMOCK_glfwSetWindowFocusCallback_CALLBACK Callback); +#define glfwSetWindowFocusCallback_StubWithCallback glfwSetWindowFocusCallback_AddCallback +#define glfwSetWindowFocusCallback_IgnoreArg_window() glfwSetWindowFocusCallback_CMockIgnoreArg_window(__LINE__) +void glfwSetWindowFocusCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowFocusCallback_IgnoreArg_callback() glfwSetWindowFocusCallback_CMockIgnoreArg_callback(__LINE__) +void glfwSetWindowFocusCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowIconifyCallback_IgnoreAndReturn(cmock_retval) glfwSetWindowIconifyCallback_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwSetWindowIconifyCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindowiconifyfun cmock_to_return); +#define glfwSetWindowIconifyCallback_StopIgnore() glfwSetWindowIconifyCallback_CMockStopIgnore() +void glfwSetWindowIconifyCallback_CMockStopIgnore(void); +#define glfwSetWindowIconifyCallback_ExpectAndReturn(window, callback, cmock_retval) glfwSetWindowIconifyCallback_CMockExpectAndReturn(__LINE__, window, callback, cmock_retval) +void glfwSetWindowIconifyCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWwindowiconifyfun callback, GLFWwindowiconifyfun cmock_to_return); +typedef GLFWwindowiconifyfun (* CMOCK_glfwSetWindowIconifyCallback_CALLBACK)(GLFWwindow* window, GLFWwindowiconifyfun callback, int cmock_num_calls); +void glfwSetWindowIconifyCallback_AddCallback(CMOCK_glfwSetWindowIconifyCallback_CALLBACK Callback); +void glfwSetWindowIconifyCallback_Stub(CMOCK_glfwSetWindowIconifyCallback_CALLBACK Callback); +#define glfwSetWindowIconifyCallback_StubWithCallback glfwSetWindowIconifyCallback_AddCallback +#define glfwSetWindowIconifyCallback_IgnoreArg_window() glfwSetWindowIconifyCallback_CMockIgnoreArg_window(__LINE__) +void glfwSetWindowIconifyCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowIconifyCallback_IgnoreArg_callback() glfwSetWindowIconifyCallback_CMockIgnoreArg_callback(__LINE__) +void glfwSetWindowIconifyCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowMaximizeCallback_IgnoreAndReturn(cmock_retval) glfwSetWindowMaximizeCallback_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwSetWindowMaximizeCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindowmaximizefun cmock_to_return); +#define glfwSetWindowMaximizeCallback_StopIgnore() glfwSetWindowMaximizeCallback_CMockStopIgnore() +void glfwSetWindowMaximizeCallback_CMockStopIgnore(void); +#define glfwSetWindowMaximizeCallback_ExpectAndReturn(window, callback, cmock_retval) glfwSetWindowMaximizeCallback_CMockExpectAndReturn(__LINE__, window, callback, cmock_retval) +void glfwSetWindowMaximizeCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWwindowmaximizefun callback, GLFWwindowmaximizefun cmock_to_return); +typedef GLFWwindowmaximizefun (* CMOCK_glfwSetWindowMaximizeCallback_CALLBACK)(GLFWwindow* window, GLFWwindowmaximizefun callback, int cmock_num_calls); +void glfwSetWindowMaximizeCallback_AddCallback(CMOCK_glfwSetWindowMaximizeCallback_CALLBACK Callback); +void glfwSetWindowMaximizeCallback_Stub(CMOCK_glfwSetWindowMaximizeCallback_CALLBACK Callback); +#define glfwSetWindowMaximizeCallback_StubWithCallback glfwSetWindowMaximizeCallback_AddCallback +#define glfwSetWindowMaximizeCallback_IgnoreArg_window() glfwSetWindowMaximizeCallback_CMockIgnoreArg_window(__LINE__) +void glfwSetWindowMaximizeCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowMaximizeCallback_IgnoreArg_callback() glfwSetWindowMaximizeCallback_CMockIgnoreArg_callback(__LINE__) +void glfwSetWindowMaximizeCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line); +#define glfwSetFramebufferSizeCallback_IgnoreAndReturn(cmock_retval) glfwSetFramebufferSizeCallback_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwSetFramebufferSizeCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWframebuffersizefun cmock_to_return); +#define glfwSetFramebufferSizeCallback_StopIgnore() glfwSetFramebufferSizeCallback_CMockStopIgnore() +void glfwSetFramebufferSizeCallback_CMockStopIgnore(void); +#define glfwSetFramebufferSizeCallback_ExpectAndReturn(window, callback, cmock_retval) glfwSetFramebufferSizeCallback_CMockExpectAndReturn(__LINE__, window, callback, cmock_retval) +void glfwSetFramebufferSizeCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWframebuffersizefun callback, GLFWframebuffersizefun cmock_to_return); +typedef GLFWframebuffersizefun (* CMOCK_glfwSetFramebufferSizeCallback_CALLBACK)(GLFWwindow* window, GLFWframebuffersizefun callback, int cmock_num_calls); +void glfwSetFramebufferSizeCallback_AddCallback(CMOCK_glfwSetFramebufferSizeCallback_CALLBACK Callback); +void glfwSetFramebufferSizeCallback_Stub(CMOCK_glfwSetFramebufferSizeCallback_CALLBACK Callback); +#define glfwSetFramebufferSizeCallback_StubWithCallback glfwSetFramebufferSizeCallback_AddCallback +#define glfwSetFramebufferSizeCallback_IgnoreArg_window() glfwSetFramebufferSizeCallback_CMockIgnoreArg_window(__LINE__) +void glfwSetFramebufferSizeCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetFramebufferSizeCallback_IgnoreArg_callback() glfwSetFramebufferSizeCallback_CMockIgnoreArg_callback(__LINE__) +void glfwSetFramebufferSizeCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowContentScaleCallback_IgnoreAndReturn(cmock_retval) glfwSetWindowContentScaleCallback_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwSetWindowContentScaleCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindowcontentscalefun cmock_to_return); +#define glfwSetWindowContentScaleCallback_StopIgnore() glfwSetWindowContentScaleCallback_CMockStopIgnore() +void glfwSetWindowContentScaleCallback_CMockStopIgnore(void); +#define glfwSetWindowContentScaleCallback_ExpectAndReturn(window, callback, cmock_retval) glfwSetWindowContentScaleCallback_CMockExpectAndReturn(__LINE__, window, callback, cmock_retval) +void glfwSetWindowContentScaleCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWwindowcontentscalefun callback, GLFWwindowcontentscalefun cmock_to_return); +typedef GLFWwindowcontentscalefun (* CMOCK_glfwSetWindowContentScaleCallback_CALLBACK)(GLFWwindow* window, GLFWwindowcontentscalefun callback, int cmock_num_calls); +void glfwSetWindowContentScaleCallback_AddCallback(CMOCK_glfwSetWindowContentScaleCallback_CALLBACK Callback); +void glfwSetWindowContentScaleCallback_Stub(CMOCK_glfwSetWindowContentScaleCallback_CALLBACK Callback); +#define glfwSetWindowContentScaleCallback_StubWithCallback glfwSetWindowContentScaleCallback_AddCallback +#define glfwSetWindowContentScaleCallback_IgnoreArg_window() glfwSetWindowContentScaleCallback_CMockIgnoreArg_window(__LINE__) +void glfwSetWindowContentScaleCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetWindowContentScaleCallback_IgnoreArg_callback() glfwSetWindowContentScaleCallback_CMockIgnoreArg_callback(__LINE__) +void glfwSetWindowContentScaleCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line); +#define glfwPollEvents_Ignore() glfwPollEvents_CMockIgnore() +void glfwPollEvents_CMockIgnore(void); +#define glfwPollEvents_StopIgnore() glfwPollEvents_CMockStopIgnore() +void glfwPollEvents_CMockStopIgnore(void); +#define glfwPollEvents_Expect() glfwPollEvents_CMockExpect(__LINE__) +void glfwPollEvents_CMockExpect(UNITY_LINE_TYPE cmock_line); +typedef void (* CMOCK_glfwPollEvents_CALLBACK)(int cmock_num_calls); +void glfwPollEvents_AddCallback(CMOCK_glfwPollEvents_CALLBACK Callback); +void glfwPollEvents_Stub(CMOCK_glfwPollEvents_CALLBACK Callback); +#define glfwPollEvents_StubWithCallback glfwPollEvents_AddCallback +#define glfwWaitEvents_Ignore() glfwWaitEvents_CMockIgnore() +void glfwWaitEvents_CMockIgnore(void); +#define glfwWaitEvents_StopIgnore() glfwWaitEvents_CMockStopIgnore() +void glfwWaitEvents_CMockStopIgnore(void); +#define glfwWaitEvents_Expect() glfwWaitEvents_CMockExpect(__LINE__) +void glfwWaitEvents_CMockExpect(UNITY_LINE_TYPE cmock_line); +typedef void (* CMOCK_glfwWaitEvents_CALLBACK)(int cmock_num_calls); +void glfwWaitEvents_AddCallback(CMOCK_glfwWaitEvents_CALLBACK Callback); +void glfwWaitEvents_Stub(CMOCK_glfwWaitEvents_CALLBACK Callback); +#define glfwWaitEvents_StubWithCallback glfwWaitEvents_AddCallback +#define glfwWaitEventsTimeout_Ignore() glfwWaitEventsTimeout_CMockIgnore() +void glfwWaitEventsTimeout_CMockIgnore(void); +#define glfwWaitEventsTimeout_StopIgnore() glfwWaitEventsTimeout_CMockStopIgnore() +void glfwWaitEventsTimeout_CMockStopIgnore(void); +#define glfwWaitEventsTimeout_Expect(timeout) glfwWaitEventsTimeout_CMockExpect(__LINE__, timeout) +void glfwWaitEventsTimeout_CMockExpect(UNITY_LINE_TYPE cmock_line, double timeout); +typedef void (* CMOCK_glfwWaitEventsTimeout_CALLBACK)(double timeout, int cmock_num_calls); +void glfwWaitEventsTimeout_AddCallback(CMOCK_glfwWaitEventsTimeout_CALLBACK Callback); +void glfwWaitEventsTimeout_Stub(CMOCK_glfwWaitEventsTimeout_CALLBACK Callback); +#define glfwWaitEventsTimeout_StubWithCallback glfwWaitEventsTimeout_AddCallback +#define glfwWaitEventsTimeout_IgnoreArg_timeout() glfwWaitEventsTimeout_CMockIgnoreArg_timeout(__LINE__) +void glfwWaitEventsTimeout_CMockIgnoreArg_timeout(UNITY_LINE_TYPE cmock_line); +#define glfwPostEmptyEvent_Ignore() glfwPostEmptyEvent_CMockIgnore() +void glfwPostEmptyEvent_CMockIgnore(void); +#define glfwPostEmptyEvent_StopIgnore() glfwPostEmptyEvent_CMockStopIgnore() +void glfwPostEmptyEvent_CMockStopIgnore(void); +#define glfwPostEmptyEvent_Expect() glfwPostEmptyEvent_CMockExpect(__LINE__) +void glfwPostEmptyEvent_CMockExpect(UNITY_LINE_TYPE cmock_line); +typedef void (* CMOCK_glfwPostEmptyEvent_CALLBACK)(int cmock_num_calls); +void glfwPostEmptyEvent_AddCallback(CMOCK_glfwPostEmptyEvent_CALLBACK Callback); +void glfwPostEmptyEvent_Stub(CMOCK_glfwPostEmptyEvent_CALLBACK Callback); +#define glfwPostEmptyEvent_StubWithCallback glfwPostEmptyEvent_AddCallback +#define glfwGetInputMode_IgnoreAndReturn(cmock_retval) glfwGetInputMode_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetInputMode_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define glfwGetInputMode_StopIgnore() glfwGetInputMode_CMockStopIgnore() +void glfwGetInputMode_CMockStopIgnore(void); +#define glfwGetInputMode_ExpectAndReturn(window, mode, cmock_retval) glfwGetInputMode_CMockExpectAndReturn(__LINE__, window, mode, cmock_retval) +void glfwGetInputMode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int mode, int cmock_to_return); +typedef int (* CMOCK_glfwGetInputMode_CALLBACK)(GLFWwindow* window, int mode, int cmock_num_calls); +void glfwGetInputMode_AddCallback(CMOCK_glfwGetInputMode_CALLBACK Callback); +void glfwGetInputMode_Stub(CMOCK_glfwGetInputMode_CALLBACK Callback); +#define glfwGetInputMode_StubWithCallback glfwGetInputMode_AddCallback +#define glfwGetInputMode_IgnoreArg_window() glfwGetInputMode_CMockIgnoreArg_window(__LINE__) +void glfwGetInputMode_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwGetInputMode_IgnoreArg_mode() glfwGetInputMode_CMockIgnoreArg_mode(__LINE__) +void glfwGetInputMode_CMockIgnoreArg_mode(UNITY_LINE_TYPE cmock_line); +#define glfwSetInputMode_Ignore() glfwSetInputMode_CMockIgnore() +void glfwSetInputMode_CMockIgnore(void); +#define glfwSetInputMode_StopIgnore() glfwSetInputMode_CMockStopIgnore() +void glfwSetInputMode_CMockStopIgnore(void); +#define glfwSetInputMode_Expect(window, mode, value) glfwSetInputMode_CMockExpect(__LINE__, window, mode, value) +void glfwSetInputMode_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int mode, int value); +typedef void (* CMOCK_glfwSetInputMode_CALLBACK)(GLFWwindow* window, int mode, int value, int cmock_num_calls); +void glfwSetInputMode_AddCallback(CMOCK_glfwSetInputMode_CALLBACK Callback); +void glfwSetInputMode_Stub(CMOCK_glfwSetInputMode_CALLBACK Callback); +#define glfwSetInputMode_StubWithCallback glfwSetInputMode_AddCallback +#define glfwSetInputMode_IgnoreArg_window() glfwSetInputMode_CMockIgnoreArg_window(__LINE__) +void glfwSetInputMode_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetInputMode_IgnoreArg_mode() glfwSetInputMode_CMockIgnoreArg_mode(__LINE__) +void glfwSetInputMode_CMockIgnoreArg_mode(UNITY_LINE_TYPE cmock_line); +#define glfwSetInputMode_IgnoreArg_value() glfwSetInputMode_CMockIgnoreArg_value(__LINE__) +void glfwSetInputMode_CMockIgnoreArg_value(UNITY_LINE_TYPE cmock_line); +#define glfwRawMouseMotionSupported_IgnoreAndReturn(cmock_retval) glfwRawMouseMotionSupported_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwRawMouseMotionSupported_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define glfwRawMouseMotionSupported_StopIgnore() glfwRawMouseMotionSupported_CMockStopIgnore() +void glfwRawMouseMotionSupported_CMockStopIgnore(void); +#define glfwRawMouseMotionSupported_ExpectAndReturn(cmock_retval) glfwRawMouseMotionSupported_CMockExpectAndReturn(__LINE__, cmock_retval) +void glfwRawMouseMotionSupported_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +typedef int (* CMOCK_glfwRawMouseMotionSupported_CALLBACK)(int cmock_num_calls); +void glfwRawMouseMotionSupported_AddCallback(CMOCK_glfwRawMouseMotionSupported_CALLBACK Callback); +void glfwRawMouseMotionSupported_Stub(CMOCK_glfwRawMouseMotionSupported_CALLBACK Callback); +#define glfwRawMouseMotionSupported_StubWithCallback glfwRawMouseMotionSupported_AddCallback +#define glfwGetKeyName_IgnoreAndReturn(cmock_retval) glfwGetKeyName_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetKeyName_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, const char* cmock_to_return); +#define glfwGetKeyName_StopIgnore() glfwGetKeyName_CMockStopIgnore() +void glfwGetKeyName_CMockStopIgnore(void); +#define glfwGetKeyName_ExpectAndReturn(key, scancode, cmock_retval) glfwGetKeyName_CMockExpectAndReturn(__LINE__, key, scancode, cmock_retval) +void glfwGetKeyName_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int key, int scancode, const char* cmock_to_return); +typedef const char* (* CMOCK_glfwGetKeyName_CALLBACK)(int key, int scancode, int cmock_num_calls); +void glfwGetKeyName_AddCallback(CMOCK_glfwGetKeyName_CALLBACK Callback); +void glfwGetKeyName_Stub(CMOCK_glfwGetKeyName_CALLBACK Callback); +#define glfwGetKeyName_StubWithCallback glfwGetKeyName_AddCallback +#define glfwGetKeyName_IgnoreArg_key() glfwGetKeyName_CMockIgnoreArg_key(__LINE__) +void glfwGetKeyName_CMockIgnoreArg_key(UNITY_LINE_TYPE cmock_line); +#define glfwGetKeyName_IgnoreArg_scancode() glfwGetKeyName_CMockIgnoreArg_scancode(__LINE__) +void glfwGetKeyName_CMockIgnoreArg_scancode(UNITY_LINE_TYPE cmock_line); +#define glfwGetKeyScancode_IgnoreAndReturn(cmock_retval) glfwGetKeyScancode_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetKeyScancode_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define glfwGetKeyScancode_StopIgnore() glfwGetKeyScancode_CMockStopIgnore() +void glfwGetKeyScancode_CMockStopIgnore(void); +#define glfwGetKeyScancode_ExpectAndReturn(key, cmock_retval) glfwGetKeyScancode_CMockExpectAndReturn(__LINE__, key, cmock_retval) +void glfwGetKeyScancode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int key, int cmock_to_return); +typedef int (* CMOCK_glfwGetKeyScancode_CALLBACK)(int key, int cmock_num_calls); +void glfwGetKeyScancode_AddCallback(CMOCK_glfwGetKeyScancode_CALLBACK Callback); +void glfwGetKeyScancode_Stub(CMOCK_glfwGetKeyScancode_CALLBACK Callback); +#define glfwGetKeyScancode_StubWithCallback glfwGetKeyScancode_AddCallback +#define glfwGetKeyScancode_IgnoreArg_key() glfwGetKeyScancode_CMockIgnoreArg_key(__LINE__) +void glfwGetKeyScancode_CMockIgnoreArg_key(UNITY_LINE_TYPE cmock_line); +#define glfwGetKey_IgnoreAndReturn(cmock_retval) glfwGetKey_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetKey_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define glfwGetKey_StopIgnore() glfwGetKey_CMockStopIgnore() +void glfwGetKey_CMockStopIgnore(void); +#define glfwGetKey_ExpectAndReturn(window, key, cmock_retval) glfwGetKey_CMockExpectAndReturn(__LINE__, window, key, cmock_retval) +void glfwGetKey_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int key, int cmock_to_return); +typedef int (* CMOCK_glfwGetKey_CALLBACK)(GLFWwindow* window, int key, int cmock_num_calls); +void glfwGetKey_AddCallback(CMOCK_glfwGetKey_CALLBACK Callback); +void glfwGetKey_Stub(CMOCK_glfwGetKey_CALLBACK Callback); +#define glfwGetKey_StubWithCallback glfwGetKey_AddCallback +#define glfwGetKey_IgnoreArg_window() glfwGetKey_CMockIgnoreArg_window(__LINE__) +void glfwGetKey_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwGetKey_IgnoreArg_key() glfwGetKey_CMockIgnoreArg_key(__LINE__) +void glfwGetKey_CMockIgnoreArg_key(UNITY_LINE_TYPE cmock_line); +#define glfwGetMouseButton_IgnoreAndReturn(cmock_retval) glfwGetMouseButton_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetMouseButton_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define glfwGetMouseButton_StopIgnore() glfwGetMouseButton_CMockStopIgnore() +void glfwGetMouseButton_CMockStopIgnore(void); +#define glfwGetMouseButton_ExpectAndReturn(window, button, cmock_retval) glfwGetMouseButton_CMockExpectAndReturn(__LINE__, window, button, cmock_retval) +void glfwGetMouseButton_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, int button, int cmock_to_return); +typedef int (* CMOCK_glfwGetMouseButton_CALLBACK)(GLFWwindow* window, int button, int cmock_num_calls); +void glfwGetMouseButton_AddCallback(CMOCK_glfwGetMouseButton_CALLBACK Callback); +void glfwGetMouseButton_Stub(CMOCK_glfwGetMouseButton_CALLBACK Callback); +#define glfwGetMouseButton_StubWithCallback glfwGetMouseButton_AddCallback +#define glfwGetMouseButton_IgnoreArg_window() glfwGetMouseButton_CMockIgnoreArg_window(__LINE__) +void glfwGetMouseButton_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwGetMouseButton_IgnoreArg_button() glfwGetMouseButton_CMockIgnoreArg_button(__LINE__) +void glfwGetMouseButton_CMockIgnoreArg_button(UNITY_LINE_TYPE cmock_line); +#define glfwGetCursorPos_Ignore() glfwGetCursorPos_CMockIgnore() +void glfwGetCursorPos_CMockIgnore(void); +#define glfwGetCursorPos_StopIgnore() glfwGetCursorPos_CMockStopIgnore() +void glfwGetCursorPos_CMockStopIgnore(void); +#define glfwGetCursorPos_Expect(window, xpos, ypos) glfwGetCursorPos_CMockExpect(__LINE__, window, xpos, ypos) +void glfwGetCursorPos_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, double* xpos, double* ypos); +typedef void (* CMOCK_glfwGetCursorPos_CALLBACK)(GLFWwindow* window, double* xpos, double* ypos, int cmock_num_calls); +void glfwGetCursorPos_AddCallback(CMOCK_glfwGetCursorPos_CALLBACK Callback); +void glfwGetCursorPos_Stub(CMOCK_glfwGetCursorPos_CALLBACK Callback); +#define glfwGetCursorPos_StubWithCallback glfwGetCursorPos_AddCallback +#define glfwGetCursorPos_IgnoreArg_window() glfwGetCursorPos_CMockIgnoreArg_window(__LINE__) +void glfwGetCursorPos_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwGetCursorPos_IgnoreArg_xpos() glfwGetCursorPos_CMockIgnoreArg_xpos(__LINE__) +void glfwGetCursorPos_CMockIgnoreArg_xpos(UNITY_LINE_TYPE cmock_line); +#define glfwGetCursorPos_IgnoreArg_ypos() glfwGetCursorPos_CMockIgnoreArg_ypos(__LINE__) +void glfwGetCursorPos_CMockIgnoreArg_ypos(UNITY_LINE_TYPE cmock_line); +#define glfwSetCursorPos_Ignore() glfwSetCursorPos_CMockIgnore() +void glfwSetCursorPos_CMockIgnore(void); +#define glfwSetCursorPos_StopIgnore() glfwSetCursorPos_CMockStopIgnore() +void glfwSetCursorPos_CMockStopIgnore(void); +#define glfwSetCursorPos_Expect(window, xpos, ypos) glfwSetCursorPos_CMockExpect(__LINE__, window, xpos, ypos) +void glfwSetCursorPos_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, double xpos, double ypos); +typedef void (* CMOCK_glfwSetCursorPos_CALLBACK)(GLFWwindow* window, double xpos, double ypos, int cmock_num_calls); +void glfwSetCursorPos_AddCallback(CMOCK_glfwSetCursorPos_CALLBACK Callback); +void glfwSetCursorPos_Stub(CMOCK_glfwSetCursorPos_CALLBACK Callback); +#define glfwSetCursorPos_StubWithCallback glfwSetCursorPos_AddCallback +#define glfwSetCursorPos_IgnoreArg_window() glfwSetCursorPos_CMockIgnoreArg_window(__LINE__) +void glfwSetCursorPos_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetCursorPos_IgnoreArg_xpos() glfwSetCursorPos_CMockIgnoreArg_xpos(__LINE__) +void glfwSetCursorPos_CMockIgnoreArg_xpos(UNITY_LINE_TYPE cmock_line); +#define glfwSetCursorPos_IgnoreArg_ypos() glfwSetCursorPos_CMockIgnoreArg_ypos(__LINE__) +void glfwSetCursorPos_CMockIgnoreArg_ypos(UNITY_LINE_TYPE cmock_line); +#define glfwCreateCursor_IgnoreAndReturn(cmock_retval) glfwCreateCursor_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwCreateCursor_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWcursor* cmock_to_return); +#define glfwCreateCursor_StopIgnore() glfwCreateCursor_CMockStopIgnore() +void glfwCreateCursor_CMockStopIgnore(void); +#define glfwCreateCursor_ExpectAndReturn(image, xhot, yhot, cmock_retval) glfwCreateCursor_CMockExpectAndReturn(__LINE__, image, xhot, yhot, cmock_retval) +void glfwCreateCursor_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, const GLFWimage* image, int xhot, int yhot, GLFWcursor* cmock_to_return); +typedef GLFWcursor* (* CMOCK_glfwCreateCursor_CALLBACK)(const GLFWimage* image, int xhot, int yhot, int cmock_num_calls); +void glfwCreateCursor_AddCallback(CMOCK_glfwCreateCursor_CALLBACK Callback); +void glfwCreateCursor_Stub(CMOCK_glfwCreateCursor_CALLBACK Callback); +#define glfwCreateCursor_StubWithCallback glfwCreateCursor_AddCallback +#define glfwCreateCursor_IgnoreArg_image() glfwCreateCursor_CMockIgnoreArg_image(__LINE__) +void glfwCreateCursor_CMockIgnoreArg_image(UNITY_LINE_TYPE cmock_line); +#define glfwCreateCursor_IgnoreArg_xhot() glfwCreateCursor_CMockIgnoreArg_xhot(__LINE__) +void glfwCreateCursor_CMockIgnoreArg_xhot(UNITY_LINE_TYPE cmock_line); +#define glfwCreateCursor_IgnoreArg_yhot() glfwCreateCursor_CMockIgnoreArg_yhot(__LINE__) +void glfwCreateCursor_CMockIgnoreArg_yhot(UNITY_LINE_TYPE cmock_line); +#define glfwCreateStandardCursor_IgnoreAndReturn(cmock_retval) glfwCreateStandardCursor_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwCreateStandardCursor_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWcursor* cmock_to_return); +#define glfwCreateStandardCursor_StopIgnore() glfwCreateStandardCursor_CMockStopIgnore() +void glfwCreateStandardCursor_CMockStopIgnore(void); +#define glfwCreateStandardCursor_ExpectAndReturn(shape, cmock_retval) glfwCreateStandardCursor_CMockExpectAndReturn(__LINE__, shape, cmock_retval) +void glfwCreateStandardCursor_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int shape, GLFWcursor* cmock_to_return); +typedef GLFWcursor* (* CMOCK_glfwCreateStandardCursor_CALLBACK)(int shape, int cmock_num_calls); +void glfwCreateStandardCursor_AddCallback(CMOCK_glfwCreateStandardCursor_CALLBACK Callback); +void glfwCreateStandardCursor_Stub(CMOCK_glfwCreateStandardCursor_CALLBACK Callback); +#define glfwCreateStandardCursor_StubWithCallback glfwCreateStandardCursor_AddCallback +#define glfwCreateStandardCursor_IgnoreArg_shape() glfwCreateStandardCursor_CMockIgnoreArg_shape(__LINE__) +void glfwCreateStandardCursor_CMockIgnoreArg_shape(UNITY_LINE_TYPE cmock_line); +#define glfwDestroyCursor_Ignore() glfwDestroyCursor_CMockIgnore() +void glfwDestroyCursor_CMockIgnore(void); +#define glfwDestroyCursor_StopIgnore() glfwDestroyCursor_CMockStopIgnore() +void glfwDestroyCursor_CMockStopIgnore(void); +#define glfwDestroyCursor_Expect(cursor) glfwDestroyCursor_CMockExpect(__LINE__, cursor) +void glfwDestroyCursor_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWcursor* cursor); +typedef void (* CMOCK_glfwDestroyCursor_CALLBACK)(GLFWcursor* cursor, int cmock_num_calls); +void glfwDestroyCursor_AddCallback(CMOCK_glfwDestroyCursor_CALLBACK Callback); +void glfwDestroyCursor_Stub(CMOCK_glfwDestroyCursor_CALLBACK Callback); +#define glfwDestroyCursor_StubWithCallback glfwDestroyCursor_AddCallback +#define glfwDestroyCursor_IgnoreArg_cursor() glfwDestroyCursor_CMockIgnoreArg_cursor(__LINE__) +void glfwDestroyCursor_CMockIgnoreArg_cursor(UNITY_LINE_TYPE cmock_line); +#define glfwSetCursor_Ignore() glfwSetCursor_CMockIgnore() +void glfwSetCursor_CMockIgnore(void); +#define glfwSetCursor_StopIgnore() glfwSetCursor_CMockStopIgnore() +void glfwSetCursor_CMockStopIgnore(void); +#define glfwSetCursor_Expect(window, cursor) glfwSetCursor_CMockExpect(__LINE__, window, cursor) +void glfwSetCursor_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWcursor* cursor); +typedef void (* CMOCK_glfwSetCursor_CALLBACK)(GLFWwindow* window, GLFWcursor* cursor, int cmock_num_calls); +void glfwSetCursor_AddCallback(CMOCK_glfwSetCursor_CALLBACK Callback); +void glfwSetCursor_Stub(CMOCK_glfwSetCursor_CALLBACK Callback); +#define glfwSetCursor_StubWithCallback glfwSetCursor_AddCallback +#define glfwSetCursor_IgnoreArg_window() glfwSetCursor_CMockIgnoreArg_window(__LINE__) +void glfwSetCursor_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetCursor_IgnoreArg_cursor() glfwSetCursor_CMockIgnoreArg_cursor(__LINE__) +void glfwSetCursor_CMockIgnoreArg_cursor(UNITY_LINE_TYPE cmock_line); +#define glfwSetKeyCallback_IgnoreAndReturn(cmock_retval) glfwSetKeyCallback_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwSetKeyCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWkeyfun cmock_to_return); +#define glfwSetKeyCallback_StopIgnore() glfwSetKeyCallback_CMockStopIgnore() +void glfwSetKeyCallback_CMockStopIgnore(void); +#define glfwSetKeyCallback_ExpectAndReturn(window, callback, cmock_retval) glfwSetKeyCallback_CMockExpectAndReturn(__LINE__, window, callback, cmock_retval) +void glfwSetKeyCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWkeyfun callback, GLFWkeyfun cmock_to_return); +typedef GLFWkeyfun (* CMOCK_glfwSetKeyCallback_CALLBACK)(GLFWwindow* window, GLFWkeyfun callback, int cmock_num_calls); +void glfwSetKeyCallback_AddCallback(CMOCK_glfwSetKeyCallback_CALLBACK Callback); +void glfwSetKeyCallback_Stub(CMOCK_glfwSetKeyCallback_CALLBACK Callback); +#define glfwSetKeyCallback_StubWithCallback glfwSetKeyCallback_AddCallback +#define glfwSetKeyCallback_IgnoreArg_window() glfwSetKeyCallback_CMockIgnoreArg_window(__LINE__) +void glfwSetKeyCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetKeyCallback_IgnoreArg_callback() glfwSetKeyCallback_CMockIgnoreArg_callback(__LINE__) +void glfwSetKeyCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line); +#define glfwSetCharCallback_IgnoreAndReturn(cmock_retval) glfwSetCharCallback_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwSetCharCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWcharfun cmock_to_return); +#define glfwSetCharCallback_StopIgnore() glfwSetCharCallback_CMockStopIgnore() +void glfwSetCharCallback_CMockStopIgnore(void); +#define glfwSetCharCallback_ExpectAndReturn(window, callback, cmock_retval) glfwSetCharCallback_CMockExpectAndReturn(__LINE__, window, callback, cmock_retval) +void glfwSetCharCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWcharfun callback, GLFWcharfun cmock_to_return); +typedef GLFWcharfun (* CMOCK_glfwSetCharCallback_CALLBACK)(GLFWwindow* window, GLFWcharfun callback, int cmock_num_calls); +void glfwSetCharCallback_AddCallback(CMOCK_glfwSetCharCallback_CALLBACK Callback); +void glfwSetCharCallback_Stub(CMOCK_glfwSetCharCallback_CALLBACK Callback); +#define glfwSetCharCallback_StubWithCallback glfwSetCharCallback_AddCallback +#define glfwSetCharCallback_IgnoreArg_window() glfwSetCharCallback_CMockIgnoreArg_window(__LINE__) +void glfwSetCharCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetCharCallback_IgnoreArg_callback() glfwSetCharCallback_CMockIgnoreArg_callback(__LINE__) +void glfwSetCharCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line); +#define glfwSetCharModsCallback_IgnoreAndReturn(cmock_retval) glfwSetCharModsCallback_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwSetCharModsCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWcharmodsfun cmock_to_return); +#define glfwSetCharModsCallback_StopIgnore() glfwSetCharModsCallback_CMockStopIgnore() +void glfwSetCharModsCallback_CMockStopIgnore(void); +#define glfwSetCharModsCallback_ExpectAndReturn(window, callback, cmock_retval) glfwSetCharModsCallback_CMockExpectAndReturn(__LINE__, window, callback, cmock_retval) +void glfwSetCharModsCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWcharmodsfun callback, GLFWcharmodsfun cmock_to_return); +typedef GLFWcharmodsfun (* CMOCK_glfwSetCharModsCallback_CALLBACK)(GLFWwindow* window, GLFWcharmodsfun callback, int cmock_num_calls); +void glfwSetCharModsCallback_AddCallback(CMOCK_glfwSetCharModsCallback_CALLBACK Callback); +void glfwSetCharModsCallback_Stub(CMOCK_glfwSetCharModsCallback_CALLBACK Callback); +#define glfwSetCharModsCallback_StubWithCallback glfwSetCharModsCallback_AddCallback +#define glfwSetCharModsCallback_IgnoreArg_window() glfwSetCharModsCallback_CMockIgnoreArg_window(__LINE__) +void glfwSetCharModsCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetCharModsCallback_IgnoreArg_callback() glfwSetCharModsCallback_CMockIgnoreArg_callback(__LINE__) +void glfwSetCharModsCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line); +#define glfwSetMouseButtonCallback_IgnoreAndReturn(cmock_retval) glfwSetMouseButtonCallback_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwSetMouseButtonCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWmousebuttonfun cmock_to_return); +#define glfwSetMouseButtonCallback_StopIgnore() glfwSetMouseButtonCallback_CMockStopIgnore() +void glfwSetMouseButtonCallback_CMockStopIgnore(void); +#define glfwSetMouseButtonCallback_ExpectAndReturn(window, callback, cmock_retval) glfwSetMouseButtonCallback_CMockExpectAndReturn(__LINE__, window, callback, cmock_retval) +void glfwSetMouseButtonCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWmousebuttonfun callback, GLFWmousebuttonfun cmock_to_return); +typedef GLFWmousebuttonfun (* CMOCK_glfwSetMouseButtonCallback_CALLBACK)(GLFWwindow* window, GLFWmousebuttonfun callback, int cmock_num_calls); +void glfwSetMouseButtonCallback_AddCallback(CMOCK_glfwSetMouseButtonCallback_CALLBACK Callback); +void glfwSetMouseButtonCallback_Stub(CMOCK_glfwSetMouseButtonCallback_CALLBACK Callback); +#define glfwSetMouseButtonCallback_StubWithCallback glfwSetMouseButtonCallback_AddCallback +#define glfwSetMouseButtonCallback_IgnoreArg_window() glfwSetMouseButtonCallback_CMockIgnoreArg_window(__LINE__) +void glfwSetMouseButtonCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetMouseButtonCallback_IgnoreArg_callback() glfwSetMouseButtonCallback_CMockIgnoreArg_callback(__LINE__) +void glfwSetMouseButtonCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line); +#define glfwSetCursorPosCallback_IgnoreAndReturn(cmock_retval) glfwSetCursorPosCallback_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwSetCursorPosCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWcursorposfun cmock_to_return); +#define glfwSetCursorPosCallback_StopIgnore() glfwSetCursorPosCallback_CMockStopIgnore() +void glfwSetCursorPosCallback_CMockStopIgnore(void); +#define glfwSetCursorPosCallback_ExpectAndReturn(window, callback, cmock_retval) glfwSetCursorPosCallback_CMockExpectAndReturn(__LINE__, window, callback, cmock_retval) +void glfwSetCursorPosCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWcursorposfun callback, GLFWcursorposfun cmock_to_return); +typedef GLFWcursorposfun (* CMOCK_glfwSetCursorPosCallback_CALLBACK)(GLFWwindow* window, GLFWcursorposfun callback, int cmock_num_calls); +void glfwSetCursorPosCallback_AddCallback(CMOCK_glfwSetCursorPosCallback_CALLBACK Callback); +void glfwSetCursorPosCallback_Stub(CMOCK_glfwSetCursorPosCallback_CALLBACK Callback); +#define glfwSetCursorPosCallback_StubWithCallback glfwSetCursorPosCallback_AddCallback +#define glfwSetCursorPosCallback_IgnoreArg_window() glfwSetCursorPosCallback_CMockIgnoreArg_window(__LINE__) +void glfwSetCursorPosCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetCursorPosCallback_IgnoreArg_callback() glfwSetCursorPosCallback_CMockIgnoreArg_callback(__LINE__) +void glfwSetCursorPosCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line); +#define glfwSetCursorEnterCallback_IgnoreAndReturn(cmock_retval) glfwSetCursorEnterCallback_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwSetCursorEnterCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWcursorenterfun cmock_to_return); +#define glfwSetCursorEnterCallback_StopIgnore() glfwSetCursorEnterCallback_CMockStopIgnore() +void glfwSetCursorEnterCallback_CMockStopIgnore(void); +#define glfwSetCursorEnterCallback_ExpectAndReturn(window, callback, cmock_retval) glfwSetCursorEnterCallback_CMockExpectAndReturn(__LINE__, window, callback, cmock_retval) +void glfwSetCursorEnterCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWcursorenterfun callback, GLFWcursorenterfun cmock_to_return); +typedef GLFWcursorenterfun (* CMOCK_glfwSetCursorEnterCallback_CALLBACK)(GLFWwindow* window, GLFWcursorenterfun callback, int cmock_num_calls); +void glfwSetCursorEnterCallback_AddCallback(CMOCK_glfwSetCursorEnterCallback_CALLBACK Callback); +void glfwSetCursorEnterCallback_Stub(CMOCK_glfwSetCursorEnterCallback_CALLBACK Callback); +#define glfwSetCursorEnterCallback_StubWithCallback glfwSetCursorEnterCallback_AddCallback +#define glfwSetCursorEnterCallback_IgnoreArg_window() glfwSetCursorEnterCallback_CMockIgnoreArg_window(__LINE__) +void glfwSetCursorEnterCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetCursorEnterCallback_IgnoreArg_callback() glfwSetCursorEnterCallback_CMockIgnoreArg_callback(__LINE__) +void glfwSetCursorEnterCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line); +#define glfwSetScrollCallback_IgnoreAndReturn(cmock_retval) glfwSetScrollCallback_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwSetScrollCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWscrollfun cmock_to_return); +#define glfwSetScrollCallback_StopIgnore() glfwSetScrollCallback_CMockStopIgnore() +void glfwSetScrollCallback_CMockStopIgnore(void); +#define glfwSetScrollCallback_ExpectAndReturn(window, callback, cmock_retval) glfwSetScrollCallback_CMockExpectAndReturn(__LINE__, window, callback, cmock_retval) +void glfwSetScrollCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWscrollfun callback, GLFWscrollfun cmock_to_return); +typedef GLFWscrollfun (* CMOCK_glfwSetScrollCallback_CALLBACK)(GLFWwindow* window, GLFWscrollfun callback, int cmock_num_calls); +void glfwSetScrollCallback_AddCallback(CMOCK_glfwSetScrollCallback_CALLBACK Callback); +void glfwSetScrollCallback_Stub(CMOCK_glfwSetScrollCallback_CALLBACK Callback); +#define glfwSetScrollCallback_StubWithCallback glfwSetScrollCallback_AddCallback +#define glfwSetScrollCallback_IgnoreArg_window() glfwSetScrollCallback_CMockIgnoreArg_window(__LINE__) +void glfwSetScrollCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetScrollCallback_IgnoreArg_callback() glfwSetScrollCallback_CMockIgnoreArg_callback(__LINE__) +void glfwSetScrollCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line); +#define glfwSetDropCallback_IgnoreAndReturn(cmock_retval) glfwSetDropCallback_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwSetDropCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWdropfun cmock_to_return); +#define glfwSetDropCallback_StopIgnore() glfwSetDropCallback_CMockStopIgnore() +void glfwSetDropCallback_CMockStopIgnore(void); +#define glfwSetDropCallback_ExpectAndReturn(window, callback, cmock_retval) glfwSetDropCallback_CMockExpectAndReturn(__LINE__, window, callback, cmock_retval) +void glfwSetDropCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, GLFWdropfun callback, GLFWdropfun cmock_to_return); +typedef GLFWdropfun (* CMOCK_glfwSetDropCallback_CALLBACK)(GLFWwindow* window, GLFWdropfun callback, int cmock_num_calls); +void glfwSetDropCallback_AddCallback(CMOCK_glfwSetDropCallback_CALLBACK Callback); +void glfwSetDropCallback_Stub(CMOCK_glfwSetDropCallback_CALLBACK Callback); +#define glfwSetDropCallback_StubWithCallback glfwSetDropCallback_AddCallback +#define glfwSetDropCallback_IgnoreArg_window() glfwSetDropCallback_CMockIgnoreArg_window(__LINE__) +void glfwSetDropCallback_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetDropCallback_IgnoreArg_callback() glfwSetDropCallback_CMockIgnoreArg_callback(__LINE__) +void glfwSetDropCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line); +#define glfwJoystickPresent_IgnoreAndReturn(cmock_retval) glfwJoystickPresent_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwJoystickPresent_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define glfwJoystickPresent_StopIgnore() glfwJoystickPresent_CMockStopIgnore() +void glfwJoystickPresent_CMockStopIgnore(void); +#define glfwJoystickPresent_ExpectAndReturn(jid, cmock_retval) glfwJoystickPresent_CMockExpectAndReturn(__LINE__, jid, cmock_retval) +void glfwJoystickPresent_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int jid, int cmock_to_return); +typedef int (* CMOCK_glfwJoystickPresent_CALLBACK)(int jid, int cmock_num_calls); +void glfwJoystickPresent_AddCallback(CMOCK_glfwJoystickPresent_CALLBACK Callback); +void glfwJoystickPresent_Stub(CMOCK_glfwJoystickPresent_CALLBACK Callback); +#define glfwJoystickPresent_StubWithCallback glfwJoystickPresent_AddCallback +#define glfwJoystickPresent_IgnoreArg_jid() glfwJoystickPresent_CMockIgnoreArg_jid(__LINE__) +void glfwJoystickPresent_CMockIgnoreArg_jid(UNITY_LINE_TYPE cmock_line); +#define glfwGetJoystickAxes_IgnoreAndReturn(cmock_retval) glfwGetJoystickAxes_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetJoystickAxes_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, const float* cmock_to_return); +#define glfwGetJoystickAxes_StopIgnore() glfwGetJoystickAxes_CMockStopIgnore() +void glfwGetJoystickAxes_CMockStopIgnore(void); +#define glfwGetJoystickAxes_ExpectAndReturn(jid, count, cmock_retval) glfwGetJoystickAxes_CMockExpectAndReturn(__LINE__, jid, count, cmock_retval) +void glfwGetJoystickAxes_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int jid, int* count, const float* cmock_to_return); +typedef const float* (* CMOCK_glfwGetJoystickAxes_CALLBACK)(int jid, int* count, int cmock_num_calls); +void glfwGetJoystickAxes_AddCallback(CMOCK_glfwGetJoystickAxes_CALLBACK Callback); +void glfwGetJoystickAxes_Stub(CMOCK_glfwGetJoystickAxes_CALLBACK Callback); +#define glfwGetJoystickAxes_StubWithCallback glfwGetJoystickAxes_AddCallback +#define glfwGetJoystickAxes_IgnoreArg_jid() glfwGetJoystickAxes_CMockIgnoreArg_jid(__LINE__) +void glfwGetJoystickAxes_CMockIgnoreArg_jid(UNITY_LINE_TYPE cmock_line); +#define glfwGetJoystickAxes_IgnoreArg_count() glfwGetJoystickAxes_CMockIgnoreArg_count(__LINE__) +void glfwGetJoystickAxes_CMockIgnoreArg_count(UNITY_LINE_TYPE cmock_line); +#define glfwGetJoystickButtons_IgnoreAndReturn(cmock_retval) glfwGetJoystickButtons_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetJoystickButtons_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, const unsigned char* cmock_to_return); +#define glfwGetJoystickButtons_StopIgnore() glfwGetJoystickButtons_CMockStopIgnore() +void glfwGetJoystickButtons_CMockStopIgnore(void); +#define glfwGetJoystickButtons_ExpectAndReturn(jid, count, cmock_retval) glfwGetJoystickButtons_CMockExpectAndReturn(__LINE__, jid, count, cmock_retval) +void glfwGetJoystickButtons_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int jid, int* count, const unsigned char* cmock_to_return); +typedef const unsigned char* (* CMOCK_glfwGetJoystickButtons_CALLBACK)(int jid, int* count, int cmock_num_calls); +void glfwGetJoystickButtons_AddCallback(CMOCK_glfwGetJoystickButtons_CALLBACK Callback); +void glfwGetJoystickButtons_Stub(CMOCK_glfwGetJoystickButtons_CALLBACK Callback); +#define glfwGetJoystickButtons_StubWithCallback glfwGetJoystickButtons_AddCallback +#define glfwGetJoystickButtons_IgnoreArg_jid() glfwGetJoystickButtons_CMockIgnoreArg_jid(__LINE__) +void glfwGetJoystickButtons_CMockIgnoreArg_jid(UNITY_LINE_TYPE cmock_line); +#define glfwGetJoystickButtons_IgnoreArg_count() glfwGetJoystickButtons_CMockIgnoreArg_count(__LINE__) +void glfwGetJoystickButtons_CMockIgnoreArg_count(UNITY_LINE_TYPE cmock_line); +#define glfwGetJoystickHats_IgnoreAndReturn(cmock_retval) glfwGetJoystickHats_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetJoystickHats_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, const unsigned char* cmock_to_return); +#define glfwGetJoystickHats_StopIgnore() glfwGetJoystickHats_CMockStopIgnore() +void glfwGetJoystickHats_CMockStopIgnore(void); +#define glfwGetJoystickHats_ExpectAndReturn(jid, count, cmock_retval) glfwGetJoystickHats_CMockExpectAndReturn(__LINE__, jid, count, cmock_retval) +void glfwGetJoystickHats_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int jid, int* count, const unsigned char* cmock_to_return); +typedef const unsigned char* (* CMOCK_glfwGetJoystickHats_CALLBACK)(int jid, int* count, int cmock_num_calls); +void glfwGetJoystickHats_AddCallback(CMOCK_glfwGetJoystickHats_CALLBACK Callback); +void glfwGetJoystickHats_Stub(CMOCK_glfwGetJoystickHats_CALLBACK Callback); +#define glfwGetJoystickHats_StubWithCallback glfwGetJoystickHats_AddCallback +#define glfwGetJoystickHats_IgnoreArg_jid() glfwGetJoystickHats_CMockIgnoreArg_jid(__LINE__) +void glfwGetJoystickHats_CMockIgnoreArg_jid(UNITY_LINE_TYPE cmock_line); +#define glfwGetJoystickHats_IgnoreArg_count() glfwGetJoystickHats_CMockIgnoreArg_count(__LINE__) +void glfwGetJoystickHats_CMockIgnoreArg_count(UNITY_LINE_TYPE cmock_line); +#define glfwGetJoystickName_IgnoreAndReturn(cmock_retval) glfwGetJoystickName_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetJoystickName_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, const char* cmock_to_return); +#define glfwGetJoystickName_StopIgnore() glfwGetJoystickName_CMockStopIgnore() +void glfwGetJoystickName_CMockStopIgnore(void); +#define glfwGetJoystickName_ExpectAndReturn(jid, cmock_retval) glfwGetJoystickName_CMockExpectAndReturn(__LINE__, jid, cmock_retval) +void glfwGetJoystickName_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int jid, const char* cmock_to_return); +typedef const char* (* CMOCK_glfwGetJoystickName_CALLBACK)(int jid, int cmock_num_calls); +void glfwGetJoystickName_AddCallback(CMOCK_glfwGetJoystickName_CALLBACK Callback); +void glfwGetJoystickName_Stub(CMOCK_glfwGetJoystickName_CALLBACK Callback); +#define glfwGetJoystickName_StubWithCallback glfwGetJoystickName_AddCallback +#define glfwGetJoystickName_IgnoreArg_jid() glfwGetJoystickName_CMockIgnoreArg_jid(__LINE__) +void glfwGetJoystickName_CMockIgnoreArg_jid(UNITY_LINE_TYPE cmock_line); +#define glfwGetJoystickGUID_IgnoreAndReturn(cmock_retval) glfwGetJoystickGUID_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetJoystickGUID_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, const char* cmock_to_return); +#define glfwGetJoystickGUID_StopIgnore() glfwGetJoystickGUID_CMockStopIgnore() +void glfwGetJoystickGUID_CMockStopIgnore(void); +#define glfwGetJoystickGUID_ExpectAndReturn(jid, cmock_retval) glfwGetJoystickGUID_CMockExpectAndReturn(__LINE__, jid, cmock_retval) +void glfwGetJoystickGUID_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int jid, const char* cmock_to_return); +typedef const char* (* CMOCK_glfwGetJoystickGUID_CALLBACK)(int jid, int cmock_num_calls); +void glfwGetJoystickGUID_AddCallback(CMOCK_glfwGetJoystickGUID_CALLBACK Callback); +void glfwGetJoystickGUID_Stub(CMOCK_glfwGetJoystickGUID_CALLBACK Callback); +#define glfwGetJoystickGUID_StubWithCallback glfwGetJoystickGUID_AddCallback +#define glfwGetJoystickGUID_IgnoreArg_jid() glfwGetJoystickGUID_CMockIgnoreArg_jid(__LINE__) +void glfwGetJoystickGUID_CMockIgnoreArg_jid(UNITY_LINE_TYPE cmock_line); +#define glfwSetJoystickUserPointer_Ignore() glfwSetJoystickUserPointer_CMockIgnore() +void glfwSetJoystickUserPointer_CMockIgnore(void); +#define glfwSetJoystickUserPointer_StopIgnore() glfwSetJoystickUserPointer_CMockStopIgnore() +void glfwSetJoystickUserPointer_CMockStopIgnore(void); +#define glfwSetJoystickUserPointer_Expect(jid, pointer) glfwSetJoystickUserPointer_CMockExpect(__LINE__, jid, pointer) +void glfwSetJoystickUserPointer_CMockExpect(UNITY_LINE_TYPE cmock_line, int jid, void* pointer); +typedef void (* CMOCK_glfwSetJoystickUserPointer_CALLBACK)(int jid, void* pointer, int cmock_num_calls); +void glfwSetJoystickUserPointer_AddCallback(CMOCK_glfwSetJoystickUserPointer_CALLBACK Callback); +void glfwSetJoystickUserPointer_Stub(CMOCK_glfwSetJoystickUserPointer_CALLBACK Callback); +#define glfwSetJoystickUserPointer_StubWithCallback glfwSetJoystickUserPointer_AddCallback +#define glfwSetJoystickUserPointer_IgnoreArg_jid() glfwSetJoystickUserPointer_CMockIgnoreArg_jid(__LINE__) +void glfwSetJoystickUserPointer_CMockIgnoreArg_jid(UNITY_LINE_TYPE cmock_line); +#define glfwSetJoystickUserPointer_IgnoreArg_pointer() glfwSetJoystickUserPointer_CMockIgnoreArg_pointer(__LINE__) +void glfwSetJoystickUserPointer_CMockIgnoreArg_pointer(UNITY_LINE_TYPE cmock_line); +#define glfwGetJoystickUserPointer_IgnoreAndReturn(cmock_retval) glfwGetJoystickUserPointer_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetJoystickUserPointer_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, void* cmock_to_return); +#define glfwGetJoystickUserPointer_StopIgnore() glfwGetJoystickUserPointer_CMockStopIgnore() +void glfwGetJoystickUserPointer_CMockStopIgnore(void); +#define glfwGetJoystickUserPointer_ExpectAndReturn(jid, cmock_retval) glfwGetJoystickUserPointer_CMockExpectAndReturn(__LINE__, jid, cmock_retval) +void glfwGetJoystickUserPointer_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int jid, void* cmock_to_return); +typedef void* (* CMOCK_glfwGetJoystickUserPointer_CALLBACK)(int jid, int cmock_num_calls); +void glfwGetJoystickUserPointer_AddCallback(CMOCK_glfwGetJoystickUserPointer_CALLBACK Callback); +void glfwGetJoystickUserPointer_Stub(CMOCK_glfwGetJoystickUserPointer_CALLBACK Callback); +#define glfwGetJoystickUserPointer_StubWithCallback glfwGetJoystickUserPointer_AddCallback +#define glfwGetJoystickUserPointer_IgnoreArg_jid() glfwGetJoystickUserPointer_CMockIgnoreArg_jid(__LINE__) +void glfwGetJoystickUserPointer_CMockIgnoreArg_jid(UNITY_LINE_TYPE cmock_line); +#define glfwJoystickIsGamepad_IgnoreAndReturn(cmock_retval) glfwJoystickIsGamepad_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwJoystickIsGamepad_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define glfwJoystickIsGamepad_StopIgnore() glfwJoystickIsGamepad_CMockStopIgnore() +void glfwJoystickIsGamepad_CMockStopIgnore(void); +#define glfwJoystickIsGamepad_ExpectAndReturn(jid, cmock_retval) glfwJoystickIsGamepad_CMockExpectAndReturn(__LINE__, jid, cmock_retval) +void glfwJoystickIsGamepad_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int jid, int cmock_to_return); +typedef int (* CMOCK_glfwJoystickIsGamepad_CALLBACK)(int jid, int cmock_num_calls); +void glfwJoystickIsGamepad_AddCallback(CMOCK_glfwJoystickIsGamepad_CALLBACK Callback); +void glfwJoystickIsGamepad_Stub(CMOCK_glfwJoystickIsGamepad_CALLBACK Callback); +#define glfwJoystickIsGamepad_StubWithCallback glfwJoystickIsGamepad_AddCallback +#define glfwJoystickIsGamepad_IgnoreArg_jid() glfwJoystickIsGamepad_CMockIgnoreArg_jid(__LINE__) +void glfwJoystickIsGamepad_CMockIgnoreArg_jid(UNITY_LINE_TYPE cmock_line); +#define glfwSetJoystickCallback_IgnoreAndReturn(cmock_retval) glfwSetJoystickCallback_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwSetJoystickCallback_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWjoystickfun cmock_to_return); +#define glfwSetJoystickCallback_StopIgnore() glfwSetJoystickCallback_CMockStopIgnore() +void glfwSetJoystickCallback_CMockStopIgnore(void); +#define glfwSetJoystickCallback_ExpectAndReturn(callback, cmock_retval) glfwSetJoystickCallback_CMockExpectAndReturn(__LINE__, callback, cmock_retval) +void glfwSetJoystickCallback_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWjoystickfun callback, GLFWjoystickfun cmock_to_return); +typedef GLFWjoystickfun (* CMOCK_glfwSetJoystickCallback_CALLBACK)(GLFWjoystickfun callback, int cmock_num_calls); +void glfwSetJoystickCallback_AddCallback(CMOCK_glfwSetJoystickCallback_CALLBACK Callback); +void glfwSetJoystickCallback_Stub(CMOCK_glfwSetJoystickCallback_CALLBACK Callback); +#define glfwSetJoystickCallback_StubWithCallback glfwSetJoystickCallback_AddCallback +#define glfwSetJoystickCallback_IgnoreArg_callback() glfwSetJoystickCallback_CMockIgnoreArg_callback(__LINE__) +void glfwSetJoystickCallback_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line); +#define glfwUpdateGamepadMappings_IgnoreAndReturn(cmock_retval) glfwUpdateGamepadMappings_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwUpdateGamepadMappings_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define glfwUpdateGamepadMappings_StopIgnore() glfwUpdateGamepadMappings_CMockStopIgnore() +void glfwUpdateGamepadMappings_CMockStopIgnore(void); +#define glfwUpdateGamepadMappings_ExpectAndReturn(string, cmock_retval) glfwUpdateGamepadMappings_CMockExpectAndReturn(__LINE__, string, cmock_retval) +void glfwUpdateGamepadMappings_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, const char* string, int cmock_to_return); +typedef int (* CMOCK_glfwUpdateGamepadMappings_CALLBACK)(const char* string, int cmock_num_calls); +void glfwUpdateGamepadMappings_AddCallback(CMOCK_glfwUpdateGamepadMappings_CALLBACK Callback); +void glfwUpdateGamepadMappings_Stub(CMOCK_glfwUpdateGamepadMappings_CALLBACK Callback); +#define glfwUpdateGamepadMappings_StubWithCallback glfwUpdateGamepadMappings_AddCallback +#define glfwUpdateGamepadMappings_IgnoreArg_string() glfwUpdateGamepadMappings_CMockIgnoreArg_string(__LINE__) +void glfwUpdateGamepadMappings_CMockIgnoreArg_string(UNITY_LINE_TYPE cmock_line); +#define glfwGetGamepadName_IgnoreAndReturn(cmock_retval) glfwGetGamepadName_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetGamepadName_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, const char* cmock_to_return); +#define glfwGetGamepadName_StopIgnore() glfwGetGamepadName_CMockStopIgnore() +void glfwGetGamepadName_CMockStopIgnore(void); +#define glfwGetGamepadName_ExpectAndReturn(jid, cmock_retval) glfwGetGamepadName_CMockExpectAndReturn(__LINE__, jid, cmock_retval) +void glfwGetGamepadName_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int jid, const char* cmock_to_return); +typedef const char* (* CMOCK_glfwGetGamepadName_CALLBACK)(int jid, int cmock_num_calls); +void glfwGetGamepadName_AddCallback(CMOCK_glfwGetGamepadName_CALLBACK Callback); +void glfwGetGamepadName_Stub(CMOCK_glfwGetGamepadName_CALLBACK Callback); +#define glfwGetGamepadName_StubWithCallback glfwGetGamepadName_AddCallback +#define glfwGetGamepadName_IgnoreArg_jid() glfwGetGamepadName_CMockIgnoreArg_jid(__LINE__) +void glfwGetGamepadName_CMockIgnoreArg_jid(UNITY_LINE_TYPE cmock_line); +#define glfwGetGamepadState_IgnoreAndReturn(cmock_retval) glfwGetGamepadState_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetGamepadState_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define glfwGetGamepadState_StopIgnore() glfwGetGamepadState_CMockStopIgnore() +void glfwGetGamepadState_CMockStopIgnore(void); +#define glfwGetGamepadState_ExpectAndReturn(jid, state, cmock_retval) glfwGetGamepadState_CMockExpectAndReturn(__LINE__, jid, state, cmock_retval) +void glfwGetGamepadState_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int jid, GLFWgamepadstate* state, int cmock_to_return); +typedef int (* CMOCK_glfwGetGamepadState_CALLBACK)(int jid, GLFWgamepadstate* state, int cmock_num_calls); +void glfwGetGamepadState_AddCallback(CMOCK_glfwGetGamepadState_CALLBACK Callback); +void glfwGetGamepadState_Stub(CMOCK_glfwGetGamepadState_CALLBACK Callback); +#define glfwGetGamepadState_StubWithCallback glfwGetGamepadState_AddCallback +#define glfwGetGamepadState_IgnoreArg_jid() glfwGetGamepadState_CMockIgnoreArg_jid(__LINE__) +void glfwGetGamepadState_CMockIgnoreArg_jid(UNITY_LINE_TYPE cmock_line); +#define glfwGetGamepadState_IgnoreArg_state() glfwGetGamepadState_CMockIgnoreArg_state(__LINE__) +void glfwGetGamepadState_CMockIgnoreArg_state(UNITY_LINE_TYPE cmock_line); +#define glfwSetClipboardString_Ignore() glfwSetClipboardString_CMockIgnore() +void glfwSetClipboardString_CMockIgnore(void); +#define glfwSetClipboardString_StopIgnore() glfwSetClipboardString_CMockStopIgnore() +void glfwSetClipboardString_CMockStopIgnore(void); +#define glfwSetClipboardString_Expect(window, string) glfwSetClipboardString_CMockExpect(__LINE__, window, string) +void glfwSetClipboardString_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, const char* string); +typedef void (* CMOCK_glfwSetClipboardString_CALLBACK)(GLFWwindow* window, const char* string, int cmock_num_calls); +void glfwSetClipboardString_AddCallback(CMOCK_glfwSetClipboardString_CALLBACK Callback); +void glfwSetClipboardString_Stub(CMOCK_glfwSetClipboardString_CALLBACK Callback); +#define glfwSetClipboardString_StubWithCallback glfwSetClipboardString_AddCallback +#define glfwSetClipboardString_IgnoreArg_window() glfwSetClipboardString_CMockIgnoreArg_window(__LINE__) +void glfwSetClipboardString_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSetClipboardString_IgnoreArg_string() glfwSetClipboardString_CMockIgnoreArg_string(__LINE__) +void glfwSetClipboardString_CMockIgnoreArg_string(UNITY_LINE_TYPE cmock_line); +#define glfwGetClipboardString_IgnoreAndReturn(cmock_retval) glfwGetClipboardString_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetClipboardString_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, const char* cmock_to_return); +#define glfwGetClipboardString_StopIgnore() glfwGetClipboardString_CMockStopIgnore() +void glfwGetClipboardString_CMockStopIgnore(void); +#define glfwGetClipboardString_ExpectAndReturn(window, cmock_retval) glfwGetClipboardString_CMockExpectAndReturn(__LINE__, window, cmock_retval) +void glfwGetClipboardString_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* window, const char* cmock_to_return); +typedef const char* (* CMOCK_glfwGetClipboardString_CALLBACK)(GLFWwindow* window, int cmock_num_calls); +void glfwGetClipboardString_AddCallback(CMOCK_glfwGetClipboardString_CALLBACK Callback); +void glfwGetClipboardString_Stub(CMOCK_glfwGetClipboardString_CALLBACK Callback); +#define glfwGetClipboardString_StubWithCallback glfwGetClipboardString_AddCallback +#define glfwGetClipboardString_IgnoreArg_window() glfwGetClipboardString_CMockIgnoreArg_window(__LINE__) +void glfwGetClipboardString_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwGetTime_IgnoreAndReturn(cmock_retval) glfwGetTime_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetTime_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, double cmock_to_return); +#define glfwGetTime_StopIgnore() glfwGetTime_CMockStopIgnore() +void glfwGetTime_CMockStopIgnore(void); +#define glfwGetTime_ExpectAndReturn(cmock_retval) glfwGetTime_CMockExpectAndReturn(__LINE__, cmock_retval) +void glfwGetTime_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, double cmock_to_return); +typedef double (* CMOCK_glfwGetTime_CALLBACK)(int cmock_num_calls); +void glfwGetTime_AddCallback(CMOCK_glfwGetTime_CALLBACK Callback); +void glfwGetTime_Stub(CMOCK_glfwGetTime_CALLBACK Callback); +#define glfwGetTime_StubWithCallback glfwGetTime_AddCallback +#define glfwSetTime_Ignore() glfwSetTime_CMockIgnore() +void glfwSetTime_CMockIgnore(void); +#define glfwSetTime_StopIgnore() glfwSetTime_CMockStopIgnore() +void glfwSetTime_CMockStopIgnore(void); +#define glfwSetTime_Expect(time) glfwSetTime_CMockExpect(__LINE__, time) +void glfwSetTime_CMockExpect(UNITY_LINE_TYPE cmock_line, double time); +typedef void (* CMOCK_glfwSetTime_CALLBACK)(double time, int cmock_num_calls); +void glfwSetTime_AddCallback(CMOCK_glfwSetTime_CALLBACK Callback); +void glfwSetTime_Stub(CMOCK_glfwSetTime_CALLBACK Callback); +#define glfwSetTime_StubWithCallback glfwSetTime_AddCallback +#define glfwSetTime_IgnoreArg_time() glfwSetTime_CMockIgnoreArg_time(__LINE__) +void glfwSetTime_CMockIgnoreArg_time(UNITY_LINE_TYPE cmock_line); +#define glfwGetTimerValue_IgnoreAndReturn(cmock_retval) glfwGetTimerValue_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetTimerValue_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, uint64_t cmock_to_return); +#define glfwGetTimerValue_StopIgnore() glfwGetTimerValue_CMockStopIgnore() +void glfwGetTimerValue_CMockStopIgnore(void); +#define glfwGetTimerValue_ExpectAndReturn(cmock_retval) glfwGetTimerValue_CMockExpectAndReturn(__LINE__, cmock_retval) +void glfwGetTimerValue_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, uint64_t cmock_to_return); +typedef uint64_t (* CMOCK_glfwGetTimerValue_CALLBACK)(int cmock_num_calls); +void glfwGetTimerValue_AddCallback(CMOCK_glfwGetTimerValue_CALLBACK Callback); +void glfwGetTimerValue_Stub(CMOCK_glfwGetTimerValue_CALLBACK Callback); +#define glfwGetTimerValue_StubWithCallback glfwGetTimerValue_AddCallback +#define glfwGetTimerFrequency_IgnoreAndReturn(cmock_retval) glfwGetTimerFrequency_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetTimerFrequency_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, uint64_t cmock_to_return); +#define glfwGetTimerFrequency_StopIgnore() glfwGetTimerFrequency_CMockStopIgnore() +void glfwGetTimerFrequency_CMockStopIgnore(void); +#define glfwGetTimerFrequency_ExpectAndReturn(cmock_retval) glfwGetTimerFrequency_CMockExpectAndReturn(__LINE__, cmock_retval) +void glfwGetTimerFrequency_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, uint64_t cmock_to_return); +typedef uint64_t (* CMOCK_glfwGetTimerFrequency_CALLBACK)(int cmock_num_calls); +void glfwGetTimerFrequency_AddCallback(CMOCK_glfwGetTimerFrequency_CALLBACK Callback); +void glfwGetTimerFrequency_Stub(CMOCK_glfwGetTimerFrequency_CALLBACK Callback); +#define glfwGetTimerFrequency_StubWithCallback glfwGetTimerFrequency_AddCallback +#define glfwMakeContextCurrent_Ignore() glfwMakeContextCurrent_CMockIgnore() +void glfwMakeContextCurrent_CMockIgnore(void); +#define glfwMakeContextCurrent_StopIgnore() glfwMakeContextCurrent_CMockStopIgnore() +void glfwMakeContextCurrent_CMockStopIgnore(void); +#define glfwMakeContextCurrent_Expect(window) glfwMakeContextCurrent_CMockExpect(__LINE__, window) +void glfwMakeContextCurrent_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window); +typedef void (* CMOCK_glfwMakeContextCurrent_CALLBACK)(GLFWwindow* window, int cmock_num_calls); +void glfwMakeContextCurrent_AddCallback(CMOCK_glfwMakeContextCurrent_CALLBACK Callback); +void glfwMakeContextCurrent_Stub(CMOCK_glfwMakeContextCurrent_CALLBACK Callback); +#define glfwMakeContextCurrent_StubWithCallback glfwMakeContextCurrent_AddCallback +#define glfwMakeContextCurrent_IgnoreArg_window() glfwMakeContextCurrent_CMockIgnoreArg_window(__LINE__) +void glfwMakeContextCurrent_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwGetCurrentContext_IgnoreAndReturn(cmock_retval) glfwGetCurrentContext_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetCurrentContext_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* cmock_to_return); +#define glfwGetCurrentContext_StopIgnore() glfwGetCurrentContext_CMockStopIgnore() +void glfwGetCurrentContext_CMockStopIgnore(void); +#define glfwGetCurrentContext_ExpectAndReturn(cmock_retval) glfwGetCurrentContext_CMockExpectAndReturn(__LINE__, cmock_retval) +void glfwGetCurrentContext_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, GLFWwindow* cmock_to_return); +typedef GLFWwindow* (* CMOCK_glfwGetCurrentContext_CALLBACK)(int cmock_num_calls); +void glfwGetCurrentContext_AddCallback(CMOCK_glfwGetCurrentContext_CALLBACK Callback); +void glfwGetCurrentContext_Stub(CMOCK_glfwGetCurrentContext_CALLBACK Callback); +#define glfwGetCurrentContext_StubWithCallback glfwGetCurrentContext_AddCallback +#define glfwSwapBuffers_Ignore() glfwSwapBuffers_CMockIgnore() +void glfwSwapBuffers_CMockIgnore(void); +#define glfwSwapBuffers_StopIgnore() glfwSwapBuffers_CMockStopIgnore() +void glfwSwapBuffers_CMockStopIgnore(void); +#define glfwSwapBuffers_Expect(window) glfwSwapBuffers_CMockExpect(__LINE__, window) +void glfwSwapBuffers_CMockExpect(UNITY_LINE_TYPE cmock_line, GLFWwindow* window); +typedef void (* CMOCK_glfwSwapBuffers_CALLBACK)(GLFWwindow* window, int cmock_num_calls); +void glfwSwapBuffers_AddCallback(CMOCK_glfwSwapBuffers_CALLBACK Callback); +void glfwSwapBuffers_Stub(CMOCK_glfwSwapBuffers_CALLBACK Callback); +#define glfwSwapBuffers_StubWithCallback glfwSwapBuffers_AddCallback +#define glfwSwapBuffers_IgnoreArg_window() glfwSwapBuffers_CMockIgnoreArg_window(__LINE__) +void glfwSwapBuffers_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwSwapInterval_Ignore() glfwSwapInterval_CMockIgnore() +void glfwSwapInterval_CMockIgnore(void); +#define glfwSwapInterval_StopIgnore() glfwSwapInterval_CMockStopIgnore() +void glfwSwapInterval_CMockStopIgnore(void); +#define glfwSwapInterval_Expect(interval) glfwSwapInterval_CMockExpect(__LINE__, interval) +void glfwSwapInterval_CMockExpect(UNITY_LINE_TYPE cmock_line, int interval); +typedef void (* CMOCK_glfwSwapInterval_CALLBACK)(int interval, int cmock_num_calls); +void glfwSwapInterval_AddCallback(CMOCK_glfwSwapInterval_CALLBACK Callback); +void glfwSwapInterval_Stub(CMOCK_glfwSwapInterval_CALLBACK Callback); +#define glfwSwapInterval_StubWithCallback glfwSwapInterval_AddCallback +#define glfwSwapInterval_IgnoreArg_interval() glfwSwapInterval_CMockIgnoreArg_interval(__LINE__) +void glfwSwapInterval_CMockIgnoreArg_interval(UNITY_LINE_TYPE cmock_line); +#define glfwExtensionSupported_IgnoreAndReturn(cmock_retval) glfwExtensionSupported_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwExtensionSupported_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define glfwExtensionSupported_StopIgnore() glfwExtensionSupported_CMockStopIgnore() +void glfwExtensionSupported_CMockStopIgnore(void); +#define glfwExtensionSupported_ExpectAndReturn(extension, cmock_retval) glfwExtensionSupported_CMockExpectAndReturn(__LINE__, extension, cmock_retval) +void glfwExtensionSupported_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, const char* extension, int cmock_to_return); +typedef int (* CMOCK_glfwExtensionSupported_CALLBACK)(const char* extension, int cmock_num_calls); +void glfwExtensionSupported_AddCallback(CMOCK_glfwExtensionSupported_CALLBACK Callback); +void glfwExtensionSupported_Stub(CMOCK_glfwExtensionSupported_CALLBACK Callback); +#define glfwExtensionSupported_StubWithCallback glfwExtensionSupported_AddCallback +#define glfwExtensionSupported_IgnoreArg_extension() glfwExtensionSupported_CMockIgnoreArg_extension(__LINE__) +void glfwExtensionSupported_CMockIgnoreArg_extension(UNITY_LINE_TYPE cmock_line); +#define glfwGetProcAddress_IgnoreAndReturn(cmock_retval) glfwGetProcAddress_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetProcAddress_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWglproc cmock_to_return); +#define glfwGetProcAddress_StopIgnore() glfwGetProcAddress_CMockStopIgnore() +void glfwGetProcAddress_CMockStopIgnore(void); +#define glfwGetProcAddress_ExpectAndReturn(procname, cmock_retval) glfwGetProcAddress_CMockExpectAndReturn(__LINE__, procname, cmock_retval) +void glfwGetProcAddress_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, const char* procname, GLFWglproc cmock_to_return); +typedef GLFWglproc (* CMOCK_glfwGetProcAddress_CALLBACK)(const char* procname, int cmock_num_calls); +void glfwGetProcAddress_AddCallback(CMOCK_glfwGetProcAddress_CALLBACK Callback); +void glfwGetProcAddress_Stub(CMOCK_glfwGetProcAddress_CALLBACK Callback); +#define glfwGetProcAddress_StubWithCallback glfwGetProcAddress_AddCallback +#define glfwGetProcAddress_IgnoreArg_procname() glfwGetProcAddress_CMockIgnoreArg_procname(__LINE__) +void glfwGetProcAddress_CMockIgnoreArg_procname(UNITY_LINE_TYPE cmock_line); +#define glfwVulkanSupported_IgnoreAndReturn(cmock_retval) glfwVulkanSupported_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwVulkanSupported_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define glfwVulkanSupported_StopIgnore() glfwVulkanSupported_CMockStopIgnore() +void glfwVulkanSupported_CMockStopIgnore(void); +#define glfwVulkanSupported_ExpectAndReturn(cmock_retval) glfwVulkanSupported_CMockExpectAndReturn(__LINE__, cmock_retval) +void glfwVulkanSupported_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +typedef int (* CMOCK_glfwVulkanSupported_CALLBACK)(int cmock_num_calls); +void glfwVulkanSupported_AddCallback(CMOCK_glfwVulkanSupported_CALLBACK Callback); +void glfwVulkanSupported_Stub(CMOCK_glfwVulkanSupported_CALLBACK Callback); +#define glfwVulkanSupported_StubWithCallback glfwVulkanSupported_AddCallback +#define glfwGetRequiredInstanceExtensions_IgnoreAndReturn(cmock_retval) glfwGetRequiredInstanceExtensions_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetRequiredInstanceExtensions_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, const char** cmock_to_return); +#define glfwGetRequiredInstanceExtensions_StopIgnore() glfwGetRequiredInstanceExtensions_CMockStopIgnore() +void glfwGetRequiredInstanceExtensions_CMockStopIgnore(void); +#define glfwGetRequiredInstanceExtensions_ExpectAndReturn(count, cmock_retval) glfwGetRequiredInstanceExtensions_CMockExpectAndReturn(__LINE__, count, cmock_retval) +void glfwGetRequiredInstanceExtensions_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, uint32_t* count, const char** cmock_to_return); +typedef const char** (* CMOCK_glfwGetRequiredInstanceExtensions_CALLBACK)(uint32_t* count, int cmock_num_calls); +void glfwGetRequiredInstanceExtensions_AddCallback(CMOCK_glfwGetRequiredInstanceExtensions_CALLBACK Callback); +void glfwGetRequiredInstanceExtensions_Stub(CMOCK_glfwGetRequiredInstanceExtensions_CALLBACK Callback); +#define glfwGetRequiredInstanceExtensions_StubWithCallback glfwGetRequiredInstanceExtensions_AddCallback +#define glfwGetRequiredInstanceExtensions_IgnoreArg_count() glfwGetRequiredInstanceExtensions_CMockIgnoreArg_count(__LINE__) +void glfwGetRequiredInstanceExtensions_CMockIgnoreArg_count(UNITY_LINE_TYPE cmock_line); +#define glfwGetInstanceProcAddress_IgnoreAndReturn(cmock_retval) glfwGetInstanceProcAddress_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetInstanceProcAddress_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, GLFWvkproc cmock_to_return); +#define glfwGetInstanceProcAddress_StopIgnore() glfwGetInstanceProcAddress_CMockStopIgnore() +void glfwGetInstanceProcAddress_CMockStopIgnore(void); +#define glfwGetInstanceProcAddress_ExpectAndReturn(instance, procname, cmock_retval) glfwGetInstanceProcAddress_CMockExpectAndReturn(__LINE__, instance, procname, cmock_retval) +void glfwGetInstanceProcAddress_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkInstance instance, const char* procname, GLFWvkproc cmock_to_return); +typedef GLFWvkproc (* CMOCK_glfwGetInstanceProcAddress_CALLBACK)(VkInstance instance, const char* procname, int cmock_num_calls); +void glfwGetInstanceProcAddress_AddCallback(CMOCK_glfwGetInstanceProcAddress_CALLBACK Callback); +void glfwGetInstanceProcAddress_Stub(CMOCK_glfwGetInstanceProcAddress_CALLBACK Callback); +#define glfwGetInstanceProcAddress_StubWithCallback glfwGetInstanceProcAddress_AddCallback +#define glfwGetInstanceProcAddress_IgnoreArg_instance() glfwGetInstanceProcAddress_CMockIgnoreArg_instance(__LINE__) +void glfwGetInstanceProcAddress_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line); +#define glfwGetInstanceProcAddress_IgnoreArg_procname() glfwGetInstanceProcAddress_CMockIgnoreArg_procname(__LINE__) +void glfwGetInstanceProcAddress_CMockIgnoreArg_procname(UNITY_LINE_TYPE cmock_line); +#define glfwGetPhysicalDevicePresentationSupport_IgnoreAndReturn(cmock_retval) glfwGetPhysicalDevicePresentationSupport_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwGetPhysicalDevicePresentationSupport_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define glfwGetPhysicalDevicePresentationSupport_StopIgnore() glfwGetPhysicalDevicePresentationSupport_CMockStopIgnore() +void glfwGetPhysicalDevicePresentationSupport_CMockStopIgnore(void); +#define glfwGetPhysicalDevicePresentationSupport_ExpectAndReturn(instance, device, queuefamily, cmock_retval) glfwGetPhysicalDevicePresentationSupport_CMockExpectAndReturn(__LINE__, instance, device, queuefamily, cmock_retval) +void glfwGetPhysicalDevicePresentationSupport_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkInstance instance, VkPhysicalDevice device, uint32_t queuefamily, int cmock_to_return); +typedef int (* CMOCK_glfwGetPhysicalDevicePresentationSupport_CALLBACK)(VkInstance instance, VkPhysicalDevice device, uint32_t queuefamily, int cmock_num_calls); +void glfwGetPhysicalDevicePresentationSupport_AddCallback(CMOCK_glfwGetPhysicalDevicePresentationSupport_CALLBACK Callback); +void glfwGetPhysicalDevicePresentationSupport_Stub(CMOCK_glfwGetPhysicalDevicePresentationSupport_CALLBACK Callback); +#define glfwGetPhysicalDevicePresentationSupport_StubWithCallback glfwGetPhysicalDevicePresentationSupport_AddCallback +#define glfwGetPhysicalDevicePresentationSupport_IgnoreArg_instance() glfwGetPhysicalDevicePresentationSupport_CMockIgnoreArg_instance(__LINE__) +void glfwGetPhysicalDevicePresentationSupport_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line); +#define glfwGetPhysicalDevicePresentationSupport_IgnoreArg_device() glfwGetPhysicalDevicePresentationSupport_CMockIgnoreArg_device(__LINE__) +void glfwGetPhysicalDevicePresentationSupport_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define glfwGetPhysicalDevicePresentationSupport_IgnoreArg_queuefamily() glfwGetPhysicalDevicePresentationSupport_CMockIgnoreArg_queuefamily(__LINE__) +void glfwGetPhysicalDevicePresentationSupport_CMockIgnoreArg_queuefamily(UNITY_LINE_TYPE cmock_line); +#define glfwCreateWindowSurface_IgnoreAndReturn(cmock_retval) glfwCreateWindowSurface_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void glfwCreateWindowSurface_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define glfwCreateWindowSurface_StopIgnore() glfwCreateWindowSurface_CMockStopIgnore() +void glfwCreateWindowSurface_CMockStopIgnore(void); +#define glfwCreateWindowSurface_ExpectAndReturn(instance, window, allocator, surface, cmock_retval) glfwCreateWindowSurface_CMockExpectAndReturn(__LINE__, instance, window, allocator, surface, cmock_retval) +void glfwCreateWindowSurface_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkInstance instance, GLFWwindow* window, const VkAllocationCallbacks* allocator, VkSurfaceKHR* surface, VkResult cmock_to_return); +typedef VkResult (* CMOCK_glfwCreateWindowSurface_CALLBACK)(VkInstance instance, GLFWwindow* window, const VkAllocationCallbacks* allocator, VkSurfaceKHR* surface, int cmock_num_calls); +void glfwCreateWindowSurface_AddCallback(CMOCK_glfwCreateWindowSurface_CALLBACK Callback); +void glfwCreateWindowSurface_Stub(CMOCK_glfwCreateWindowSurface_CALLBACK Callback); +#define glfwCreateWindowSurface_StubWithCallback glfwCreateWindowSurface_AddCallback +#define glfwCreateWindowSurface_IgnoreArg_instance() glfwCreateWindowSurface_CMockIgnoreArg_instance(__LINE__) +void glfwCreateWindowSurface_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line); +#define glfwCreateWindowSurface_IgnoreArg_window() glfwCreateWindowSurface_CMockIgnoreArg_window(__LINE__) +void glfwCreateWindowSurface_CMockIgnoreArg_window(UNITY_LINE_TYPE cmock_line); +#define glfwCreateWindowSurface_IgnoreArg_allocator() glfwCreateWindowSurface_CMockIgnoreArg_allocator(__LINE__) +void glfwCreateWindowSurface_CMockIgnoreArg_allocator(UNITY_LINE_TYPE cmock_line); +#define glfwCreateWindowSurface_IgnoreArg_surface() glfwCreateWindowSurface_CMockIgnoreArg_surface(__LINE__) +void glfwCreateWindowSurface_CMockIgnoreArg_surface(UNITY_LINE_TYPE cmock_line); + +#ifdef __cplusplus +} +#endif + +#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__) +#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0))) +#pragma GCC diagnostic pop +#endif +#endif + +#endif diff --git a/tests/src/mocks/freetype/fttypes.h b/tests/src/mocks/freetype/fttypes.h new file mode 100644 index 00000000..5ec24438 --- /dev/null +++ b/tests/src/mocks/freetype/fttypes.h @@ -0,0 +1,44 @@ +#ifndef FTTYPES_H +#define FTTYPES_H + +#define FT_FREETYPE_H +#define FT_LOAD_RENDER 1 + +typedef void* FT_Library; +typedef int FT_Error; + +typedef long FT_Long; +typedef unsigned long FT_ULong; +typedef unsigned int FT_UInt; +typedef FT_Long FT_Int32; + +typedef struct { + int x; + int y; +} FT_Vector; + +typedef struct { + int width; + int rows; + void *buffer; +} FT_Bitmap; + +typedef struct { + int bitmap_left; + int bitmap_top; + FT_Vector advance; + FT_Bitmap bitmap; +} FT_GlyphSlotRec_; + +typedef struct { + int num_glyphs; + FT_GlyphSlotRec_ *glyph; +} FT_FaceRec_; + +typedef FT_FaceRec_* FT_Face; + +FT_Error FT_Init_FreeType( FT_Library *alibrary ) { return 0; } +FT_Error FT_New_Face( FT_Library library, const char* filepathname, FT_Long face_index, FT_Face *aface ) { return 0; } +FT_Error FT_Set_Pixel_Sizes( FT_Face face, FT_UInt pixel_width, FT_UInt pixel_height ) { return 0; } +FT_Error FT_Load_Char( FT_Face face, FT_ULong char_code, FT_Int32 load_flags ) { return 0; } +#endif // FTTYPES_H diff --git a/tests/src/mocks/stb_image.h b/tests/src/mocks/stb_image.h new file mode 100644 index 00000000..fe38d5bf --- /dev/null +++ b/tests/src/mocks/stb_image.h @@ -0,0 +1,15 @@ +#ifndef STBI_IMAGE_H +#define STBI_IMAGE_H + +#define STBI_rgb_alpha 4 + +typedef unsigned char stbi_uc; + +stbi_uc g_mocked_uc; + +void stbi_image_free (void *retval_from_stbi_load) {} + +stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp) { return &g_mocked_uc; } + +#endif // STBI_IMAGE_H + diff --git a/tests/src/mocks/vk_mem_alloc.c b/tests/src/mocks/vk_mem_alloc.c new file mode 100644 index 00000000..92fda013 --- /dev/null +++ b/tests/src/mocks/vk_mem_alloc.c @@ -0,0 +1,12 @@ +#include "vk_mem_alloc.h" + +VkResult vmaCreateAllocator(VmaAllocatorCreateInfo* pCreateInfo, VmaAllocator* pAllocator) { return VK_SUCCESS; } + +VkResult vmaCreateBuffer(VmaAllocator allocator, const VkBufferCreateInfo* pBufferCreateInfo, const VmaAllocationCreateInfo* pAllocationCreateInfo, VkBuffer* pBuffer, VmaAllocation* pAllocation, VmaAllocationInfo* pAllocationInfo) { return VK_SUCCESS; } + +VkResult vmaCreateImage(VmaAllocator allocator, const VkImageCreateInfo* pImageCreateInfo, const VmaAllocationCreateInfo* pAllocationCreateInfo, VkImage* pImage, VmaAllocation* pAllocation, VmaAllocationInfo* pAllocationInfo) { return VK_SUCCESS; } + +void vmaDestroyAllocator(VmaAllocator allocator) {} +void vmaDestroyBuffer(VmaAllocator allocator, VkBuffer buffer, VmaAllocation allocation) {} +void vmaDestroyImage(VmaAllocator allocator, VkImage image, VmaAllocation allocation) {} +VkResult vmaMapMemory(VmaAllocator allocator, VmaAllocation allocation, void** ppData) { return VK_SUCCESS; } diff --git a/tests/src/mocks/vk_mem_alloc.h b/tests/src/mocks/vk_mem_alloc.h new file mode 100644 index 00000000..1719f159 --- /dev/null +++ b/tests/src/mocks/vk_mem_alloc.h @@ -0,0 +1,71 @@ +#ifndef AMD_VULKAN_MEMORY_ALLOCATOR_H +#define AMD_VULKAN_MEMORY_ALLOCATOR_H + +#include +#include + +#define VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE 1 +#define VMA_ALLOCATION_CREATE_MAPPED_BIT 2 +#define VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT 3 +#define VMA_MEMORY_USAGE_AUTO_PREFER_HOST 4 +#define VMA_MEMORY_USAGE_AUTO 5; +#define VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT 6 + +typedef int VmaAllocation; +typedef int VmaAllocator; +typedef int VmaMemoryUsage; +typedef int VmaAllocationCreateFlags; + +typedef struct { + VkBuffer buffer; + VmaAllocation allocation; +} VmaBuffer; + +typedef struct { + VkImage image; + VmaAllocation allocation; +} VmaImage; + +typedef struct { + float priority; + uint32_t flags; + uint32_t usage; + uint32_t requiredFlags; + uint32_t preferredFlags; + uint32_t memoryTypeBits; + void* pool; + void* pUserData; +} VmaAllocationCreateInfo; + +typedef struct { + VkDeviceMemory memory; + VkDeviceSize offset; + VkDeviceSize size; + void* pMappedData; +} VmaAllocationInfo; + +typedef struct { + void* vkGetInstanceProcAddr; + void* vkGetDeviceProcAddr; +} VmaVulkanFunctions; + +typedef struct { + uint32_t vulkanApiVersion; + VkPhysicalDevice physicalDevice; + VkDevice device; + VkInstance instance; + VmaVulkanFunctions* pVulkanFunctions; +} VmaAllocatorCreateInfo; + +VkResult vmaCreateAllocator(VmaAllocatorCreateInfo* pCreateInfo, VmaAllocator* pAllocator); + +VkResult vmaCreateBuffer(VmaAllocator allocator, const VkBufferCreateInfo* pBufferCreateInfo, const VmaAllocationCreateInfo* pAllocationCreateInfo, VkBuffer* pBuffer, VmaAllocation* pAllocation, VmaAllocationInfo* pAllocationInfo); + +VkResult vmaCreateImage(VmaAllocator allocator, const VkImageCreateInfo* pImageCreateInfo, const VmaAllocationCreateInfo* pAllocationCreateInfo, VkImage* pImage, VmaAllocation* pAllocation, VmaAllocationInfo* pAllocationInfo); + +void vmaDestroyAllocator(VmaAllocator allocator); +void vmaDestroyBuffer(VmaAllocator allocator, VkBuffer buffer, VmaAllocation allocation); +void vmaDestroyImage(VmaAllocator allocator, VkImage image, VmaAllocation allocation); +VkResult vmaMapMemory(VmaAllocator allocator, VmaAllocation allocation, void** ppData); + +#endif // AMD_VULKAN_MEMORY_ALLOCATOR_H diff --git a/tests/src/mocks/vulkan/Mockvulkan_core.c b/tests/src/mocks/vulkan/Mockvulkan_core.c new file mode 100644 index 00000000..3a14d394 --- /dev/null +++ b/tests/src/mocks/vulkan/Mockvulkan_core.c @@ -0,0 +1,109936 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ +#include +#include +#include +#include "cmock.h" +#include "Mockvulkan_core.h" + +static const char* CMockString_accelerationStructure = "accelerationStructure"; +static const char* CMockString_accelerationStructureCount = "accelerationStructureCount"; +static const char* CMockString_alphaToCoverageEnable = "alphaToCoverageEnable"; +static const char* CMockString_alphaToOneEnable = "alphaToOneEnable"; +static const char* CMockString_aspectMask = "aspectMask"; +static const char* CMockString_attachmentCount = "attachmentCount"; +static const char* CMockString_baseGroupX = "baseGroupX"; +static const char* CMockString_baseGroupY = "baseGroupY"; +static const char* CMockString_baseGroupZ = "baseGroupZ"; +static const char* CMockString_bindInfoCount = "bindInfoCount"; +static const char* CMockString_bindSessionMemoryInfoCount = "bindSessionMemoryInfoCount"; +static const char* CMockString_binding = "binding"; +static const char* CMockString_bindingCount = "bindingCount"; +static const char* CMockString_bindingPoint = "bindingPoint"; +static const char* CMockString_blendConstants = "blendConstants"; +static const char* CMockString_buffer = "buffer"; +static const char* CMockString_bufferCount = "bufferCount"; +static const char* CMockString_bufferMemoryBarrierCount = "bufferMemoryBarrierCount"; +static const char* CMockString_bufferView = "bufferView"; +static const char* CMockString_buildType = "buildType"; +static const char* CMockString_callableShaderBindingOffset = "callableShaderBindingOffset"; +static const char* CMockString_callableShaderBindingStride = "callableShaderBindingStride"; +static const char* CMockString_callableShaderBindingTableBuffer = "callableShaderBindingTableBuffer"; +static const char* CMockString_callback = "callback"; +static const char* CMockString_combinerOps = "combinerOps"; +static const char* CMockString_commandBuffer = "commandBuffer"; +static const char* CMockString_commandBufferCount = "commandBufferCount"; +static const char* CMockString_commandPool = "commandPool"; +static const char* CMockString_compareMask = "compareMask"; +static const char* CMockString_compareOp = "compareOp"; +static const char* CMockString_configuration = "configuration"; +static const char* CMockString_connectorId = "connectorId"; +static const char* CMockString_conservativeRasterizationMode = "conservativeRasterizationMode"; +static const char* CMockString_contents = "contents"; +static const char* CMockString_copyBufferAddress = "copyBufferAddress"; +static const char* CMockString_copyCount = "copyCount"; +static const char* CMockString_countBuffer = "countBuffer"; +static const char* CMockString_countBufferOffset = "countBufferOffset"; +static const char* CMockString_counter = "counter"; +static const char* CMockString_counterBuffer = "counterBuffer"; +static const char* CMockString_counterBufferCount = "counterBufferCount"; +static const char* CMockString_counterBufferOffset = "counterBufferOffset"; +static const char* CMockString_counterOffset = "counterOffset"; +static const char* CMockString_coverageModulationMode = "coverageModulationMode"; +static const char* CMockString_coverageModulationTableCount = "coverageModulationTableCount"; +static const char* CMockString_coverageModulationTableEnable = "coverageModulationTableEnable"; +static const char* CMockString_coverageReductionMode = "coverageReductionMode"; +static const char* CMockString_coverageToColorEnable = "coverageToColorEnable"; +static const char* CMockString_coverageToColorLocation = "coverageToColorLocation"; +static const char* CMockString_createInfoCount = "createInfoCount"; +static const char* CMockString_cullMode = "cullMode"; +static const char* CMockString_customSampleOrderCount = "customSampleOrderCount"; +static const char* CMockString_data = "data"; +static const char* CMockString_dataSize = "dataSize"; +static const char* CMockString_decompressRegionCount = "decompressRegionCount"; +static const char* CMockString_deferredOperation = "deferredOperation"; +static const char* CMockString_dependencyFlags = "dependencyFlags"; +static const char* CMockString_depth = "depth"; +static const char* CMockString_depthBiasClamp = "depthBiasClamp"; +static const char* CMockString_depthBiasConstantFactor = "depthBiasConstantFactor"; +static const char* CMockString_depthBiasEnable = "depthBiasEnable"; +static const char* CMockString_depthBiasSlopeFactor = "depthBiasSlopeFactor"; +static const char* CMockString_depthBoundsTestEnable = "depthBoundsTestEnable"; +static const char* CMockString_depthClampEnable = "depthClampEnable"; +static const char* CMockString_depthClipEnable = "depthClipEnable"; +static const char* CMockString_depthCompareOp = "depthCompareOp"; +static const char* CMockString_depthFailOp = "depthFailOp"; +static const char* CMockString_depthTestEnable = "depthTestEnable"; +static const char* CMockString_depthWriteEnable = "depthWriteEnable"; +static const char* CMockString_descriptorCopyCount = "descriptorCopyCount"; +static const char* CMockString_descriptorPool = "descriptorPool"; +static const char* CMockString_descriptorSet = "descriptorSet"; +static const char* CMockString_descriptorSetCount = "descriptorSetCount"; +static const char* CMockString_descriptorSetLayout = "descriptorSetLayout"; +static const char* CMockString_descriptorUpdateTemplate = "descriptorUpdateTemplate"; +static const char* CMockString_descriptorWriteCount = "descriptorWriteCount"; +static const char* CMockString_device = "device"; +static const char* CMockString_deviceMask = "deviceMask"; +static const char* CMockString_discardRectangleCount = "discardRectangleCount"; +static const char* CMockString_discardRectangleEnable = "discardRectangleEnable"; +static const char* CMockString_discardRectangleMode = "discardRectangleMode"; +static const char* CMockString_display = "display"; +static const char* CMockString_domainOrigin = "domainOrigin"; +static const char* CMockString_drawCount = "drawCount"; +static const char* CMockString_drmFd = "drmFd"; +static const char* CMockString_dst = "dst"; +static const char* CMockString_dstBuffer = "dstBuffer"; +static const char* CMockString_dstCache = "dstCache"; +static const char* CMockString_dstImage = "dstImage"; +static const char* CMockString_dstImageLayout = "dstImageLayout"; +static const char* CMockString_dstOffset = "dstOffset"; +static const char* CMockString_dstStageMask = "dstStageMask"; +static const char* CMockString_dynamicOffsetCount = "dynamicOffsetCount"; +static const char* CMockString_event = "event"; +static const char* CMockString_eventCount = "eventCount"; +static const char* CMockString_exclusiveScissorCount = "exclusiveScissorCount"; +static const char* CMockString_externalHandleType = "externalHandleType"; +static const char* CMockString_extraPrimitiveOverestimationSize = "extraPrimitiveOverestimationSize"; +static const char* CMockString_faceMask = "faceMask"; +static const char* CMockString_failOp = "failOp"; +static const char* CMockString_fd = "fd"; +static const char* CMockString_fence = "fence"; +static const char* CMockString_fenceCount = "fenceCount"; +static const char* CMockString_filter = "filter"; +static const char* CMockString_firstAttachment = "firstAttachment"; +static const char* CMockString_firstBinding = "firstBinding"; +static const char* CMockString_firstCounterBuffer = "firstCounterBuffer"; +static const char* CMockString_firstDiscardRectangle = "firstDiscardRectangle"; +static const char* CMockString_firstExclusiveScissor = "firstExclusiveScissor"; +static const char* CMockString_firstGroup = "firstGroup"; +static const char* CMockString_firstIndex = "firstIndex"; +static const char* CMockString_firstInstance = "firstInstance"; +static const char* CMockString_firstQuery = "firstQuery"; +static const char* CMockString_firstScissor = "firstScissor"; +static const char* CMockString_firstSet = "firstSet"; +static const char* CMockString_firstTask = "firstTask"; +static const char* CMockString_firstVertex = "firstVertex"; +static const char* CMockString_firstViewport = "firstViewport"; +static const char* CMockString_flags = "flags"; +static const char* CMockString_format = "format"; +static const char* CMockString_framebuffer = "framebuffer"; +static const char* CMockString_frontFace = "frontFace"; +static const char* CMockString_function = "function"; +static const char* CMockString_group = "group"; +static const char* CMockString_groupCount = "groupCount"; +static const char* CMockString_groupCountX = "groupCountX"; +static const char* CMockString_groupCountY = "groupCountY"; +static const char* CMockString_groupCountZ = "groupCountZ"; +static const char* CMockString_groupIndex = "groupIndex"; +static const char* CMockString_groupShader = "groupShader"; +static const char* CMockString_handleType = "handleType"; +static const char* CMockString_heapIndex = "heapIndex"; +static const char* CMockString_height = "height"; +static const char* CMockString_hitShaderBindingOffset = "hitShaderBindingOffset"; +static const char* CMockString_hitShaderBindingStride = "hitShaderBindingStride"; +static const char* CMockString_hitShaderBindingTableBuffer = "hitShaderBindingTableBuffer"; +static const char* CMockString_image = "image"; +static const char* CMockString_imageLayout = "imageLayout"; +static const char* CMockString_imageMemoryBarrierCount = "imageMemoryBarrierCount"; +static const char* CMockString_imageView = "imageView"; +static const char* CMockString_index = "index"; +static const char* CMockString_indexCount = "indexCount"; +static const char* CMockString_indexType = "indexType"; +static const char* CMockString_indirectCommandsAddress = "indirectCommandsAddress"; +static const char* CMockString_indirectCommandsCountAddress = "indirectCommandsCountAddress"; +static const char* CMockString_indirectCommandsLayout = "indirectCommandsLayout"; +static const char* CMockString_indirectDeviceAddress = "indirectDeviceAddress"; +static const char* CMockString_infoCount = "infoCount"; +static const char* CMockString_infoType = "infoType"; +static const char* CMockString_instance = "instance"; +static const char* CMockString_instanceCount = "instanceCount"; +static const char* CMockString_instanceData = "instanceData"; +static const char* CMockString_instanceOffset = "instanceOffset"; +static const char* CMockString_isPreprocessed = "isPreprocessed"; +static const char* CMockString_layout = "layout"; +static const char* CMockString_lineRasterizationMode = "lineRasterizationMode"; +static const char* CMockString_lineStippleFactor = "lineStippleFactor"; +static const char* CMockString_lineStipplePattern = "lineStipplePattern"; +static const char* CMockString_lineWidth = "lineWidth"; +static const char* CMockString_localDeviceIndex = "localDeviceIndex"; +static const char* CMockString_localDimmingEnable = "localDimmingEnable"; +static const char* CMockString_location = "location"; +static const char* CMockString_logicOp = "logicOp"; +static const char* CMockString_logicOpEnable = "logicOpEnable"; +static const char* CMockString_marker = "marker"; +static const char* CMockString_maxDepthBounds = "maxDepthBounds"; +static const char* CMockString_maxDrawCount = "maxDrawCount"; +static const char* CMockString_memory = "memory"; +static const char* CMockString_memoryBarrierCount = "memoryBarrierCount"; +static const char* CMockString_memoryOffset = "memoryOffset"; +static const char* CMockString_memoryRangeCount = "memoryRangeCount"; +static const char* CMockString_messageCode = "messageCode"; +static const char* CMockString_messageSeverity = "messageSeverity"; +static const char* CMockString_messageTypes = "messageTypes"; +static const char* CMockString_messenger = "messenger"; +static const char* CMockString_micromap = "micromap"; +static const char* CMockString_micromapCount = "micromapCount"; +static const char* CMockString_minDepthBounds = "minDepthBounds"; +static const char* CMockString_missShaderBindingOffset = "missShaderBindingOffset"; +static const char* CMockString_missShaderBindingStride = "missShaderBindingStride"; +static const char* CMockString_missShaderBindingTableBuffer = "missShaderBindingTableBuffer"; +static const char* CMockString_mode = "mode"; +static const char* CMockString_module = "module"; +static const char* CMockString_negativeOneToOne = "negativeOneToOne"; +static const char* CMockString_object = "object"; +static const char* CMockString_objectHandle = "objectHandle"; +static const char* CMockString_objectType = "objectType"; +static const char* CMockString_offset = "offset"; +static const char* CMockString_operation = "operation"; +static const char* CMockString_pAccelerationStructure = "pAccelerationStructure"; +static const char* CMockString_pAccelerationStructures = "pAccelerationStructures"; +static const char* CMockString_pAcquireInfo = "pAcquireInfo"; +static const char* CMockString_pAddress = "pAddress"; +static const char* CMockString_pAllocateInfo = "pAllocateInfo"; +static const char* CMockString_pAllocator = "pAllocator"; +static const char* CMockString_pApiVersion = "pApiVersion"; +static const char* CMockString_pAttachments = "pAttachments"; +static const char* CMockString_pBeginInfo = "pBeginInfo"; +static const char* CMockString_pBindInfo = "pBindInfo"; +static const char* CMockString_pBindInfos = "pBindInfos"; +static const char* CMockString_pBindSessionMemoryInfos = "pBindSessionMemoryInfos"; +static const char* CMockString_pBindingInfos = "pBindingInfos"; +static const char* CMockString_pBindingReference = "pBindingReference"; +static const char* CMockString_pBlitImageInfo = "pBlitImageInfo"; +static const char* CMockString_pBuffer = "pBuffer"; +static const char* CMockString_pBufferIndices = "pBufferIndices"; +static const char* CMockString_pBufferMemoryBarriers = "pBufferMemoryBarriers"; +static const char* CMockString_pBuffers = "pBuffers"; +static const char* CMockString_pBuildInfo = "pBuildInfo"; +static const char* CMockString_pCallableShaderBindingTable = "pCallableShaderBindingTable"; +static const char* CMockString_pCallback = "pCallback"; +static const char* CMockString_pCallbackData = "pCallbackData"; +static const char* CMockString_pCapabilities = "pCapabilities"; +static const char* CMockString_pCheckpointData = "pCheckpointData"; +static const char* CMockString_pCheckpointDataCount = "pCheckpointDataCount"; +static const char* CMockString_pCheckpointMarker = "pCheckpointMarker"; +static const char* CMockString_pCodingControlInfo = "pCodingControlInfo"; +static const char* CMockString_pColor = "pColor"; +static const char* CMockString_pColorBlendAdvanced = "pColorBlendAdvanced"; +static const char* CMockString_pColorBlendEnables = "pColorBlendEnables"; +static const char* CMockString_pColorBlendEquations = "pColorBlendEquations"; +static const char* CMockString_pColorWriteEnables = "pColorWriteEnables"; +static const char* CMockString_pColorWriteMasks = "pColorWriteMasks"; +static const char* CMockString_pCombinationCount = "pCombinationCount"; +static const char* CMockString_pCombinations = "pCombinations"; +static const char* CMockString_pCommandBuffers = "pCommandBuffers"; +static const char* CMockString_pCommandPool = "pCommandPool"; +static const char* CMockString_pCommittedMemoryInBytes = "pCommittedMemoryInBytes"; +static const char* CMockString_pCompatibility = "pCompatibility"; +static const char* CMockString_pConditionalRenderingBegin = "pConditionalRenderingBegin"; +static const char* CMockString_pConfiguration = "pConfiguration"; +static const char* CMockString_pCopyBufferInfo = "pCopyBufferInfo"; +static const char* CMockString_pCopyBufferToImageInfo = "pCopyBufferToImageInfo"; +static const char* CMockString_pCopyImageInfo = "pCopyImageInfo"; +static const char* CMockString_pCopyImageToBufferInfo = "pCopyImageToBufferInfo"; +static const char* CMockString_pCounterBufferOffsets = "pCounterBufferOffsets"; +static const char* CMockString_pCounterBuffers = "pCounterBuffers"; +static const char* CMockString_pCounterCount = "pCounterCount"; +static const char* CMockString_pCounterDescriptions = "pCounterDescriptions"; +static const char* CMockString_pCounterValue = "pCounterValue"; +static const char* CMockString_pCounters = "pCounters"; +static const char* CMockString_pCoverageModulationTable = "pCoverageModulationTable"; +static const char* CMockString_pCreateInfo = "pCreateInfo"; +static const char* CMockString_pCreateInfos = "pCreateInfos"; +static const char* CMockString_pCustomSampleOrders = "pCustomSampleOrders"; +static const char* CMockString_pData = "pData"; +static const char* CMockString_pDataSize = "pDataSize"; +static const char* CMockString_pDecodeInfo = "pDecodeInfo"; +static const char* CMockString_pDecompressMemoryRegions = "pDecompressMemoryRegions"; +static const char* CMockString_pDeferredOperation = "pDeferredOperation"; +static const char* CMockString_pDependencyInfo = "pDependencyInfo"; +static const char* CMockString_pDependencyInfos = "pDependencyInfos"; +static const char* CMockString_pDepthStencil = "pDepthStencil"; +static const char* CMockString_pDescriptor = "pDescriptor"; +static const char* CMockString_pDescriptorCopies = "pDescriptorCopies"; +static const char* CMockString_pDescriptorInfo = "pDescriptorInfo"; +static const char* CMockString_pDescriptorPool = "pDescriptorPool"; +static const char* CMockString_pDescriptorSets = "pDescriptorSets"; +static const char* CMockString_pDescriptorUpdateTemplate = "pDescriptorUpdateTemplate"; +static const char* CMockString_pDescriptorWrites = "pDescriptorWrites"; +static const char* CMockString_pDevice = "pDevice"; +static const char* CMockString_pDeviceEventInfo = "pDeviceEventInfo"; +static const char* CMockString_pDeviceGroupPresentCapabilities = "pDeviceGroupPresentCapabilities"; +static const char* CMockString_pDiscardRectangles = "pDiscardRectangles"; +static const char* CMockString_pDisplayCount = "pDisplayCount"; +static const char* CMockString_pDisplayEventInfo = "pDisplayEventInfo"; +static const char* CMockString_pDisplayPlaneInfo = "pDisplayPlaneInfo"; +static const char* CMockString_pDisplayPowerInfo = "pDisplayPowerInfo"; +static const char* CMockString_pDisplayTimingProperties = "pDisplayTimingProperties"; +static const char* CMockString_pDisplays = "pDisplays"; +static const char* CMockString_pDynamicOffsets = "pDynamicOffsets"; +static const char* CMockString_pEndCodingInfo = "pEndCodingInfo"; +static const char* CMockString_pEvent = "pEvent"; +static const char* CMockString_pEvents = "pEvents"; +static const char* CMockString_pExclusiveScissorEnables = "pExclusiveScissorEnables"; +static const char* CMockString_pExclusiveScissors = "pExclusiveScissors"; +static const char* CMockString_pExecutableCount = "pExecutableCount"; +static const char* CMockString_pExecutableInfo = "pExecutableInfo"; +static const char* CMockString_pExecuteInfo = "pExecuteInfo"; +static const char* CMockString_pExternalBufferInfo = "pExternalBufferInfo"; +static const char* CMockString_pExternalBufferProperties = "pExternalBufferProperties"; +static const char* CMockString_pExternalFenceInfo = "pExternalFenceInfo"; +static const char* CMockString_pExternalFenceProperties = "pExternalFenceProperties"; +static const char* CMockString_pExternalImageFormatProperties = "pExternalImageFormatProperties"; +static const char* CMockString_pExternalSemaphoreInfo = "pExternalSemaphoreInfo"; +static const char* CMockString_pExternalSemaphoreProperties = "pExternalSemaphoreProperties"; +static const char* CMockString_pFaultCounts = "pFaultCounts"; +static const char* CMockString_pFaultInfo = "pFaultInfo"; +static const char* CMockString_pFd = "pFd"; +static const char* CMockString_pFeatures = "pFeatures"; +static const char* CMockString_pFence = "pFence"; +static const char* CMockString_pFences = "pFences"; +static const char* CMockString_pFormatCount = "pFormatCount"; +static const char* CMockString_pFormatInfo = "pFormatInfo"; +static const char* CMockString_pFormatProperties = "pFormatProperties"; +static const char* CMockString_pFragmentShadingRateCount = "pFragmentShadingRateCount"; +static const char* CMockString_pFragmentShadingRates = "pFragmentShadingRates"; +static const char* CMockString_pFragmentSize = "pFragmentSize"; +static const char* CMockString_pFramebuffer = "pFramebuffer"; +static const char* CMockString_pFunction = "pFunction"; +static const char* CMockString_pGeneratedCommandsInfo = "pGeneratedCommandsInfo"; +static const char* CMockString_pGetFdInfo = "pGetFdInfo"; +static const char* CMockString_pGranularity = "pGranularity"; +static const char* CMockString_pHitShaderBindingTable = "pHitShaderBindingTable"; +static const char* CMockString_pHostMapping = "pHostMapping"; +static const char* CMockString_pHostPointer = "pHostPointer"; +static const char* CMockString_pIdentifier = "pIdentifier"; +static const char* CMockString_pImage = "pImage"; +static const char* CMockString_pImageFormatInfo = "pImageFormatInfo"; +static const char* CMockString_pImageFormatProperties = "pImageFormatProperties"; +static const char* CMockString_pImageIndex = "pImageIndex"; +static const char* CMockString_pImageMemoryBarriers = "pImageMemoryBarriers"; +static const char* CMockString_pImageSubresources = "pImageSubresources"; +static const char* CMockString_pImportFenceFdInfo = "pImportFenceFdInfo"; +static const char* CMockString_pImportSemaphoreFdInfo = "pImportSemaphoreFdInfo"; +static const char* CMockString_pIndexInfo = "pIndexInfo"; +static const char* CMockString_pIndirectCommandsLayout = "pIndirectCommandsLayout"; +static const char* CMockString_pIndirectDeviceAddresses = "pIndirectDeviceAddresses"; +static const char* CMockString_pIndirectStrides = "pIndirectStrides"; +static const char* CMockString_pInfo = "pInfo"; +static const char* CMockString_pInfoSize = "pInfoSize"; +static const char* CMockString_pInfos = "pInfos"; +static const char* CMockString_pInitializeInfo = "pInitializeInfo"; +static const char* CMockString_pInstance = "pInstance"; +static const char* CMockString_pInternalRepresentationCount = "pInternalRepresentationCount"; +static const char* CMockString_pInternalRepresentations = "pInternalRepresentations"; +static const char* CMockString_pLabelInfo = "pLabelInfo"; +static const char* CMockString_pLaunchInfo = "pLaunchInfo"; +static const char* CMockString_pLayerName = "pLayerName"; +static const char* CMockString_pLayerPrefix = "pLayerPrefix"; +static const char* CMockString_pLayout = "pLayout"; +static const char* CMockString_pLayoutSizeInBytes = "pLayoutSizeInBytes"; +static const char* CMockString_pMarkerInfo = "pMarkerInfo"; +static const char* CMockString_pMaxDeviation = "pMaxDeviation"; +static const char* CMockString_pMaxPrimitiveCounts = "pMaxPrimitiveCounts"; +static const char* CMockString_pMaxWorkgroupSize = "pMaxWorkgroupSize"; +static const char* CMockString_pMemory = "pMemory"; +static const char* CMockString_pMemoryBarriers = "pMemoryBarriers"; +static const char* CMockString_pMemoryFdProperties = "pMemoryFdProperties"; +static const char* CMockString_pMemoryGetRemoteAddressInfo = "pMemoryGetRemoteAddressInfo"; +static const char* CMockString_pMemoryHostPointerProperties = "pMemoryHostPointerProperties"; +static const char* CMockString_pMemoryMapInfo = "pMemoryMapInfo"; +static const char* CMockString_pMemoryProperties = "pMemoryProperties"; +static const char* CMockString_pMemoryRanges = "pMemoryRanges"; +static const char* CMockString_pMemoryRequirements = "pMemoryRequirements"; +static const char* CMockString_pMemoryRequirementsCount = "pMemoryRequirementsCount"; +static const char* CMockString_pMemoryUnmapInfo = "pMemoryUnmapInfo"; +static const char* CMockString_pMessage = "pMessage"; +static const char* CMockString_pMessenger = "pMessenger"; +static const char* CMockString_pMetadata = "pMetadata"; +static const char* CMockString_pMicromap = "pMicromap"; +static const char* CMockString_pMicromaps = "pMicromaps"; +static const char* CMockString_pMissShaderBindingTable = "pMissShaderBindingTable"; +static const char* CMockString_pMode = "pMode"; +static const char* CMockString_pModes = "pModes"; +static const char* CMockString_pModule = "pModule"; +static const char* CMockString_pMultisampleProperties = "pMultisampleProperties"; +static const char* CMockString_pName = "pName"; +static const char* CMockString_pNameInfo = "pNameInfo"; +static const char* CMockString_pNumPasses = "pNumPasses"; +static const char* CMockString_pOffset = "pOffset"; +static const char* CMockString_pOffsets = "pOffsets"; +static const char* CMockString_pOpticalFlowImageFormatInfo = "pOpticalFlowImageFormatInfo"; +static const char* CMockString_pOverrideInfo = "pOverrideInfo"; +static const char* CMockString_pPeerMemoryFeatures = "pPeerMemoryFeatures"; +static const char* CMockString_pPerformanceQueryCreateInfo = "pPerformanceQueryCreateInfo"; +static const char* CMockString_pPhysicalDeviceCount = "pPhysicalDeviceCount"; +static const char* CMockString_pPhysicalDeviceGroupCount = "pPhysicalDeviceGroupCount"; +static const char* CMockString_pPhysicalDeviceGroupProperties = "pPhysicalDeviceGroupProperties"; +static const char* CMockString_pPhysicalDevices = "pPhysicalDevices"; +static const char* CMockString_pPipelineCache = "pPipelineCache"; +static const char* CMockString_pPipelineInfo = "pPipelineInfo"; +static const char* CMockString_pPipelineLayout = "pPipelineLayout"; +static const char* CMockString_pPipelineProperties = "pPipelineProperties"; +static const char* CMockString_pPipelines = "pPipelines"; +static const char* CMockString_pPresentInfo = "pPresentInfo"; +static const char* CMockString_pPresentModeCount = "pPresentModeCount"; +static const char* CMockString_pPresentModes = "pPresentModes"; +static const char* CMockString_pPresentationTimingCount = "pPresentationTimingCount"; +static const char* CMockString_pPresentationTimings = "pPresentationTimings"; +static const char* CMockString_pPrivateDataSlot = "pPrivateDataSlot"; +static const char* CMockString_pProperties = "pProperties"; +static const char* CMockString_pPropertiesCount = "pPropertiesCount"; +static const char* CMockString_pPropertyCount = "pPropertyCount"; +static const char* CMockString_pQueryPool = "pQueryPool"; +static const char* CMockString_pQueue = "pQueue"; +static const char* CMockString_pQueueFamilyProperties = "pQueueFamilyProperties"; +static const char* CMockString_pQueueFamilyPropertyCount = "pQueueFamilyPropertyCount"; +static const char* CMockString_pQueueInfo = "pQueueInfo"; +static const char* CMockString_pRanges = "pRanges"; +static const char* CMockString_pRaygenShaderBindingTable = "pRaygenShaderBindingTable"; +static const char* CMockString_pRectCount = "pRectCount"; +static const char* CMockString_pRects = "pRects"; +static const char* CMockString_pRegions = "pRegions"; +static const char* CMockString_pReleaseInfo = "pReleaseInfo"; +static const char* CMockString_pRenderPass = "pRenderPass"; +static const char* CMockString_pRenderPassBegin = "pRenderPassBegin"; +static const char* CMockString_pRenderingInfo = "pRenderingInfo"; +static const char* CMockString_pResolveImageInfo = "pResolveImageInfo"; +static const char* CMockString_pSampleLocationsInfo = "pSampleLocationsInfo"; +static const char* CMockString_pSampleMask = "pSampleMask"; +static const char* CMockString_pSampler = "pSampler"; +static const char* CMockString_pScissors = "pScissors"; +static const char* CMockString_pSemaphore = "pSemaphore"; +static const char* CMockString_pSession = "pSession"; +static const char* CMockString_pSetLayout = "pSetLayout"; +static const char* CMockString_pShaderModule = "pShaderModule"; +static const char* CMockString_pShaders = "pShaders"; +static const char* CMockString_pShadingRatePalettes = "pShadingRatePalettes"; +static const char* CMockString_pSignalInfo = "pSignalInfo"; +static const char* CMockString_pSizeInfo = "pSizeInfo"; +static const char* CMockString_pSizes = "pSizes"; +static const char* CMockString_pSparseMemoryRequirementCount = "pSparseMemoryRequirementCount"; +static const char* CMockString_pSparseMemoryRequirements = "pSparseMemoryRequirements"; +static const char* CMockString_pSrcCaches = "pSrcCaches"; +static const char* CMockString_pStages = "pStages"; +static const char* CMockString_pStatisticCount = "pStatisticCount"; +static const char* CMockString_pStatistics = "pStatistics"; +static const char* CMockString_pStrides = "pStrides"; +static const char* CMockString_pSubmits = "pSubmits"; +static const char* CMockString_pSubpassBeginInfo = "pSubpassBeginInfo"; +static const char* CMockString_pSubpassEndInfo = "pSubpassEndInfo"; +static const char* CMockString_pSubresource = "pSubresource"; +static const char* CMockString_pSupport = "pSupport"; +static const char* CMockString_pSupported = "pSupported"; +static const char* CMockString_pSurface = "pSurface"; +static const char* CMockString_pSurfaceCapabilities = "pSurfaceCapabilities"; +static const char* CMockString_pSurfaceFormatCount = "pSurfaceFormatCount"; +static const char* CMockString_pSurfaceFormats = "pSurfaceFormats"; +static const char* CMockString_pSurfaceInfo = "pSurfaceInfo"; +static const char* CMockString_pSwapchain = "pSwapchain"; +static const char* CMockString_pSwapchainImageCount = "pSwapchainImageCount"; +static const char* CMockString_pSwapchainImages = "pSwapchainImages"; +static const char* CMockString_pSwapchains = "pSwapchains"; +static const char* CMockString_pTagInfo = "pTagInfo"; +static const char* CMockString_pTimeDomainCount = "pTimeDomainCount"; +static const char* CMockString_pTimeDomains = "pTimeDomains"; +static const char* CMockString_pTimestampInfos = "pTimestampInfos"; +static const char* CMockString_pTimestamps = "pTimestamps"; +static const char* CMockString_pToolCount = "pToolCount"; +static const char* CMockString_pToolProperties = "pToolProperties"; +static const char* CMockString_pUpdateInfo = "pUpdateInfo"; +static const char* CMockString_pValidationCache = "pValidationCache"; +static const char* CMockString_pValue = "pValue"; +static const char* CMockString_pValues = "pValues"; +static const char* CMockString_pVersionInfo = "pVersionInfo"; +static const char* CMockString_pVertexAttributeDescriptions = "pVertexAttributeDescriptions"; +static const char* CMockString_pVertexBindingDescriptions = "pVertexBindingDescriptions"; +static const char* CMockString_pVertexInfo = "pVertexInfo"; +static const char* CMockString_pVertexOffset = "pVertexOffset"; +static const char* CMockString_pVideoFormatInfo = "pVideoFormatInfo"; +static const char* CMockString_pVideoFormatProperties = "pVideoFormatProperties"; +static const char* CMockString_pVideoFormatPropertyCount = "pVideoFormatPropertyCount"; +static const char* CMockString_pVideoProfile = "pVideoProfile"; +static const char* CMockString_pVideoSession = "pVideoSession"; +static const char* CMockString_pVideoSessionParameters = "pVideoSessionParameters"; +static const char* CMockString_pView = "pView"; +static const char* CMockString_pViewportSwizzles = "pViewportSwizzles"; +static const char* CMockString_pViewportWScalings = "pViewportWScalings"; +static const char* CMockString_pViewports = "pViewports"; +static const char* CMockString_pWaitInfo = "pWaitInfo"; +static const char* CMockString_pYcbcrConversion = "pYcbcrConversion"; +static const char* CMockString_parameter = "parameter"; +static const char* CMockString_passOp = "passOp"; +static const char* CMockString_patchControlPoints = "patchControlPoints"; +static const char* CMockString_physicalDevice = "physicalDevice"; +static const char* CMockString_pipeline = "pipeline"; +static const char* CMockString_pipelineBindPoint = "pipelineBindPoint"; +static const char* CMockString_pipelineCache = "pipelineCache"; +static const char* CMockString_pipelineLayout = "pipelineLayout"; +static const char* CMockString_pipelineStackSize = "pipelineStackSize"; +static const char* CMockString_pipelineStage = "pipelineStage"; +static const char* CMockString_planeIndex = "planeIndex"; +static const char* CMockString_polygonMode = "polygonMode"; +static const char* CMockString_ppBuildRangeInfos = "ppBuildRangeInfos"; +static const char* CMockString_ppData = "ppData"; +static const char* CMockString_ppMaxPrimitiveCounts = "ppMaxPrimitiveCounts"; +static const char* CMockString_presentId = "presentId"; +static const char* CMockString_primitiveRestartEnable = "primitiveRestartEnable"; +static const char* CMockString_primitiveTopology = "primitiveTopology"; +static const char* CMockString_priority = "priority"; +static const char* CMockString_privateDataSlot = "privateDataSlot"; +static const char* CMockString_provokingVertexMode = "provokingVertexMode"; +static const char* CMockString_query = "query"; +static const char* CMockString_queryCount = "queryCount"; +static const char* CMockString_queryPool = "queryPool"; +static const char* CMockString_queryType = "queryType"; +static const char* CMockString_queue = "queue"; +static const char* CMockString_queueFamilyIndex = "queueFamilyIndex"; +static const char* CMockString_queueIndex = "queueIndex"; +static const char* CMockString_rangeCount = "rangeCount"; +static const char* CMockString_rasterizationSamples = "rasterizationSamples"; +static const char* CMockString_rasterizationStream = "rasterizationStream"; +static const char* CMockString_rasterizerDiscardEnable = "rasterizerDiscardEnable"; +static const char* CMockString_raygenShaderBindingOffset = "raygenShaderBindingOffset"; +static const char* CMockString_raygenShaderBindingTableBuffer = "raygenShaderBindingTableBuffer"; +static const char* CMockString_rectCount = "rectCount"; +static const char* CMockString_reference = "reference"; +static const char* CMockString_regionCount = "regionCount"; +static const char* CMockString_remoteDeviceIndex = "remoteDeviceIndex"; +static const char* CMockString_renderPass = "renderPass"; +static const char* CMockString_renderpass = "renderpass"; +static const char* CMockString_representativeFragmentTestEnable = "representativeFragmentTestEnable"; +static const char* CMockString_sampleLocationsEnable = "sampleLocationsEnable"; +static const char* CMockString_sampleOrderType = "sampleOrderType"; +static const char* CMockString_sampler = "sampler"; +static const char* CMockString_samples = "samples"; +static const char* CMockString_scissorCount = "scissorCount"; +static const char* CMockString_scratch = "scratch"; +static const char* CMockString_scratchOffset = "scratchOffset"; +static const char* CMockString_semaphore = "semaphore"; +static const char* CMockString_session = "session"; +static const char* CMockString_set = "set"; +static const char* CMockString_setCount = "setCount"; +static const char* CMockString_shader = "shader"; +static const char* CMockString_shaderModule = "shaderModule"; +static const char* CMockString_shaderStage = "shaderStage"; +static const char* CMockString_shadingRate = "shadingRate"; +static const char* CMockString_shadingRateImageEnable = "shadingRateImageEnable"; +static const char* CMockString_size = "size"; +static const char* CMockString_src = "src"; +static const char* CMockString_srcBuffer = "srcBuffer"; +static const char* CMockString_srcCacheCount = "srcCacheCount"; +static const char* CMockString_srcImage = "srcImage"; +static const char* CMockString_srcImageLayout = "srcImageLayout"; +static const char* CMockString_srcStageMask = "srcStageMask"; +static const char* CMockString_stage = "stage"; +static const char* CMockString_stageCount = "stageCount"; +static const char* CMockString_stageFlags = "stageFlags"; +static const char* CMockString_stageMask = "stageMask"; +static const char* CMockString_stencilTestEnable = "stencilTestEnable"; +static const char* CMockString_stippledLineEnable = "stippledLineEnable"; +static const char* CMockString_stride = "stride"; +static const char* CMockString_submitCount = "submitCount"; +static const char* CMockString_surface = "surface"; +static const char* CMockString_swapChain = "swapChain"; +static const char* CMockString_swapchain = "swapchain"; +static const char* CMockString_swapchainCount = "swapchainCount"; +static const char* CMockString_taskCount = "taskCount"; +static const char* CMockString_tiling = "tiling"; +static const char* CMockString_timeout = "timeout"; +static const char* CMockString_timestampCount = "timestampCount"; +static const char* CMockString_type = "type"; +static const char* CMockString_update = "update"; +static const char* CMockString_usage = "usage"; +static const char* CMockString_validationCache = "validationCache"; +static const char* CMockString_vertexAttributeDescriptionCount = "vertexAttributeDescriptionCount"; +static const char* CMockString_vertexBindingDescriptionCount = "vertexBindingDescriptionCount"; +static const char* CMockString_vertexCount = "vertexCount"; +static const char* CMockString_vertexOffset = "vertexOffset"; +static const char* CMockString_vertexStride = "vertexStride"; +static const char* CMockString_videoSession = "videoSession"; +static const char* CMockString_videoSessionParameters = "videoSessionParameters"; +static const char* CMockString_view = "view"; +static const char* CMockString_viewportCount = "viewportCount"; +static const char* CMockString_viewportWScalingEnable = "viewportWScalingEnable"; +static const char* CMockString_vkAcquireDrmDisplayEXT = "vkAcquireDrmDisplayEXT"; +static const char* CMockString_vkAcquireNextImage2KHR = "vkAcquireNextImage2KHR"; +static const char* CMockString_vkAcquireNextImageKHR = "vkAcquireNextImageKHR"; +static const char* CMockString_vkAcquirePerformanceConfigurationINTEL = "vkAcquirePerformanceConfigurationINTEL"; +static const char* CMockString_vkAcquireProfilingLockKHR = "vkAcquireProfilingLockKHR"; +static const char* CMockString_vkAllocateCommandBuffers = "vkAllocateCommandBuffers"; +static const char* CMockString_vkAllocateDescriptorSets = "vkAllocateDescriptorSets"; +static const char* CMockString_vkAllocateMemory = "vkAllocateMemory"; +static const char* CMockString_vkBeginCommandBuffer = "vkBeginCommandBuffer"; +static const char* CMockString_vkBindAccelerationStructureMemoryNV = "vkBindAccelerationStructureMemoryNV"; +static const char* CMockString_vkBindBufferMemory = "vkBindBufferMemory"; +static const char* CMockString_vkBindBufferMemory2 = "vkBindBufferMemory2"; +static const char* CMockString_vkBindBufferMemory2KHR = "vkBindBufferMemory2KHR"; +static const char* CMockString_vkBindImageMemory = "vkBindImageMemory"; +static const char* CMockString_vkBindImageMemory2 = "vkBindImageMemory2"; +static const char* CMockString_vkBindImageMemory2KHR = "vkBindImageMemory2KHR"; +static const char* CMockString_vkBindOpticalFlowSessionImageNV = "vkBindOpticalFlowSessionImageNV"; +static const char* CMockString_vkBindVideoSessionMemoryKHR = "vkBindVideoSessionMemoryKHR"; +static const char* CMockString_vkBuildAccelerationStructuresKHR = "vkBuildAccelerationStructuresKHR"; +static const char* CMockString_vkBuildMicromapsEXT = "vkBuildMicromapsEXT"; +static const char* CMockString_vkCmdBeginConditionalRenderingEXT = "vkCmdBeginConditionalRenderingEXT"; +static const char* CMockString_vkCmdBeginDebugUtilsLabelEXT = "vkCmdBeginDebugUtilsLabelEXT"; +static const char* CMockString_vkCmdBeginQuery = "vkCmdBeginQuery"; +static const char* CMockString_vkCmdBeginQueryIndexedEXT = "vkCmdBeginQueryIndexedEXT"; +static const char* CMockString_vkCmdBeginRenderPass = "vkCmdBeginRenderPass"; +static const char* CMockString_vkCmdBeginRenderPass2 = "vkCmdBeginRenderPass2"; +static const char* CMockString_vkCmdBeginRenderPass2KHR = "vkCmdBeginRenderPass2KHR"; +static const char* CMockString_vkCmdBeginRendering = "vkCmdBeginRendering"; +static const char* CMockString_vkCmdBeginRenderingKHR = "vkCmdBeginRenderingKHR"; +static const char* CMockString_vkCmdBeginTransformFeedbackEXT = "vkCmdBeginTransformFeedbackEXT"; +static const char* CMockString_vkCmdBeginVideoCodingKHR = "vkCmdBeginVideoCodingKHR"; +static const char* CMockString_vkCmdBindDescriptorBufferEmbeddedSamplersEXT = "vkCmdBindDescriptorBufferEmbeddedSamplersEXT"; +static const char* CMockString_vkCmdBindDescriptorBuffersEXT = "vkCmdBindDescriptorBuffersEXT"; +static const char* CMockString_vkCmdBindDescriptorSets = "vkCmdBindDescriptorSets"; +static const char* CMockString_vkCmdBindIndexBuffer = "vkCmdBindIndexBuffer"; +static const char* CMockString_vkCmdBindInvocationMaskHUAWEI = "vkCmdBindInvocationMaskHUAWEI"; +static const char* CMockString_vkCmdBindPipeline = "vkCmdBindPipeline"; +static const char* CMockString_vkCmdBindPipelineShaderGroupNV = "vkCmdBindPipelineShaderGroupNV"; +static const char* CMockString_vkCmdBindShadersEXT = "vkCmdBindShadersEXT"; +static const char* CMockString_vkCmdBindShadingRateImageNV = "vkCmdBindShadingRateImageNV"; +static const char* CMockString_vkCmdBindTransformFeedbackBuffersEXT = "vkCmdBindTransformFeedbackBuffersEXT"; +static const char* CMockString_vkCmdBindVertexBuffers = "vkCmdBindVertexBuffers"; +static const char* CMockString_vkCmdBindVertexBuffers2 = "vkCmdBindVertexBuffers2"; +static const char* CMockString_vkCmdBindVertexBuffers2EXT = "vkCmdBindVertexBuffers2EXT"; +static const char* CMockString_vkCmdBlitImage = "vkCmdBlitImage"; +static const char* CMockString_vkCmdBlitImage2 = "vkCmdBlitImage2"; +static const char* CMockString_vkCmdBlitImage2KHR = "vkCmdBlitImage2KHR"; +static const char* CMockString_vkCmdBuildAccelerationStructureNV = "vkCmdBuildAccelerationStructureNV"; +static const char* CMockString_vkCmdBuildAccelerationStructuresIndirectKHR = "vkCmdBuildAccelerationStructuresIndirectKHR"; +static const char* CMockString_vkCmdBuildAccelerationStructuresKHR = "vkCmdBuildAccelerationStructuresKHR"; +static const char* CMockString_vkCmdBuildMicromapsEXT = "vkCmdBuildMicromapsEXT"; +static const char* CMockString_vkCmdClearAttachments = "vkCmdClearAttachments"; +static const char* CMockString_vkCmdClearColorImage = "vkCmdClearColorImage"; +static const char* CMockString_vkCmdClearDepthStencilImage = "vkCmdClearDepthStencilImage"; +static const char* CMockString_vkCmdControlVideoCodingKHR = "vkCmdControlVideoCodingKHR"; +static const char* CMockString_vkCmdCopyAccelerationStructureKHR = "vkCmdCopyAccelerationStructureKHR"; +static const char* CMockString_vkCmdCopyAccelerationStructureNV = "vkCmdCopyAccelerationStructureNV"; +static const char* CMockString_vkCmdCopyAccelerationStructureToMemoryKHR = "vkCmdCopyAccelerationStructureToMemoryKHR"; +static const char* CMockString_vkCmdCopyBuffer = "vkCmdCopyBuffer"; +static const char* CMockString_vkCmdCopyBuffer2 = "vkCmdCopyBuffer2"; +static const char* CMockString_vkCmdCopyBuffer2KHR = "vkCmdCopyBuffer2KHR"; +static const char* CMockString_vkCmdCopyBufferToImage = "vkCmdCopyBufferToImage"; +static const char* CMockString_vkCmdCopyBufferToImage2 = "vkCmdCopyBufferToImage2"; +static const char* CMockString_vkCmdCopyBufferToImage2KHR = "vkCmdCopyBufferToImage2KHR"; +static const char* CMockString_vkCmdCopyImage = "vkCmdCopyImage"; +static const char* CMockString_vkCmdCopyImage2 = "vkCmdCopyImage2"; +static const char* CMockString_vkCmdCopyImage2KHR = "vkCmdCopyImage2KHR"; +static const char* CMockString_vkCmdCopyImageToBuffer = "vkCmdCopyImageToBuffer"; +static const char* CMockString_vkCmdCopyImageToBuffer2 = "vkCmdCopyImageToBuffer2"; +static const char* CMockString_vkCmdCopyImageToBuffer2KHR = "vkCmdCopyImageToBuffer2KHR"; +static const char* CMockString_vkCmdCopyMemoryIndirectNV = "vkCmdCopyMemoryIndirectNV"; +static const char* CMockString_vkCmdCopyMemoryToAccelerationStructureKHR = "vkCmdCopyMemoryToAccelerationStructureKHR"; +static const char* CMockString_vkCmdCopyMemoryToImageIndirectNV = "vkCmdCopyMemoryToImageIndirectNV"; +static const char* CMockString_vkCmdCopyMemoryToMicromapEXT = "vkCmdCopyMemoryToMicromapEXT"; +static const char* CMockString_vkCmdCopyMicromapEXT = "vkCmdCopyMicromapEXT"; +static const char* CMockString_vkCmdCopyMicromapToMemoryEXT = "vkCmdCopyMicromapToMemoryEXT"; +static const char* CMockString_vkCmdCopyQueryPoolResults = "vkCmdCopyQueryPoolResults"; +static const char* CMockString_vkCmdCuLaunchKernelNVX = "vkCmdCuLaunchKernelNVX"; +static const char* CMockString_vkCmdDebugMarkerBeginEXT = "vkCmdDebugMarkerBeginEXT"; +static const char* CMockString_vkCmdDebugMarkerEndEXT = "vkCmdDebugMarkerEndEXT"; +static const char* CMockString_vkCmdDebugMarkerInsertEXT = "vkCmdDebugMarkerInsertEXT"; +static const char* CMockString_vkCmdDecodeVideoKHR = "vkCmdDecodeVideoKHR"; +static const char* CMockString_vkCmdDecompressMemoryIndirectCountNV = "vkCmdDecompressMemoryIndirectCountNV"; +static const char* CMockString_vkCmdDecompressMemoryNV = "vkCmdDecompressMemoryNV"; +static const char* CMockString_vkCmdDispatch = "vkCmdDispatch"; +static const char* CMockString_vkCmdDispatchBase = "vkCmdDispatchBase"; +static const char* CMockString_vkCmdDispatchBaseKHR = "vkCmdDispatchBaseKHR"; +static const char* CMockString_vkCmdDispatchIndirect = "vkCmdDispatchIndirect"; +static const char* CMockString_vkCmdDraw = "vkCmdDraw"; +static const char* CMockString_vkCmdDrawClusterHUAWEI = "vkCmdDrawClusterHUAWEI"; +static const char* CMockString_vkCmdDrawClusterIndirectHUAWEI = "vkCmdDrawClusterIndirectHUAWEI"; +static const char* CMockString_vkCmdDrawIndexed = "vkCmdDrawIndexed"; +static const char* CMockString_vkCmdDrawIndexedIndirect = "vkCmdDrawIndexedIndirect"; +static const char* CMockString_vkCmdDrawIndexedIndirectCount = "vkCmdDrawIndexedIndirectCount"; +static const char* CMockString_vkCmdDrawIndexedIndirectCountAMD = "vkCmdDrawIndexedIndirectCountAMD"; +static const char* CMockString_vkCmdDrawIndexedIndirectCountKHR = "vkCmdDrawIndexedIndirectCountKHR"; +static const char* CMockString_vkCmdDrawIndirect = "vkCmdDrawIndirect"; +static const char* CMockString_vkCmdDrawIndirectByteCountEXT = "vkCmdDrawIndirectByteCountEXT"; +static const char* CMockString_vkCmdDrawIndirectCount = "vkCmdDrawIndirectCount"; +static const char* CMockString_vkCmdDrawIndirectCountAMD = "vkCmdDrawIndirectCountAMD"; +static const char* CMockString_vkCmdDrawIndirectCountKHR = "vkCmdDrawIndirectCountKHR"; +static const char* CMockString_vkCmdDrawMeshTasksEXT = "vkCmdDrawMeshTasksEXT"; +static const char* CMockString_vkCmdDrawMeshTasksIndirectCountEXT = "vkCmdDrawMeshTasksIndirectCountEXT"; +static const char* CMockString_vkCmdDrawMeshTasksIndirectCountNV = "vkCmdDrawMeshTasksIndirectCountNV"; +static const char* CMockString_vkCmdDrawMeshTasksIndirectEXT = "vkCmdDrawMeshTasksIndirectEXT"; +static const char* CMockString_vkCmdDrawMeshTasksIndirectNV = "vkCmdDrawMeshTasksIndirectNV"; +static const char* CMockString_vkCmdDrawMeshTasksNV = "vkCmdDrawMeshTasksNV"; +static const char* CMockString_vkCmdDrawMultiEXT = "vkCmdDrawMultiEXT"; +static const char* CMockString_vkCmdDrawMultiIndexedEXT = "vkCmdDrawMultiIndexedEXT"; +static const char* CMockString_vkCmdEndConditionalRenderingEXT = "vkCmdEndConditionalRenderingEXT"; +static const char* CMockString_vkCmdEndDebugUtilsLabelEXT = "vkCmdEndDebugUtilsLabelEXT"; +static const char* CMockString_vkCmdEndQuery = "vkCmdEndQuery"; +static const char* CMockString_vkCmdEndQueryIndexedEXT = "vkCmdEndQueryIndexedEXT"; +static const char* CMockString_vkCmdEndRenderPass = "vkCmdEndRenderPass"; +static const char* CMockString_vkCmdEndRenderPass2 = "vkCmdEndRenderPass2"; +static const char* CMockString_vkCmdEndRenderPass2KHR = "vkCmdEndRenderPass2KHR"; +static const char* CMockString_vkCmdEndRendering = "vkCmdEndRendering"; +static const char* CMockString_vkCmdEndRenderingKHR = "vkCmdEndRenderingKHR"; +static const char* CMockString_vkCmdEndTransformFeedbackEXT = "vkCmdEndTransformFeedbackEXT"; +static const char* CMockString_vkCmdEndVideoCodingKHR = "vkCmdEndVideoCodingKHR"; +static const char* CMockString_vkCmdExecuteCommands = "vkCmdExecuteCommands"; +static const char* CMockString_vkCmdExecuteGeneratedCommandsNV = "vkCmdExecuteGeneratedCommandsNV"; +static const char* CMockString_vkCmdFillBuffer = "vkCmdFillBuffer"; +static const char* CMockString_vkCmdInsertDebugUtilsLabelEXT = "vkCmdInsertDebugUtilsLabelEXT"; +static const char* CMockString_vkCmdNextSubpass = "vkCmdNextSubpass"; +static const char* CMockString_vkCmdNextSubpass2 = "vkCmdNextSubpass2"; +static const char* CMockString_vkCmdNextSubpass2KHR = "vkCmdNextSubpass2KHR"; +static const char* CMockString_vkCmdOpticalFlowExecuteNV = "vkCmdOpticalFlowExecuteNV"; +static const char* CMockString_vkCmdPipelineBarrier = "vkCmdPipelineBarrier"; +static const char* CMockString_vkCmdPipelineBarrier2 = "vkCmdPipelineBarrier2"; +static const char* CMockString_vkCmdPipelineBarrier2KHR = "vkCmdPipelineBarrier2KHR"; +static const char* CMockString_vkCmdPreprocessGeneratedCommandsNV = "vkCmdPreprocessGeneratedCommandsNV"; +static const char* CMockString_vkCmdPushConstants = "vkCmdPushConstants"; +static const char* CMockString_vkCmdPushDescriptorSetKHR = "vkCmdPushDescriptorSetKHR"; +static const char* CMockString_vkCmdPushDescriptorSetWithTemplateKHR = "vkCmdPushDescriptorSetWithTemplateKHR"; +static const char* CMockString_vkCmdResetEvent = "vkCmdResetEvent"; +static const char* CMockString_vkCmdResetEvent2 = "vkCmdResetEvent2"; +static const char* CMockString_vkCmdResetEvent2KHR = "vkCmdResetEvent2KHR"; +static const char* CMockString_vkCmdResetQueryPool = "vkCmdResetQueryPool"; +static const char* CMockString_vkCmdResolveImage = "vkCmdResolveImage"; +static const char* CMockString_vkCmdResolveImage2 = "vkCmdResolveImage2"; +static const char* CMockString_vkCmdResolveImage2KHR = "vkCmdResolveImage2KHR"; +static const char* CMockString_vkCmdSetAlphaToCoverageEnableEXT = "vkCmdSetAlphaToCoverageEnableEXT"; +static const char* CMockString_vkCmdSetAlphaToOneEnableEXT = "vkCmdSetAlphaToOneEnableEXT"; +static const char* CMockString_vkCmdSetAttachmentFeedbackLoopEnableEXT = "vkCmdSetAttachmentFeedbackLoopEnableEXT"; +static const char* CMockString_vkCmdSetBlendConstants = "vkCmdSetBlendConstants"; +static const char* CMockString_vkCmdSetCheckpointNV = "vkCmdSetCheckpointNV"; +static const char* CMockString_vkCmdSetCoarseSampleOrderNV = "vkCmdSetCoarseSampleOrderNV"; +static const char* CMockString_vkCmdSetColorBlendAdvancedEXT = "vkCmdSetColorBlendAdvancedEXT"; +static const char* CMockString_vkCmdSetColorBlendEnableEXT = "vkCmdSetColorBlendEnableEXT"; +static const char* CMockString_vkCmdSetColorBlendEquationEXT = "vkCmdSetColorBlendEquationEXT"; +static const char* CMockString_vkCmdSetColorWriteEnableEXT = "vkCmdSetColorWriteEnableEXT"; +static const char* CMockString_vkCmdSetColorWriteMaskEXT = "vkCmdSetColorWriteMaskEXT"; +static const char* CMockString_vkCmdSetConservativeRasterizationModeEXT = "vkCmdSetConservativeRasterizationModeEXT"; +static const char* CMockString_vkCmdSetCoverageModulationModeNV = "vkCmdSetCoverageModulationModeNV"; +static const char* CMockString_vkCmdSetCoverageModulationTableEnableNV = "vkCmdSetCoverageModulationTableEnableNV"; +static const char* CMockString_vkCmdSetCoverageModulationTableNV = "vkCmdSetCoverageModulationTableNV"; +static const char* CMockString_vkCmdSetCoverageReductionModeNV = "vkCmdSetCoverageReductionModeNV"; +static const char* CMockString_vkCmdSetCoverageToColorEnableNV = "vkCmdSetCoverageToColorEnableNV"; +static const char* CMockString_vkCmdSetCoverageToColorLocationNV = "vkCmdSetCoverageToColorLocationNV"; +static const char* CMockString_vkCmdSetCullMode = "vkCmdSetCullMode"; +static const char* CMockString_vkCmdSetCullModeEXT = "vkCmdSetCullModeEXT"; +static const char* CMockString_vkCmdSetDepthBias = "vkCmdSetDepthBias"; +static const char* CMockString_vkCmdSetDepthBiasEnable = "vkCmdSetDepthBiasEnable"; +static const char* CMockString_vkCmdSetDepthBiasEnableEXT = "vkCmdSetDepthBiasEnableEXT"; +static const char* CMockString_vkCmdSetDepthBounds = "vkCmdSetDepthBounds"; +static const char* CMockString_vkCmdSetDepthBoundsTestEnable = "vkCmdSetDepthBoundsTestEnable"; +static const char* CMockString_vkCmdSetDepthBoundsTestEnableEXT = "vkCmdSetDepthBoundsTestEnableEXT"; +static const char* CMockString_vkCmdSetDepthClampEnableEXT = "vkCmdSetDepthClampEnableEXT"; +static const char* CMockString_vkCmdSetDepthClipEnableEXT = "vkCmdSetDepthClipEnableEXT"; +static const char* CMockString_vkCmdSetDepthClipNegativeOneToOneEXT = "vkCmdSetDepthClipNegativeOneToOneEXT"; +static const char* CMockString_vkCmdSetDepthCompareOp = "vkCmdSetDepthCompareOp"; +static const char* CMockString_vkCmdSetDepthCompareOpEXT = "vkCmdSetDepthCompareOpEXT"; +static const char* CMockString_vkCmdSetDepthTestEnable = "vkCmdSetDepthTestEnable"; +static const char* CMockString_vkCmdSetDepthTestEnableEXT = "vkCmdSetDepthTestEnableEXT"; +static const char* CMockString_vkCmdSetDepthWriteEnable = "vkCmdSetDepthWriteEnable"; +static const char* CMockString_vkCmdSetDepthWriteEnableEXT = "vkCmdSetDepthWriteEnableEXT"; +static const char* CMockString_vkCmdSetDescriptorBufferOffsetsEXT = "vkCmdSetDescriptorBufferOffsetsEXT"; +static const char* CMockString_vkCmdSetDeviceMask = "vkCmdSetDeviceMask"; +static const char* CMockString_vkCmdSetDeviceMaskKHR = "vkCmdSetDeviceMaskKHR"; +static const char* CMockString_vkCmdSetDiscardRectangleEXT = "vkCmdSetDiscardRectangleEXT"; +static const char* CMockString_vkCmdSetDiscardRectangleEnableEXT = "vkCmdSetDiscardRectangleEnableEXT"; +static const char* CMockString_vkCmdSetDiscardRectangleModeEXT = "vkCmdSetDiscardRectangleModeEXT"; +static const char* CMockString_vkCmdSetEvent = "vkCmdSetEvent"; +static const char* CMockString_vkCmdSetEvent2 = "vkCmdSetEvent2"; +static const char* CMockString_vkCmdSetEvent2KHR = "vkCmdSetEvent2KHR"; +static const char* CMockString_vkCmdSetExclusiveScissorEnableNV = "vkCmdSetExclusiveScissorEnableNV"; +static const char* CMockString_vkCmdSetExclusiveScissorNV = "vkCmdSetExclusiveScissorNV"; +static const char* CMockString_vkCmdSetExtraPrimitiveOverestimationSizeEXT = "vkCmdSetExtraPrimitiveOverestimationSizeEXT"; +static const char* CMockString_vkCmdSetFragmentShadingRateEnumNV = "vkCmdSetFragmentShadingRateEnumNV"; +static const char* CMockString_vkCmdSetFragmentShadingRateKHR = "vkCmdSetFragmentShadingRateKHR"; +static const char* CMockString_vkCmdSetFrontFace = "vkCmdSetFrontFace"; +static const char* CMockString_vkCmdSetFrontFaceEXT = "vkCmdSetFrontFaceEXT"; +static const char* CMockString_vkCmdSetLineRasterizationModeEXT = "vkCmdSetLineRasterizationModeEXT"; +static const char* CMockString_vkCmdSetLineStippleEXT = "vkCmdSetLineStippleEXT"; +static const char* CMockString_vkCmdSetLineStippleEnableEXT = "vkCmdSetLineStippleEnableEXT"; +static const char* CMockString_vkCmdSetLineWidth = "vkCmdSetLineWidth"; +static const char* CMockString_vkCmdSetLogicOpEXT = "vkCmdSetLogicOpEXT"; +static const char* CMockString_vkCmdSetLogicOpEnableEXT = "vkCmdSetLogicOpEnableEXT"; +static const char* CMockString_vkCmdSetPatchControlPointsEXT = "vkCmdSetPatchControlPointsEXT"; +static const char* CMockString_vkCmdSetPerformanceMarkerINTEL = "vkCmdSetPerformanceMarkerINTEL"; +static const char* CMockString_vkCmdSetPerformanceOverrideINTEL = "vkCmdSetPerformanceOverrideINTEL"; +static const char* CMockString_vkCmdSetPerformanceStreamMarkerINTEL = "vkCmdSetPerformanceStreamMarkerINTEL"; +static const char* CMockString_vkCmdSetPolygonModeEXT = "vkCmdSetPolygonModeEXT"; +static const char* CMockString_vkCmdSetPrimitiveRestartEnable = "vkCmdSetPrimitiveRestartEnable"; +static const char* CMockString_vkCmdSetPrimitiveRestartEnableEXT = "vkCmdSetPrimitiveRestartEnableEXT"; +static const char* CMockString_vkCmdSetPrimitiveTopology = "vkCmdSetPrimitiveTopology"; +static const char* CMockString_vkCmdSetPrimitiveTopologyEXT = "vkCmdSetPrimitiveTopologyEXT"; +static const char* CMockString_vkCmdSetProvokingVertexModeEXT = "vkCmdSetProvokingVertexModeEXT"; +static const char* CMockString_vkCmdSetRasterizationSamplesEXT = "vkCmdSetRasterizationSamplesEXT"; +static const char* CMockString_vkCmdSetRasterizationStreamEXT = "vkCmdSetRasterizationStreamEXT"; +static const char* CMockString_vkCmdSetRasterizerDiscardEnable = "vkCmdSetRasterizerDiscardEnable"; +static const char* CMockString_vkCmdSetRasterizerDiscardEnableEXT = "vkCmdSetRasterizerDiscardEnableEXT"; +static const char* CMockString_vkCmdSetRayTracingPipelineStackSizeKHR = "vkCmdSetRayTracingPipelineStackSizeKHR"; +static const char* CMockString_vkCmdSetRepresentativeFragmentTestEnableNV = "vkCmdSetRepresentativeFragmentTestEnableNV"; +static const char* CMockString_vkCmdSetSampleLocationsEXT = "vkCmdSetSampleLocationsEXT"; +static const char* CMockString_vkCmdSetSampleLocationsEnableEXT = "vkCmdSetSampleLocationsEnableEXT"; +static const char* CMockString_vkCmdSetSampleMaskEXT = "vkCmdSetSampleMaskEXT"; +static const char* CMockString_vkCmdSetScissor = "vkCmdSetScissor"; +static const char* CMockString_vkCmdSetScissorWithCount = "vkCmdSetScissorWithCount"; +static const char* CMockString_vkCmdSetScissorWithCountEXT = "vkCmdSetScissorWithCountEXT"; +static const char* CMockString_vkCmdSetShadingRateImageEnableNV = "vkCmdSetShadingRateImageEnableNV"; +static const char* CMockString_vkCmdSetStencilCompareMask = "vkCmdSetStencilCompareMask"; +static const char* CMockString_vkCmdSetStencilOp = "vkCmdSetStencilOp"; +static const char* CMockString_vkCmdSetStencilOpEXT = "vkCmdSetStencilOpEXT"; +static const char* CMockString_vkCmdSetStencilReference = "vkCmdSetStencilReference"; +static const char* CMockString_vkCmdSetStencilTestEnable = "vkCmdSetStencilTestEnable"; +static const char* CMockString_vkCmdSetStencilTestEnableEXT = "vkCmdSetStencilTestEnableEXT"; +static const char* CMockString_vkCmdSetStencilWriteMask = "vkCmdSetStencilWriteMask"; +static const char* CMockString_vkCmdSetTessellationDomainOriginEXT = "vkCmdSetTessellationDomainOriginEXT"; +static const char* CMockString_vkCmdSetVertexInputEXT = "vkCmdSetVertexInputEXT"; +static const char* CMockString_vkCmdSetViewport = "vkCmdSetViewport"; +static const char* CMockString_vkCmdSetViewportShadingRatePaletteNV = "vkCmdSetViewportShadingRatePaletteNV"; +static const char* CMockString_vkCmdSetViewportSwizzleNV = "vkCmdSetViewportSwizzleNV"; +static const char* CMockString_vkCmdSetViewportWScalingEnableNV = "vkCmdSetViewportWScalingEnableNV"; +static const char* CMockString_vkCmdSetViewportWScalingNV = "vkCmdSetViewportWScalingNV"; +static const char* CMockString_vkCmdSetViewportWithCount = "vkCmdSetViewportWithCount"; +static const char* CMockString_vkCmdSetViewportWithCountEXT = "vkCmdSetViewportWithCountEXT"; +static const char* CMockString_vkCmdSubpassShadingHUAWEI = "vkCmdSubpassShadingHUAWEI"; +static const char* CMockString_vkCmdTraceRaysIndirect2KHR = "vkCmdTraceRaysIndirect2KHR"; +static const char* CMockString_vkCmdTraceRaysIndirectKHR = "vkCmdTraceRaysIndirectKHR"; +static const char* CMockString_vkCmdTraceRaysKHR = "vkCmdTraceRaysKHR"; +static const char* CMockString_vkCmdTraceRaysNV = "vkCmdTraceRaysNV"; +static const char* CMockString_vkCmdUpdateBuffer = "vkCmdUpdateBuffer"; +static const char* CMockString_vkCmdWaitEvents = "vkCmdWaitEvents"; +static const char* CMockString_vkCmdWaitEvents2 = "vkCmdWaitEvents2"; +static const char* CMockString_vkCmdWaitEvents2KHR = "vkCmdWaitEvents2KHR"; +static const char* CMockString_vkCmdWriteAccelerationStructuresPropertiesKHR = "vkCmdWriteAccelerationStructuresPropertiesKHR"; +static const char* CMockString_vkCmdWriteAccelerationStructuresPropertiesNV = "vkCmdWriteAccelerationStructuresPropertiesNV"; +static const char* CMockString_vkCmdWriteBufferMarker2AMD = "vkCmdWriteBufferMarker2AMD"; +static const char* CMockString_vkCmdWriteBufferMarkerAMD = "vkCmdWriteBufferMarkerAMD"; +static const char* CMockString_vkCmdWriteMicromapsPropertiesEXT = "vkCmdWriteMicromapsPropertiesEXT"; +static const char* CMockString_vkCmdWriteTimestamp = "vkCmdWriteTimestamp"; +static const char* CMockString_vkCmdWriteTimestamp2 = "vkCmdWriteTimestamp2"; +static const char* CMockString_vkCmdWriteTimestamp2KHR = "vkCmdWriteTimestamp2KHR"; +static const char* CMockString_vkCompileDeferredNV = "vkCompileDeferredNV"; +static const char* CMockString_vkCopyAccelerationStructureKHR = "vkCopyAccelerationStructureKHR"; +static const char* CMockString_vkCopyAccelerationStructureToMemoryKHR = "vkCopyAccelerationStructureToMemoryKHR"; +static const char* CMockString_vkCopyMemoryToAccelerationStructureKHR = "vkCopyMemoryToAccelerationStructureKHR"; +static const char* CMockString_vkCopyMemoryToMicromapEXT = "vkCopyMemoryToMicromapEXT"; +static const char* CMockString_vkCopyMicromapEXT = "vkCopyMicromapEXT"; +static const char* CMockString_vkCopyMicromapToMemoryEXT = "vkCopyMicromapToMemoryEXT"; +static const char* CMockString_vkCreateAccelerationStructureKHR = "vkCreateAccelerationStructureKHR"; +static const char* CMockString_vkCreateAccelerationStructureNV = "vkCreateAccelerationStructureNV"; +static const char* CMockString_vkCreateBuffer = "vkCreateBuffer"; +static const char* CMockString_vkCreateBufferView = "vkCreateBufferView"; +static const char* CMockString_vkCreateCommandPool = "vkCreateCommandPool"; +static const char* CMockString_vkCreateComputePipelines = "vkCreateComputePipelines"; +static const char* CMockString_vkCreateCuFunctionNVX = "vkCreateCuFunctionNVX"; +static const char* CMockString_vkCreateCuModuleNVX = "vkCreateCuModuleNVX"; +static const char* CMockString_vkCreateDebugReportCallbackEXT = "vkCreateDebugReportCallbackEXT"; +static const char* CMockString_vkCreateDebugUtilsMessengerEXT = "vkCreateDebugUtilsMessengerEXT"; +static const char* CMockString_vkCreateDeferredOperationKHR = "vkCreateDeferredOperationKHR"; +static const char* CMockString_vkCreateDescriptorPool = "vkCreateDescriptorPool"; +static const char* CMockString_vkCreateDescriptorSetLayout = "vkCreateDescriptorSetLayout"; +static const char* CMockString_vkCreateDescriptorUpdateTemplate = "vkCreateDescriptorUpdateTemplate"; +static const char* CMockString_vkCreateDescriptorUpdateTemplateKHR = "vkCreateDescriptorUpdateTemplateKHR"; +static const char* CMockString_vkCreateDevice = "vkCreateDevice"; +static const char* CMockString_vkCreateDisplayModeKHR = "vkCreateDisplayModeKHR"; +static const char* CMockString_vkCreateDisplayPlaneSurfaceKHR = "vkCreateDisplayPlaneSurfaceKHR"; +static const char* CMockString_vkCreateEvent = "vkCreateEvent"; +static const char* CMockString_vkCreateFence = "vkCreateFence"; +static const char* CMockString_vkCreateFramebuffer = "vkCreateFramebuffer"; +static const char* CMockString_vkCreateGraphicsPipelines = "vkCreateGraphicsPipelines"; +static const char* CMockString_vkCreateHeadlessSurfaceEXT = "vkCreateHeadlessSurfaceEXT"; +static const char* CMockString_vkCreateImage = "vkCreateImage"; +static const char* CMockString_vkCreateImageView = "vkCreateImageView"; +static const char* CMockString_vkCreateIndirectCommandsLayoutNV = "vkCreateIndirectCommandsLayoutNV"; +static const char* CMockString_vkCreateInstance = "vkCreateInstance"; +static const char* CMockString_vkCreateMicromapEXT = "vkCreateMicromapEXT"; +static const char* CMockString_vkCreateOpticalFlowSessionNV = "vkCreateOpticalFlowSessionNV"; +static const char* CMockString_vkCreatePipelineCache = "vkCreatePipelineCache"; +static const char* CMockString_vkCreatePipelineLayout = "vkCreatePipelineLayout"; +static const char* CMockString_vkCreatePrivateDataSlot = "vkCreatePrivateDataSlot"; +static const char* CMockString_vkCreatePrivateDataSlotEXT = "vkCreatePrivateDataSlotEXT"; +static const char* CMockString_vkCreateQueryPool = "vkCreateQueryPool"; +static const char* CMockString_vkCreateRayTracingPipelinesKHR = "vkCreateRayTracingPipelinesKHR"; +static const char* CMockString_vkCreateRayTracingPipelinesNV = "vkCreateRayTracingPipelinesNV"; +static const char* CMockString_vkCreateRenderPass = "vkCreateRenderPass"; +static const char* CMockString_vkCreateRenderPass2 = "vkCreateRenderPass2"; +static const char* CMockString_vkCreateRenderPass2KHR = "vkCreateRenderPass2KHR"; +static const char* CMockString_vkCreateSampler = "vkCreateSampler"; +static const char* CMockString_vkCreateSamplerYcbcrConversion = "vkCreateSamplerYcbcrConversion"; +static const char* CMockString_vkCreateSamplerYcbcrConversionKHR = "vkCreateSamplerYcbcrConversionKHR"; +static const char* CMockString_vkCreateSemaphore = "vkCreateSemaphore"; +static const char* CMockString_vkCreateShaderModule = "vkCreateShaderModule"; +static const char* CMockString_vkCreateShadersEXT = "vkCreateShadersEXT"; +static const char* CMockString_vkCreateSharedSwapchainsKHR = "vkCreateSharedSwapchainsKHR"; +static const char* CMockString_vkCreateSwapchainKHR = "vkCreateSwapchainKHR"; +static const char* CMockString_vkCreateValidationCacheEXT = "vkCreateValidationCacheEXT"; +static const char* CMockString_vkCreateVideoSessionKHR = "vkCreateVideoSessionKHR"; +static const char* CMockString_vkCreateVideoSessionParametersKHR = "vkCreateVideoSessionParametersKHR"; +static const char* CMockString_vkDebugMarkerSetObjectNameEXT = "vkDebugMarkerSetObjectNameEXT"; +static const char* CMockString_vkDebugMarkerSetObjectTagEXT = "vkDebugMarkerSetObjectTagEXT"; +static const char* CMockString_vkDebugReportMessageEXT = "vkDebugReportMessageEXT"; +static const char* CMockString_vkDeferredOperationJoinKHR = "vkDeferredOperationJoinKHR"; +static const char* CMockString_vkDestroyAccelerationStructureKHR = "vkDestroyAccelerationStructureKHR"; +static const char* CMockString_vkDestroyAccelerationStructureNV = "vkDestroyAccelerationStructureNV"; +static const char* CMockString_vkDestroyBuffer = "vkDestroyBuffer"; +static const char* CMockString_vkDestroyBufferView = "vkDestroyBufferView"; +static const char* CMockString_vkDestroyCommandPool = "vkDestroyCommandPool"; +static const char* CMockString_vkDestroyCuFunctionNVX = "vkDestroyCuFunctionNVX"; +static const char* CMockString_vkDestroyCuModuleNVX = "vkDestroyCuModuleNVX"; +static const char* CMockString_vkDestroyDebugReportCallbackEXT = "vkDestroyDebugReportCallbackEXT"; +static const char* CMockString_vkDestroyDebugUtilsMessengerEXT = "vkDestroyDebugUtilsMessengerEXT"; +static const char* CMockString_vkDestroyDeferredOperationKHR = "vkDestroyDeferredOperationKHR"; +static const char* CMockString_vkDestroyDescriptorPool = "vkDestroyDescriptorPool"; +static const char* CMockString_vkDestroyDescriptorSetLayout = "vkDestroyDescriptorSetLayout"; +static const char* CMockString_vkDestroyDescriptorUpdateTemplate = "vkDestroyDescriptorUpdateTemplate"; +static const char* CMockString_vkDestroyDescriptorUpdateTemplateKHR = "vkDestroyDescriptorUpdateTemplateKHR"; +static const char* CMockString_vkDestroyDevice = "vkDestroyDevice"; +static const char* CMockString_vkDestroyEvent = "vkDestroyEvent"; +static const char* CMockString_vkDestroyFence = "vkDestroyFence"; +static const char* CMockString_vkDestroyFramebuffer = "vkDestroyFramebuffer"; +static const char* CMockString_vkDestroyImage = "vkDestroyImage"; +static const char* CMockString_vkDestroyImageView = "vkDestroyImageView"; +static const char* CMockString_vkDestroyIndirectCommandsLayoutNV = "vkDestroyIndirectCommandsLayoutNV"; +static const char* CMockString_vkDestroyInstance = "vkDestroyInstance"; +static const char* CMockString_vkDestroyMicromapEXT = "vkDestroyMicromapEXT"; +static const char* CMockString_vkDestroyOpticalFlowSessionNV = "vkDestroyOpticalFlowSessionNV"; +static const char* CMockString_vkDestroyPipeline = "vkDestroyPipeline"; +static const char* CMockString_vkDestroyPipelineCache = "vkDestroyPipelineCache"; +static const char* CMockString_vkDestroyPipelineLayout = "vkDestroyPipelineLayout"; +static const char* CMockString_vkDestroyPrivateDataSlot = "vkDestroyPrivateDataSlot"; +static const char* CMockString_vkDestroyPrivateDataSlotEXT = "vkDestroyPrivateDataSlotEXT"; +static const char* CMockString_vkDestroyQueryPool = "vkDestroyQueryPool"; +static const char* CMockString_vkDestroyRenderPass = "vkDestroyRenderPass"; +static const char* CMockString_vkDestroySampler = "vkDestroySampler"; +static const char* CMockString_vkDestroySamplerYcbcrConversion = "vkDestroySamplerYcbcrConversion"; +static const char* CMockString_vkDestroySamplerYcbcrConversionKHR = "vkDestroySamplerYcbcrConversionKHR"; +static const char* CMockString_vkDestroySemaphore = "vkDestroySemaphore"; +static const char* CMockString_vkDestroyShaderEXT = "vkDestroyShaderEXT"; +static const char* CMockString_vkDestroyShaderModule = "vkDestroyShaderModule"; +static const char* CMockString_vkDestroySurfaceKHR = "vkDestroySurfaceKHR"; +static const char* CMockString_vkDestroySwapchainKHR = "vkDestroySwapchainKHR"; +static const char* CMockString_vkDestroyValidationCacheEXT = "vkDestroyValidationCacheEXT"; +static const char* CMockString_vkDestroyVideoSessionKHR = "vkDestroyVideoSessionKHR"; +static const char* CMockString_vkDestroyVideoSessionParametersKHR = "vkDestroyVideoSessionParametersKHR"; +static const char* CMockString_vkDeviceWaitIdle = "vkDeviceWaitIdle"; +static const char* CMockString_vkDisplayPowerControlEXT = "vkDisplayPowerControlEXT"; +static const char* CMockString_vkEndCommandBuffer = "vkEndCommandBuffer"; +static const char* CMockString_vkEnumerateDeviceExtensionProperties = "vkEnumerateDeviceExtensionProperties"; +static const char* CMockString_vkEnumerateDeviceLayerProperties = "vkEnumerateDeviceLayerProperties"; +static const char* CMockString_vkEnumerateInstanceExtensionProperties = "vkEnumerateInstanceExtensionProperties"; +static const char* CMockString_vkEnumerateInstanceLayerProperties = "vkEnumerateInstanceLayerProperties"; +static const char* CMockString_vkEnumerateInstanceVersion = "vkEnumerateInstanceVersion"; +static const char* CMockString_vkEnumeratePhysicalDeviceGroups = "vkEnumeratePhysicalDeviceGroups"; +static const char* CMockString_vkEnumeratePhysicalDeviceGroupsKHR = "vkEnumeratePhysicalDeviceGroupsKHR"; +static const char* CMockString_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR"; +static const char* CMockString_vkEnumeratePhysicalDevices = "vkEnumeratePhysicalDevices"; +static const char* CMockString_vkFlushMappedMemoryRanges = "vkFlushMappedMemoryRanges"; +static const char* CMockString_vkFreeCommandBuffers = "vkFreeCommandBuffers"; +static const char* CMockString_vkFreeDescriptorSets = "vkFreeDescriptorSets"; +static const char* CMockString_vkFreeMemory = "vkFreeMemory"; +static const char* CMockString_vkGetAccelerationStructureBuildSizesKHR = "vkGetAccelerationStructureBuildSizesKHR"; +static const char* CMockString_vkGetAccelerationStructureDeviceAddressKHR = "vkGetAccelerationStructureDeviceAddressKHR"; +static const char* CMockString_vkGetAccelerationStructureHandleNV = "vkGetAccelerationStructureHandleNV"; +static const char* CMockString_vkGetAccelerationStructureMemoryRequirementsNV = "vkGetAccelerationStructureMemoryRequirementsNV"; +static const char* CMockString_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT"; +static const char* CMockString_vkGetBufferDeviceAddress = "vkGetBufferDeviceAddress"; +static const char* CMockString_vkGetBufferDeviceAddressEXT = "vkGetBufferDeviceAddressEXT"; +static const char* CMockString_vkGetBufferDeviceAddressKHR = "vkGetBufferDeviceAddressKHR"; +static const char* CMockString_vkGetBufferMemoryRequirements = "vkGetBufferMemoryRequirements"; +static const char* CMockString_vkGetBufferMemoryRequirements2 = "vkGetBufferMemoryRequirements2"; +static const char* CMockString_vkGetBufferMemoryRequirements2KHR = "vkGetBufferMemoryRequirements2KHR"; +static const char* CMockString_vkGetBufferOpaqueCaptureAddress = "vkGetBufferOpaqueCaptureAddress"; +static const char* CMockString_vkGetBufferOpaqueCaptureAddressKHR = "vkGetBufferOpaqueCaptureAddressKHR"; +static const char* CMockString_vkGetBufferOpaqueCaptureDescriptorDataEXT = "vkGetBufferOpaqueCaptureDescriptorDataEXT"; +static const char* CMockString_vkGetCalibratedTimestampsEXT = "vkGetCalibratedTimestampsEXT"; +static const char* CMockString_vkGetDeferredOperationMaxConcurrencyKHR = "vkGetDeferredOperationMaxConcurrencyKHR"; +static const char* CMockString_vkGetDeferredOperationResultKHR = "vkGetDeferredOperationResultKHR"; +static const char* CMockString_vkGetDescriptorEXT = "vkGetDescriptorEXT"; +static const char* CMockString_vkGetDescriptorSetHostMappingVALVE = "vkGetDescriptorSetHostMappingVALVE"; +static const char* CMockString_vkGetDescriptorSetLayoutBindingOffsetEXT = "vkGetDescriptorSetLayoutBindingOffsetEXT"; +static const char* CMockString_vkGetDescriptorSetLayoutHostMappingInfoVALVE = "vkGetDescriptorSetLayoutHostMappingInfoVALVE"; +static const char* CMockString_vkGetDescriptorSetLayoutSizeEXT = "vkGetDescriptorSetLayoutSizeEXT"; +static const char* CMockString_vkGetDescriptorSetLayoutSupport = "vkGetDescriptorSetLayoutSupport"; +static const char* CMockString_vkGetDescriptorSetLayoutSupportKHR = "vkGetDescriptorSetLayoutSupportKHR"; +static const char* CMockString_vkGetDeviceAccelerationStructureCompatibilityKHR = "vkGetDeviceAccelerationStructureCompatibilityKHR"; +static const char* CMockString_vkGetDeviceBufferMemoryRequirements = "vkGetDeviceBufferMemoryRequirements"; +static const char* CMockString_vkGetDeviceBufferMemoryRequirementsKHR = "vkGetDeviceBufferMemoryRequirementsKHR"; +static const char* CMockString_vkGetDeviceFaultInfoEXT = "vkGetDeviceFaultInfoEXT"; +static const char* CMockString_vkGetDeviceGroupPeerMemoryFeatures = "vkGetDeviceGroupPeerMemoryFeatures"; +static const char* CMockString_vkGetDeviceGroupPeerMemoryFeaturesKHR = "vkGetDeviceGroupPeerMemoryFeaturesKHR"; +static const char* CMockString_vkGetDeviceGroupPresentCapabilitiesKHR = "vkGetDeviceGroupPresentCapabilitiesKHR"; +static const char* CMockString_vkGetDeviceGroupSurfacePresentModesKHR = "vkGetDeviceGroupSurfacePresentModesKHR"; +static const char* CMockString_vkGetDeviceImageMemoryRequirements = "vkGetDeviceImageMemoryRequirements"; +static const char* CMockString_vkGetDeviceImageMemoryRequirementsKHR = "vkGetDeviceImageMemoryRequirementsKHR"; +static const char* CMockString_vkGetDeviceImageSparseMemoryRequirements = "vkGetDeviceImageSparseMemoryRequirements"; +static const char* CMockString_vkGetDeviceImageSparseMemoryRequirementsKHR = "vkGetDeviceImageSparseMemoryRequirementsKHR"; +static const char* CMockString_vkGetDeviceMemoryCommitment = "vkGetDeviceMemoryCommitment"; +static const char* CMockString_vkGetDeviceMemoryOpaqueCaptureAddress = "vkGetDeviceMemoryOpaqueCaptureAddress"; +static const char* CMockString_vkGetDeviceMemoryOpaqueCaptureAddressKHR = "vkGetDeviceMemoryOpaqueCaptureAddressKHR"; +static const char* CMockString_vkGetDeviceMicromapCompatibilityEXT = "vkGetDeviceMicromapCompatibilityEXT"; +static const char* CMockString_vkGetDeviceProcAddr = "vkGetDeviceProcAddr"; +static const char* CMockString_vkGetDeviceQueue = "vkGetDeviceQueue"; +static const char* CMockString_vkGetDeviceQueue2 = "vkGetDeviceQueue2"; +static const char* CMockString_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI"; +static const char* CMockString_vkGetDisplayModeProperties2KHR = "vkGetDisplayModeProperties2KHR"; +static const char* CMockString_vkGetDisplayModePropertiesKHR = "vkGetDisplayModePropertiesKHR"; +static const char* CMockString_vkGetDisplayPlaneCapabilities2KHR = "vkGetDisplayPlaneCapabilities2KHR"; +static const char* CMockString_vkGetDisplayPlaneCapabilitiesKHR = "vkGetDisplayPlaneCapabilitiesKHR"; +static const char* CMockString_vkGetDisplayPlaneSupportedDisplaysKHR = "vkGetDisplayPlaneSupportedDisplaysKHR"; +static const char* CMockString_vkGetDrmDisplayEXT = "vkGetDrmDisplayEXT"; +static const char* CMockString_vkGetDynamicRenderingTilePropertiesQCOM = "vkGetDynamicRenderingTilePropertiesQCOM"; +static const char* CMockString_vkGetEventStatus = "vkGetEventStatus"; +static const char* CMockString_vkGetFenceFdKHR = "vkGetFenceFdKHR"; +static const char* CMockString_vkGetFenceStatus = "vkGetFenceStatus"; +static const char* CMockString_vkGetFramebufferTilePropertiesQCOM = "vkGetFramebufferTilePropertiesQCOM"; +static const char* CMockString_vkGetGeneratedCommandsMemoryRequirementsNV = "vkGetGeneratedCommandsMemoryRequirementsNV"; +static const char* CMockString_vkGetImageDrmFormatModifierPropertiesEXT = "vkGetImageDrmFormatModifierPropertiesEXT"; +static const char* CMockString_vkGetImageMemoryRequirements = "vkGetImageMemoryRequirements"; +static const char* CMockString_vkGetImageMemoryRequirements2 = "vkGetImageMemoryRequirements2"; +static const char* CMockString_vkGetImageMemoryRequirements2KHR = "vkGetImageMemoryRequirements2KHR"; +static const char* CMockString_vkGetImageOpaqueCaptureDescriptorDataEXT = "vkGetImageOpaqueCaptureDescriptorDataEXT"; +static const char* CMockString_vkGetImageSparseMemoryRequirements = "vkGetImageSparseMemoryRequirements"; +static const char* CMockString_vkGetImageSparseMemoryRequirements2 = "vkGetImageSparseMemoryRequirements2"; +static const char* CMockString_vkGetImageSparseMemoryRequirements2KHR = "vkGetImageSparseMemoryRequirements2KHR"; +static const char* CMockString_vkGetImageSubresourceLayout = "vkGetImageSubresourceLayout"; +static const char* CMockString_vkGetImageSubresourceLayout2EXT = "vkGetImageSubresourceLayout2EXT"; +static const char* CMockString_vkGetImageViewAddressNVX = "vkGetImageViewAddressNVX"; +static const char* CMockString_vkGetImageViewHandleNVX = "vkGetImageViewHandleNVX"; +static const char* CMockString_vkGetImageViewOpaqueCaptureDescriptorDataEXT = "vkGetImageViewOpaqueCaptureDescriptorDataEXT"; +static const char* CMockString_vkGetInstanceProcAddr = "vkGetInstanceProcAddr"; +static const char* CMockString_vkGetMemoryFdKHR = "vkGetMemoryFdKHR"; +static const char* CMockString_vkGetMemoryFdPropertiesKHR = "vkGetMemoryFdPropertiesKHR"; +static const char* CMockString_vkGetMemoryHostPointerPropertiesEXT = "vkGetMemoryHostPointerPropertiesEXT"; +static const char* CMockString_vkGetMemoryRemoteAddressNV = "vkGetMemoryRemoteAddressNV"; +static const char* CMockString_vkGetMicromapBuildSizesEXT = "vkGetMicromapBuildSizesEXT"; +static const char* CMockString_vkGetPastPresentationTimingGOOGLE = "vkGetPastPresentationTimingGOOGLE"; +static const char* CMockString_vkGetPerformanceParameterINTEL = "vkGetPerformanceParameterINTEL"; +static const char* CMockString_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT"; +static const char* CMockString_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV"; +static const char* CMockString_vkGetPhysicalDeviceDisplayPlaneProperties2KHR = "vkGetPhysicalDeviceDisplayPlaneProperties2KHR"; +static const char* CMockString_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = "vkGetPhysicalDeviceDisplayPlanePropertiesKHR"; +static const char* CMockString_vkGetPhysicalDeviceDisplayProperties2KHR = "vkGetPhysicalDeviceDisplayProperties2KHR"; +static const char* CMockString_vkGetPhysicalDeviceDisplayPropertiesKHR = "vkGetPhysicalDeviceDisplayPropertiesKHR"; +static const char* CMockString_vkGetPhysicalDeviceExternalBufferProperties = "vkGetPhysicalDeviceExternalBufferProperties"; +static const char* CMockString_vkGetPhysicalDeviceExternalBufferPropertiesKHR = "vkGetPhysicalDeviceExternalBufferPropertiesKHR"; +static const char* CMockString_vkGetPhysicalDeviceExternalFenceProperties = "vkGetPhysicalDeviceExternalFenceProperties"; +static const char* CMockString_vkGetPhysicalDeviceExternalFencePropertiesKHR = "vkGetPhysicalDeviceExternalFencePropertiesKHR"; +static const char* CMockString_vkGetPhysicalDeviceExternalImageFormatPropertiesNV = "vkGetPhysicalDeviceExternalImageFormatPropertiesNV"; +static const char* CMockString_vkGetPhysicalDeviceExternalSemaphoreProperties = "vkGetPhysicalDeviceExternalSemaphoreProperties"; +static const char* CMockString_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR"; +static const char* CMockString_vkGetPhysicalDeviceFeatures = "vkGetPhysicalDeviceFeatures"; +static const char* CMockString_vkGetPhysicalDeviceFeatures2 = "vkGetPhysicalDeviceFeatures2"; +static const char* CMockString_vkGetPhysicalDeviceFeatures2KHR = "vkGetPhysicalDeviceFeatures2KHR"; +static const char* CMockString_vkGetPhysicalDeviceFormatProperties = "vkGetPhysicalDeviceFormatProperties"; +static const char* CMockString_vkGetPhysicalDeviceFormatProperties2 = "vkGetPhysicalDeviceFormatProperties2"; +static const char* CMockString_vkGetPhysicalDeviceFormatProperties2KHR = "vkGetPhysicalDeviceFormatProperties2KHR"; +static const char* CMockString_vkGetPhysicalDeviceFragmentShadingRatesKHR = "vkGetPhysicalDeviceFragmentShadingRatesKHR"; +static const char* CMockString_vkGetPhysicalDeviceImageFormatProperties = "vkGetPhysicalDeviceImageFormatProperties"; +static const char* CMockString_vkGetPhysicalDeviceImageFormatProperties2 = "vkGetPhysicalDeviceImageFormatProperties2"; +static const char* CMockString_vkGetPhysicalDeviceImageFormatProperties2KHR = "vkGetPhysicalDeviceImageFormatProperties2KHR"; +static const char* CMockString_vkGetPhysicalDeviceMemoryProperties = "vkGetPhysicalDeviceMemoryProperties"; +static const char* CMockString_vkGetPhysicalDeviceMemoryProperties2 = "vkGetPhysicalDeviceMemoryProperties2"; +static const char* CMockString_vkGetPhysicalDeviceMemoryProperties2KHR = "vkGetPhysicalDeviceMemoryProperties2KHR"; +static const char* CMockString_vkGetPhysicalDeviceMultisamplePropertiesEXT = "vkGetPhysicalDeviceMultisamplePropertiesEXT"; +static const char* CMockString_vkGetPhysicalDeviceOpticalFlowImageFormatsNV = "vkGetPhysicalDeviceOpticalFlowImageFormatsNV"; +static const char* CMockString_vkGetPhysicalDevicePresentRectanglesKHR = "vkGetPhysicalDevicePresentRectanglesKHR"; +static const char* CMockString_vkGetPhysicalDeviceProperties = "vkGetPhysicalDeviceProperties"; +static const char* CMockString_vkGetPhysicalDeviceProperties2 = "vkGetPhysicalDeviceProperties2"; +static const char* CMockString_vkGetPhysicalDeviceProperties2KHR = "vkGetPhysicalDeviceProperties2KHR"; +static const char* CMockString_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR"; +static const char* CMockString_vkGetPhysicalDeviceQueueFamilyProperties = "vkGetPhysicalDeviceQueueFamilyProperties"; +static const char* CMockString_vkGetPhysicalDeviceQueueFamilyProperties2 = "vkGetPhysicalDeviceQueueFamilyProperties2"; +static const char* CMockString_vkGetPhysicalDeviceQueueFamilyProperties2KHR = "vkGetPhysicalDeviceQueueFamilyProperties2KHR"; +static const char* CMockString_vkGetPhysicalDeviceSparseImageFormatProperties = "vkGetPhysicalDeviceSparseImageFormatProperties"; +static const char* CMockString_vkGetPhysicalDeviceSparseImageFormatProperties2 = "vkGetPhysicalDeviceSparseImageFormatProperties2"; +static const char* CMockString_vkGetPhysicalDeviceSparseImageFormatProperties2KHR = "vkGetPhysicalDeviceSparseImageFormatProperties2KHR"; +static const char* CMockString_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV"; +static const char* CMockString_vkGetPhysicalDeviceSurfaceCapabilities2EXT = "vkGetPhysicalDeviceSurfaceCapabilities2EXT"; +static const char* CMockString_vkGetPhysicalDeviceSurfaceCapabilities2KHR = "vkGetPhysicalDeviceSurfaceCapabilities2KHR"; +static const char* CMockString_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"; +static const char* CMockString_vkGetPhysicalDeviceSurfaceFormats2KHR = "vkGetPhysicalDeviceSurfaceFormats2KHR"; +static const char* CMockString_vkGetPhysicalDeviceSurfaceFormatsKHR = "vkGetPhysicalDeviceSurfaceFormatsKHR"; +static const char* CMockString_vkGetPhysicalDeviceSurfacePresentModesKHR = "vkGetPhysicalDeviceSurfacePresentModesKHR"; +static const char* CMockString_vkGetPhysicalDeviceSurfaceSupportKHR = "vkGetPhysicalDeviceSurfaceSupportKHR"; +static const char* CMockString_vkGetPhysicalDeviceToolProperties = "vkGetPhysicalDeviceToolProperties"; +static const char* CMockString_vkGetPhysicalDeviceToolPropertiesEXT = "vkGetPhysicalDeviceToolPropertiesEXT"; +static const char* CMockString_vkGetPhysicalDeviceVideoCapabilitiesKHR = "vkGetPhysicalDeviceVideoCapabilitiesKHR"; +static const char* CMockString_vkGetPhysicalDeviceVideoFormatPropertiesKHR = "vkGetPhysicalDeviceVideoFormatPropertiesKHR"; +static const char* CMockString_vkGetPipelineCacheData = "vkGetPipelineCacheData"; +static const char* CMockString_vkGetPipelineExecutableInternalRepresentationsKHR = "vkGetPipelineExecutableInternalRepresentationsKHR"; +static const char* CMockString_vkGetPipelineExecutablePropertiesKHR = "vkGetPipelineExecutablePropertiesKHR"; +static const char* CMockString_vkGetPipelineExecutableStatisticsKHR = "vkGetPipelineExecutableStatisticsKHR"; +static const char* CMockString_vkGetPipelinePropertiesEXT = "vkGetPipelinePropertiesEXT"; +static const char* CMockString_vkGetPrivateData = "vkGetPrivateData"; +static const char* CMockString_vkGetPrivateDataEXT = "vkGetPrivateDataEXT"; +static const char* CMockString_vkGetQueryPoolResults = "vkGetQueryPoolResults"; +static const char* CMockString_vkGetQueueCheckpointData2NV = "vkGetQueueCheckpointData2NV"; +static const char* CMockString_vkGetQueueCheckpointDataNV = "vkGetQueueCheckpointDataNV"; +static const char* CMockString_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR"; +static const char* CMockString_vkGetRayTracingShaderGroupHandlesKHR = "vkGetRayTracingShaderGroupHandlesKHR"; +static const char* CMockString_vkGetRayTracingShaderGroupHandlesNV = "vkGetRayTracingShaderGroupHandlesNV"; +static const char* CMockString_vkGetRayTracingShaderGroupStackSizeKHR = "vkGetRayTracingShaderGroupStackSizeKHR"; +static const char* CMockString_vkGetRefreshCycleDurationGOOGLE = "vkGetRefreshCycleDurationGOOGLE"; +static const char* CMockString_vkGetRenderAreaGranularity = "vkGetRenderAreaGranularity"; +static const char* CMockString_vkGetSamplerOpaqueCaptureDescriptorDataEXT = "vkGetSamplerOpaqueCaptureDescriptorDataEXT"; +static const char* CMockString_vkGetSemaphoreCounterValue = "vkGetSemaphoreCounterValue"; +static const char* CMockString_vkGetSemaphoreCounterValueKHR = "vkGetSemaphoreCounterValueKHR"; +static const char* CMockString_vkGetSemaphoreFdKHR = "vkGetSemaphoreFdKHR"; +static const char* CMockString_vkGetShaderBinaryDataEXT = "vkGetShaderBinaryDataEXT"; +static const char* CMockString_vkGetShaderInfoAMD = "vkGetShaderInfoAMD"; +static const char* CMockString_vkGetShaderModuleCreateInfoIdentifierEXT = "vkGetShaderModuleCreateInfoIdentifierEXT"; +static const char* CMockString_vkGetShaderModuleIdentifierEXT = "vkGetShaderModuleIdentifierEXT"; +static const char* CMockString_vkGetSwapchainCounterEXT = "vkGetSwapchainCounterEXT"; +static const char* CMockString_vkGetSwapchainImagesKHR = "vkGetSwapchainImagesKHR"; +static const char* CMockString_vkGetSwapchainStatusKHR = "vkGetSwapchainStatusKHR"; +static const char* CMockString_vkGetValidationCacheDataEXT = "vkGetValidationCacheDataEXT"; +static const char* CMockString_vkGetVideoSessionMemoryRequirementsKHR = "vkGetVideoSessionMemoryRequirementsKHR"; +static const char* CMockString_vkImportFenceFdKHR = "vkImportFenceFdKHR"; +static const char* CMockString_vkImportSemaphoreFdKHR = "vkImportSemaphoreFdKHR"; +static const char* CMockString_vkInitializePerformanceApiINTEL = "vkInitializePerformanceApiINTEL"; +static const char* CMockString_vkInvalidateMappedMemoryRanges = "vkInvalidateMappedMemoryRanges"; +static const char* CMockString_vkMapMemory = "vkMapMemory"; +static const char* CMockString_vkMapMemory2KHR = "vkMapMemory2KHR"; +static const char* CMockString_vkMergePipelineCaches = "vkMergePipelineCaches"; +static const char* CMockString_vkMergeValidationCachesEXT = "vkMergeValidationCachesEXT"; +static const char* CMockString_vkQueueBeginDebugUtilsLabelEXT = "vkQueueBeginDebugUtilsLabelEXT"; +static const char* CMockString_vkQueueBindSparse = "vkQueueBindSparse"; +static const char* CMockString_vkQueueEndDebugUtilsLabelEXT = "vkQueueEndDebugUtilsLabelEXT"; +static const char* CMockString_vkQueueInsertDebugUtilsLabelEXT = "vkQueueInsertDebugUtilsLabelEXT"; +static const char* CMockString_vkQueuePresentKHR = "vkQueuePresentKHR"; +static const char* CMockString_vkQueueSetPerformanceConfigurationINTEL = "vkQueueSetPerformanceConfigurationINTEL"; +static const char* CMockString_vkQueueSubmit = "vkQueueSubmit"; +static const char* CMockString_vkQueueSubmit2 = "vkQueueSubmit2"; +static const char* CMockString_vkQueueSubmit2KHR = "vkQueueSubmit2KHR"; +static const char* CMockString_vkQueueWaitIdle = "vkQueueWaitIdle"; +static const char* CMockString_vkRegisterDeviceEventEXT = "vkRegisterDeviceEventEXT"; +static const char* CMockString_vkRegisterDisplayEventEXT = "vkRegisterDisplayEventEXT"; +static const char* CMockString_vkReleaseDisplayEXT = "vkReleaseDisplayEXT"; +static const char* CMockString_vkReleasePerformanceConfigurationINTEL = "vkReleasePerformanceConfigurationINTEL"; +static const char* CMockString_vkReleaseProfilingLockKHR = "vkReleaseProfilingLockKHR"; +static const char* CMockString_vkReleaseSwapchainImagesEXT = "vkReleaseSwapchainImagesEXT"; +static const char* CMockString_vkResetCommandBuffer = "vkResetCommandBuffer"; +static const char* CMockString_vkResetCommandPool = "vkResetCommandPool"; +static const char* CMockString_vkResetDescriptorPool = "vkResetDescriptorPool"; +static const char* CMockString_vkResetEvent = "vkResetEvent"; +static const char* CMockString_vkResetFences = "vkResetFences"; +static const char* CMockString_vkResetQueryPool = "vkResetQueryPool"; +static const char* CMockString_vkResetQueryPoolEXT = "vkResetQueryPoolEXT"; +static const char* CMockString_vkSetDebugUtilsObjectNameEXT = "vkSetDebugUtilsObjectNameEXT"; +static const char* CMockString_vkSetDebugUtilsObjectTagEXT = "vkSetDebugUtilsObjectTagEXT"; +static const char* CMockString_vkSetDeviceMemoryPriorityEXT = "vkSetDeviceMemoryPriorityEXT"; +static const char* CMockString_vkSetEvent = "vkSetEvent"; +static const char* CMockString_vkSetHdrMetadataEXT = "vkSetHdrMetadataEXT"; +static const char* CMockString_vkSetLocalDimmingAMD = "vkSetLocalDimmingAMD"; +static const char* CMockString_vkSetPrivateData = "vkSetPrivateData"; +static const char* CMockString_vkSetPrivateDataEXT = "vkSetPrivateDataEXT"; +static const char* CMockString_vkSignalSemaphore = "vkSignalSemaphore"; +static const char* CMockString_vkSignalSemaphoreKHR = "vkSignalSemaphoreKHR"; +static const char* CMockString_vkSubmitDebugUtilsMessageEXT = "vkSubmitDebugUtilsMessageEXT"; +static const char* CMockString_vkTrimCommandPool = "vkTrimCommandPool"; +static const char* CMockString_vkTrimCommandPoolKHR = "vkTrimCommandPoolKHR"; +static const char* CMockString_vkUninitializePerformanceApiINTEL = "vkUninitializePerformanceApiINTEL"; +static const char* CMockString_vkUnmapMemory = "vkUnmapMemory"; +static const char* CMockString_vkUnmapMemory2KHR = "vkUnmapMemory2KHR"; +static const char* CMockString_vkUpdateDescriptorSetWithTemplate = "vkUpdateDescriptorSetWithTemplate"; +static const char* CMockString_vkUpdateDescriptorSetWithTemplateKHR = "vkUpdateDescriptorSetWithTemplateKHR"; +static const char* CMockString_vkUpdateDescriptorSets = "vkUpdateDescriptorSets"; +static const char* CMockString_vkUpdateVideoSessionParametersKHR = "vkUpdateVideoSessionParametersKHR"; +static const char* CMockString_vkWaitForFences = "vkWaitForFences"; +static const char* CMockString_vkWaitForPresentKHR = "vkWaitForPresentKHR"; +static const char* CMockString_vkWaitSemaphores = "vkWaitSemaphores"; +static const char* CMockString_vkWaitSemaphoresKHR = "vkWaitSemaphoresKHR"; +static const char* CMockString_vkWriteAccelerationStructuresPropertiesKHR = "vkWriteAccelerationStructuresPropertiesKHR"; +static const char* CMockString_vkWriteMicromapsPropertiesEXT = "vkWriteMicromapsPropertiesEXT"; +static const char* CMockString_waitAll = "waitAll"; +static const char* CMockString_width = "width"; +static const char* CMockString_writeMask = "writeMask"; +static const char* CMockString_ycbcrConversion = "ycbcrConversion"; + +typedef struct _CMOCK_vkCreateInstance_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + const VkInstanceCreateInfo* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkInstance* Expected_pInstance; + char ReturnThruPtr_pInstance_Used; + VkInstance const* ReturnThruPtr_pInstance_Val; + size_t ReturnThruPtr_pInstance_Size; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pInstance; + +} CMOCK_vkCreateInstance_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyInstance_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkInstance Expected_instance; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_instance; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyInstance_CALL_INSTANCE; + +typedef struct _CMOCK_vkEnumeratePhysicalDevices_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkInstance Expected_instance; + uint32_t* Expected_pPhysicalDeviceCount; + VkPhysicalDevice* Expected_pPhysicalDevices; + char ReturnThruPtr_pPhysicalDeviceCount_Used; + uint32_t const* ReturnThruPtr_pPhysicalDeviceCount_Val; + size_t ReturnThruPtr_pPhysicalDeviceCount_Size; + char ReturnThruPtr_pPhysicalDevices_Used; + VkPhysicalDevice const* ReturnThruPtr_pPhysicalDevices_Val; + size_t ReturnThruPtr_pPhysicalDevices_Size; + char IgnoreArg_instance; + char IgnoreArg_pPhysicalDeviceCount; + char IgnoreArg_pPhysicalDevices; + +} CMOCK_vkEnumeratePhysicalDevices_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceFeatures_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkPhysicalDevice Expected_physicalDevice; + VkPhysicalDeviceFeatures* Expected_pFeatures; + char ReturnThruPtr_pFeatures_Used; + VkPhysicalDeviceFeatures const* ReturnThruPtr_pFeatures_Val; + size_t ReturnThruPtr_pFeatures_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pFeatures; + +} CMOCK_vkGetPhysicalDeviceFeatures_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceFormatProperties_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkPhysicalDevice Expected_physicalDevice; + VkFormat Expected_format; + VkFormatProperties* Expected_pFormatProperties; + char ReturnThruPtr_pFormatProperties_Used; + VkFormatProperties const* ReturnThruPtr_pFormatProperties_Val; + size_t ReturnThruPtr_pFormatProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_format; + char IgnoreArg_pFormatProperties; + +} CMOCK_vkGetPhysicalDeviceFormatProperties_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + VkFormat Expected_format; + VkImageType Expected_type; + VkImageTiling Expected_tiling; + VkImageUsageFlags Expected_usage; + VkImageCreateFlags Expected_flags; + VkImageFormatProperties* Expected_pImageFormatProperties; + char ReturnThruPtr_pImageFormatProperties_Used; + VkImageFormatProperties const* ReturnThruPtr_pImageFormatProperties_Val; + size_t ReturnThruPtr_pImageFormatProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_format; + char IgnoreArg_type; + char IgnoreArg_tiling; + char IgnoreArg_usage; + char IgnoreArg_flags; + char IgnoreArg_pImageFormatProperties; + +} CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceProperties_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkPhysicalDevice Expected_physicalDevice; + VkPhysicalDeviceProperties* Expected_pProperties; + char ReturnThruPtr_pProperties_Used; + VkPhysicalDeviceProperties const* ReturnThruPtr_pProperties_Val; + size_t ReturnThruPtr_pProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pProperties; + +} CMOCK_vkGetPhysicalDeviceProperties_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceQueueFamilyProperties_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkPhysicalDevice Expected_physicalDevice; + uint32_t* Expected_pQueueFamilyPropertyCount; + VkQueueFamilyProperties* Expected_pQueueFamilyProperties; + char ReturnThruPtr_pQueueFamilyPropertyCount_Used; + uint32_t const* ReturnThruPtr_pQueueFamilyPropertyCount_Val; + size_t ReturnThruPtr_pQueueFamilyPropertyCount_Size; + char ReturnThruPtr_pQueueFamilyProperties_Used; + VkQueueFamilyProperties const* ReturnThruPtr_pQueueFamilyProperties_Val; + size_t ReturnThruPtr_pQueueFamilyProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pQueueFamilyPropertyCount; + char IgnoreArg_pQueueFamilyProperties; + +} CMOCK_vkGetPhysicalDeviceQueueFamilyProperties_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceMemoryProperties_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkPhysicalDevice Expected_physicalDevice; + VkPhysicalDeviceMemoryProperties* Expected_pMemoryProperties; + char ReturnThruPtr_pMemoryProperties_Used; + VkPhysicalDeviceMemoryProperties const* ReturnThruPtr_pMemoryProperties_Val; + size_t ReturnThruPtr_pMemoryProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pMemoryProperties; + +} CMOCK_vkGetPhysicalDeviceMemoryProperties_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetInstanceProcAddr_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + PFN_vkVoidFunction ReturnVal; + VkInstance Expected_instance; + const char* Expected_pName; + char IgnoreArg_instance; + char IgnoreArg_pName; + +} CMOCK_vkGetInstanceProcAddr_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDeviceProcAddr_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + PFN_vkVoidFunction ReturnVal; + VkDevice Expected_device; + const char* Expected_pName; + char IgnoreArg_device; + char IgnoreArg_pName; + +} CMOCK_vkGetDeviceProcAddr_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateDevice_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + const VkDeviceCreateInfo* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkDevice* Expected_pDevice; + char ReturnThruPtr_pDevice_Used; + VkDevice const* ReturnThruPtr_pDevice_Val; + size_t ReturnThruPtr_pDevice_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pDevice; + +} CMOCK_vkCreateDevice_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyDevice_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyDevice_CALL_INSTANCE; + +typedef struct _CMOCK_vkEnumerateInstanceExtensionProperties_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + const char* Expected_pLayerName; + uint32_t* Expected_pPropertyCount; + VkExtensionProperties* Expected_pProperties; + char ReturnThruPtr_pPropertyCount_Used; + uint32_t const* ReturnThruPtr_pPropertyCount_Val; + size_t ReturnThruPtr_pPropertyCount_Size; + char ReturnThruPtr_pProperties_Used; + VkExtensionProperties const* ReturnThruPtr_pProperties_Val; + size_t ReturnThruPtr_pProperties_Size; + char IgnoreArg_pLayerName; + char IgnoreArg_pPropertyCount; + char IgnoreArg_pProperties; + +} CMOCK_vkEnumerateInstanceExtensionProperties_CALL_INSTANCE; + +typedef struct _CMOCK_vkEnumerateDeviceExtensionProperties_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + const char* Expected_pLayerName; + uint32_t* Expected_pPropertyCount; + VkExtensionProperties* Expected_pProperties; + char ReturnThruPtr_pPropertyCount_Used; + uint32_t const* ReturnThruPtr_pPropertyCount_Val; + size_t ReturnThruPtr_pPropertyCount_Size; + char ReturnThruPtr_pProperties_Used; + VkExtensionProperties const* ReturnThruPtr_pProperties_Val; + size_t ReturnThruPtr_pProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pLayerName; + char IgnoreArg_pPropertyCount; + char IgnoreArg_pProperties; + +} CMOCK_vkEnumerateDeviceExtensionProperties_CALL_INSTANCE; + +typedef struct _CMOCK_vkEnumerateInstanceLayerProperties_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + uint32_t* Expected_pPropertyCount; + VkLayerProperties* Expected_pProperties; + char ReturnThruPtr_pPropertyCount_Used; + uint32_t const* ReturnThruPtr_pPropertyCount_Val; + size_t ReturnThruPtr_pPropertyCount_Size; + char ReturnThruPtr_pProperties_Used; + VkLayerProperties const* ReturnThruPtr_pProperties_Val; + size_t ReturnThruPtr_pProperties_Size; + char IgnoreArg_pPropertyCount; + char IgnoreArg_pProperties; + +} CMOCK_vkEnumerateInstanceLayerProperties_CALL_INSTANCE; + +typedef struct _CMOCK_vkEnumerateDeviceLayerProperties_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + uint32_t* Expected_pPropertyCount; + VkLayerProperties* Expected_pProperties; + char ReturnThruPtr_pPropertyCount_Used; + uint32_t const* ReturnThruPtr_pPropertyCount_Val; + size_t ReturnThruPtr_pPropertyCount_Size; + char ReturnThruPtr_pProperties_Used; + VkLayerProperties const* ReturnThruPtr_pProperties_Val; + size_t ReturnThruPtr_pProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pPropertyCount; + char IgnoreArg_pProperties; + +} CMOCK_vkEnumerateDeviceLayerProperties_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDeviceQueue_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + uint32_t Expected_queueFamilyIndex; + uint32_t Expected_queueIndex; + VkQueue* Expected_pQueue; + char ReturnThruPtr_pQueue_Used; + VkQueue const* ReturnThruPtr_pQueue_Val; + size_t ReturnThruPtr_pQueue_Size; + char IgnoreArg_device; + char IgnoreArg_queueFamilyIndex; + char IgnoreArg_queueIndex; + char IgnoreArg_pQueue; + +} CMOCK_vkGetDeviceQueue_CALL_INSTANCE; + +typedef struct _CMOCK_vkQueueSubmit_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkQueue Expected_queue; + uint32_t Expected_submitCount; + const VkSubmitInfo* Expected_pSubmits; + VkFence Expected_fence; + char IgnoreArg_queue; + char IgnoreArg_submitCount; + char IgnoreArg_pSubmits; + char IgnoreArg_fence; + +} CMOCK_vkQueueSubmit_CALL_INSTANCE; + +typedef struct _CMOCK_vkQueueWaitIdle_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkQueue Expected_queue; + char IgnoreArg_queue; + +} CMOCK_vkQueueWaitIdle_CALL_INSTANCE; + +typedef struct _CMOCK_vkDeviceWaitIdle_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + char IgnoreArg_device; + +} CMOCK_vkDeviceWaitIdle_CALL_INSTANCE; + +typedef struct _CMOCK_vkAllocateMemory_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkMemoryAllocateInfo* Expected_pAllocateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkDeviceMemory* Expected_pMemory; + char ReturnThruPtr_pMemory_Used; + VkDeviceMemory const* ReturnThruPtr_pMemory_Val; + size_t ReturnThruPtr_pMemory_Size; + char IgnoreArg_device; + char IgnoreArg_pAllocateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pMemory; + +} CMOCK_vkAllocateMemory_CALL_INSTANCE; + +typedef struct _CMOCK_vkFreeMemory_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkDeviceMemory Expected_memory; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_memory; + char IgnoreArg_pAllocator; + +} CMOCK_vkFreeMemory_CALL_INSTANCE; + +typedef struct _CMOCK_vkMapMemory_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkDeviceMemory Expected_memory; + VkDeviceSize Expected_offset; + VkDeviceSize Expected_size; + VkMemoryMapFlags Expected_flags; + void** Expected_ppData; + char ReturnThruPtr_ppData_Used; + void* const* ReturnThruPtr_ppData_Val; + size_t ReturnThruPtr_ppData_Size; + char IgnoreArg_device; + char IgnoreArg_memory; + char IgnoreArg_offset; + char IgnoreArg_size; + char IgnoreArg_flags; + char IgnoreArg_ppData; + +} CMOCK_vkMapMemory_CALL_INSTANCE; + +typedef struct _CMOCK_vkUnmapMemory_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkDeviceMemory Expected_memory; + char IgnoreArg_device; + char IgnoreArg_memory; + +} CMOCK_vkUnmapMemory_CALL_INSTANCE; + +typedef struct _CMOCK_vkFlushMappedMemoryRanges_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + uint32_t Expected_memoryRangeCount; + const VkMappedMemoryRange* Expected_pMemoryRanges; + char IgnoreArg_device; + char IgnoreArg_memoryRangeCount; + char IgnoreArg_pMemoryRanges; + +} CMOCK_vkFlushMappedMemoryRanges_CALL_INSTANCE; + +typedef struct _CMOCK_vkInvalidateMappedMemoryRanges_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + uint32_t Expected_memoryRangeCount; + const VkMappedMemoryRange* Expected_pMemoryRanges; + char IgnoreArg_device; + char IgnoreArg_memoryRangeCount; + char IgnoreArg_pMemoryRanges; + +} CMOCK_vkInvalidateMappedMemoryRanges_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDeviceMemoryCommitment_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkDeviceMemory Expected_memory; + VkDeviceSize* Expected_pCommittedMemoryInBytes; + char ReturnThruPtr_pCommittedMemoryInBytes_Used; + VkDeviceSize const* ReturnThruPtr_pCommittedMemoryInBytes_Val; + size_t ReturnThruPtr_pCommittedMemoryInBytes_Size; + char IgnoreArg_device; + char IgnoreArg_memory; + char IgnoreArg_pCommittedMemoryInBytes; + +} CMOCK_vkGetDeviceMemoryCommitment_CALL_INSTANCE; + +typedef struct _CMOCK_vkBindBufferMemory_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkBuffer Expected_buffer; + VkDeviceMemory Expected_memory; + VkDeviceSize Expected_memoryOffset; + char IgnoreArg_device; + char IgnoreArg_buffer; + char IgnoreArg_memory; + char IgnoreArg_memoryOffset; + +} CMOCK_vkBindBufferMemory_CALL_INSTANCE; + +typedef struct _CMOCK_vkBindImageMemory_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkImage Expected_image; + VkDeviceMemory Expected_memory; + VkDeviceSize Expected_memoryOffset; + char IgnoreArg_device; + char IgnoreArg_image; + char IgnoreArg_memory; + char IgnoreArg_memoryOffset; + +} CMOCK_vkBindImageMemory_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetBufferMemoryRequirements_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkBuffer Expected_buffer; + VkMemoryRequirements* Expected_pMemoryRequirements; + char ReturnThruPtr_pMemoryRequirements_Used; + VkMemoryRequirements const* ReturnThruPtr_pMemoryRequirements_Val; + size_t ReturnThruPtr_pMemoryRequirements_Size; + char IgnoreArg_device; + char IgnoreArg_buffer; + char IgnoreArg_pMemoryRequirements; + +} CMOCK_vkGetBufferMemoryRequirements_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetImageMemoryRequirements_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkImage Expected_image; + VkMemoryRequirements* Expected_pMemoryRequirements; + char ReturnThruPtr_pMemoryRequirements_Used; + VkMemoryRequirements const* ReturnThruPtr_pMemoryRequirements_Val; + size_t ReturnThruPtr_pMemoryRequirements_Size; + char IgnoreArg_device; + char IgnoreArg_image; + char IgnoreArg_pMemoryRequirements; + +} CMOCK_vkGetImageMemoryRequirements_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetImageSparseMemoryRequirements_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkImage Expected_image; + uint32_t* Expected_pSparseMemoryRequirementCount; + VkSparseImageMemoryRequirements* Expected_pSparseMemoryRequirements; + char ReturnThruPtr_pSparseMemoryRequirementCount_Used; + uint32_t const* ReturnThruPtr_pSparseMemoryRequirementCount_Val; + size_t ReturnThruPtr_pSparseMemoryRequirementCount_Size; + char ReturnThruPtr_pSparseMemoryRequirements_Used; + VkSparseImageMemoryRequirements const* ReturnThruPtr_pSparseMemoryRequirements_Val; + size_t ReturnThruPtr_pSparseMemoryRequirements_Size; + char IgnoreArg_device; + char IgnoreArg_image; + char IgnoreArg_pSparseMemoryRequirementCount; + char IgnoreArg_pSparseMemoryRequirements; + +} CMOCK_vkGetImageSparseMemoryRequirements_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkPhysicalDevice Expected_physicalDevice; + VkFormat Expected_format; + VkImageType Expected_type; + VkSampleCountFlagBits Expected_samples; + VkImageUsageFlags Expected_usage; + VkImageTiling Expected_tiling; + uint32_t* Expected_pPropertyCount; + VkSparseImageFormatProperties* Expected_pProperties; + char ReturnThruPtr_pPropertyCount_Used; + uint32_t const* ReturnThruPtr_pPropertyCount_Val; + size_t ReturnThruPtr_pPropertyCount_Size; + char ReturnThruPtr_pProperties_Used; + VkSparseImageFormatProperties const* ReturnThruPtr_pProperties_Val; + size_t ReturnThruPtr_pProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_format; + char IgnoreArg_type; + char IgnoreArg_samples; + char IgnoreArg_usage; + char IgnoreArg_tiling; + char IgnoreArg_pPropertyCount; + char IgnoreArg_pProperties; + +} CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE; + +typedef struct _CMOCK_vkQueueBindSparse_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkQueue Expected_queue; + uint32_t Expected_bindInfoCount; + const VkBindSparseInfo* Expected_pBindInfo; + VkFence Expected_fence; + char IgnoreArg_queue; + char IgnoreArg_bindInfoCount; + char IgnoreArg_pBindInfo; + char IgnoreArg_fence; + +} CMOCK_vkQueueBindSparse_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateFence_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkFenceCreateInfo* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkFence* Expected_pFence; + char ReturnThruPtr_pFence_Used; + VkFence const* ReturnThruPtr_pFence_Val; + size_t ReturnThruPtr_pFence_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pFence; + +} CMOCK_vkCreateFence_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyFence_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkFence Expected_fence; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_fence; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyFence_CALL_INSTANCE; + +typedef struct _CMOCK_vkResetFences_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + uint32_t Expected_fenceCount; + const VkFence* Expected_pFences; + char IgnoreArg_device; + char IgnoreArg_fenceCount; + char IgnoreArg_pFences; + +} CMOCK_vkResetFences_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetFenceStatus_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkFence Expected_fence; + char IgnoreArg_device; + char IgnoreArg_fence; + +} CMOCK_vkGetFenceStatus_CALL_INSTANCE; + +typedef struct _CMOCK_vkWaitForFences_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + uint32_t Expected_fenceCount; + const VkFence* Expected_pFences; + VkBool32 Expected_waitAll; + uint64_t Expected_timeout; + char IgnoreArg_device; + char IgnoreArg_fenceCount; + char IgnoreArg_pFences; + char IgnoreArg_waitAll; + char IgnoreArg_timeout; + +} CMOCK_vkWaitForFences_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateSemaphore_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkSemaphoreCreateInfo* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkSemaphore* Expected_pSemaphore; + char ReturnThruPtr_pSemaphore_Used; + VkSemaphore const* ReturnThruPtr_pSemaphore_Val; + size_t ReturnThruPtr_pSemaphore_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pSemaphore; + +} CMOCK_vkCreateSemaphore_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroySemaphore_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkSemaphore Expected_semaphore; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_semaphore; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroySemaphore_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateEvent_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkEventCreateInfo* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkEvent* Expected_pEvent; + char ReturnThruPtr_pEvent_Used; + VkEvent const* ReturnThruPtr_pEvent_Val; + size_t ReturnThruPtr_pEvent_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pEvent; + +} CMOCK_vkCreateEvent_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyEvent_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkEvent Expected_event; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_event; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyEvent_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetEventStatus_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkEvent Expected_event; + char IgnoreArg_device; + char IgnoreArg_event; + +} CMOCK_vkGetEventStatus_CALL_INSTANCE; + +typedef struct _CMOCK_vkSetEvent_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkEvent Expected_event; + char IgnoreArg_device; + char IgnoreArg_event; + +} CMOCK_vkSetEvent_CALL_INSTANCE; + +typedef struct _CMOCK_vkResetEvent_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkEvent Expected_event; + char IgnoreArg_device; + char IgnoreArg_event; + +} CMOCK_vkResetEvent_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateQueryPool_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkQueryPoolCreateInfo* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkQueryPool* Expected_pQueryPool; + char ReturnThruPtr_pQueryPool_Used; + VkQueryPool const* ReturnThruPtr_pQueryPool_Val; + size_t ReturnThruPtr_pQueryPool_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pQueryPool; + +} CMOCK_vkCreateQueryPool_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyQueryPool_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkQueryPool Expected_queryPool; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_queryPool; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyQueryPool_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetQueryPoolResults_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkQueryPool Expected_queryPool; + uint32_t Expected_firstQuery; + uint32_t Expected_queryCount; + size_t Expected_dataSize; + void* Expected_pData; + VkDeviceSize Expected_stride; + VkQueryResultFlags Expected_flags; + char ReturnThruPtr_pData_Used; + void const* ReturnThruPtr_pData_Val; + size_t ReturnThruPtr_pData_Size; + char IgnoreArg_device; + char IgnoreArg_queryPool; + char IgnoreArg_firstQuery; + char IgnoreArg_queryCount; + char IgnoreArg_dataSize; + char IgnoreArg_pData; + char IgnoreArg_stride; + char IgnoreArg_flags; + +} CMOCK_vkGetQueryPoolResults_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateBuffer_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkBufferCreateInfo* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkBuffer* Expected_pBuffer; + char ReturnThruPtr_pBuffer_Used; + VkBuffer const* ReturnThruPtr_pBuffer_Val; + size_t ReturnThruPtr_pBuffer_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pBuffer; + +} CMOCK_vkCreateBuffer_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyBuffer_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkBuffer Expected_buffer; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_buffer; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyBuffer_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateBufferView_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkBufferViewCreateInfo* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkBufferView* Expected_pView; + char ReturnThruPtr_pView_Used; + VkBufferView const* ReturnThruPtr_pView_Val; + size_t ReturnThruPtr_pView_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pView; + +} CMOCK_vkCreateBufferView_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyBufferView_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkBufferView Expected_bufferView; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_bufferView; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyBufferView_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateImage_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkImageCreateInfo* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkImage* Expected_pImage; + char ReturnThruPtr_pImage_Used; + VkImage const* ReturnThruPtr_pImage_Val; + size_t ReturnThruPtr_pImage_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pImage; + +} CMOCK_vkCreateImage_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyImage_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkImage Expected_image; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_image; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyImage_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetImageSubresourceLayout_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkImage Expected_image; + const VkImageSubresource* Expected_pSubresource; + VkSubresourceLayout* Expected_pLayout; + char ReturnThruPtr_pLayout_Used; + VkSubresourceLayout const* ReturnThruPtr_pLayout_Val; + size_t ReturnThruPtr_pLayout_Size; + char IgnoreArg_device; + char IgnoreArg_image; + char IgnoreArg_pSubresource; + char IgnoreArg_pLayout; + +} CMOCK_vkGetImageSubresourceLayout_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateImageView_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkImageViewCreateInfo* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkImageView* Expected_pView; + char ReturnThruPtr_pView_Used; + VkImageView const* ReturnThruPtr_pView_Val; + size_t ReturnThruPtr_pView_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pView; + +} CMOCK_vkCreateImageView_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyImageView_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkImageView Expected_imageView; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_imageView; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyImageView_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateShaderModule_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkShaderModuleCreateInfo* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkShaderModule* Expected_pShaderModule; + char ReturnThruPtr_pShaderModule_Used; + VkShaderModule const* ReturnThruPtr_pShaderModule_Val; + size_t ReturnThruPtr_pShaderModule_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pShaderModule; + +} CMOCK_vkCreateShaderModule_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyShaderModule_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkShaderModule Expected_shaderModule; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_shaderModule; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyShaderModule_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreatePipelineCache_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkPipelineCacheCreateInfo* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkPipelineCache* Expected_pPipelineCache; + char ReturnThruPtr_pPipelineCache_Used; + VkPipelineCache const* ReturnThruPtr_pPipelineCache_Val; + size_t ReturnThruPtr_pPipelineCache_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pPipelineCache; + +} CMOCK_vkCreatePipelineCache_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyPipelineCache_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkPipelineCache Expected_pipelineCache; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_pipelineCache; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyPipelineCache_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPipelineCacheData_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkPipelineCache Expected_pipelineCache; + size_t* Expected_pDataSize; + void* Expected_pData; + char ReturnThruPtr_pDataSize_Used; + size_t const* ReturnThruPtr_pDataSize_Val; + size_t ReturnThruPtr_pDataSize_Size; + char ReturnThruPtr_pData_Used; + void const* ReturnThruPtr_pData_Val; + size_t ReturnThruPtr_pData_Size; + char IgnoreArg_device; + char IgnoreArg_pipelineCache; + char IgnoreArg_pDataSize; + char IgnoreArg_pData; + +} CMOCK_vkGetPipelineCacheData_CALL_INSTANCE; + +typedef struct _CMOCK_vkMergePipelineCaches_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkPipelineCache Expected_dstCache; + uint32_t Expected_srcCacheCount; + const VkPipelineCache* Expected_pSrcCaches; + char IgnoreArg_device; + char IgnoreArg_dstCache; + char IgnoreArg_srcCacheCount; + char IgnoreArg_pSrcCaches; + +} CMOCK_vkMergePipelineCaches_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateGraphicsPipelines_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkPipelineCache Expected_pipelineCache; + uint32_t Expected_createInfoCount; + const VkGraphicsPipelineCreateInfo* Expected_pCreateInfos; + const VkAllocationCallbacks* Expected_pAllocator; + VkPipeline* Expected_pPipelines; + char ReturnThruPtr_pPipelines_Used; + VkPipeline const* ReturnThruPtr_pPipelines_Val; + size_t ReturnThruPtr_pPipelines_Size; + char IgnoreArg_device; + char IgnoreArg_pipelineCache; + char IgnoreArg_createInfoCount; + char IgnoreArg_pCreateInfos; + char IgnoreArg_pAllocator; + char IgnoreArg_pPipelines; + +} CMOCK_vkCreateGraphicsPipelines_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateComputePipelines_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkPipelineCache Expected_pipelineCache; + uint32_t Expected_createInfoCount; + const VkComputePipelineCreateInfo* Expected_pCreateInfos; + const VkAllocationCallbacks* Expected_pAllocator; + VkPipeline* Expected_pPipelines; + char ReturnThruPtr_pPipelines_Used; + VkPipeline const* ReturnThruPtr_pPipelines_Val; + size_t ReturnThruPtr_pPipelines_Size; + char IgnoreArg_device; + char IgnoreArg_pipelineCache; + char IgnoreArg_createInfoCount; + char IgnoreArg_pCreateInfos; + char IgnoreArg_pAllocator; + char IgnoreArg_pPipelines; + +} CMOCK_vkCreateComputePipelines_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyPipeline_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkPipeline Expected_pipeline; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_pipeline; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyPipeline_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreatePipelineLayout_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkPipelineLayoutCreateInfo* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkPipelineLayout* Expected_pPipelineLayout; + char ReturnThruPtr_pPipelineLayout_Used; + VkPipelineLayout const* ReturnThruPtr_pPipelineLayout_Val; + size_t ReturnThruPtr_pPipelineLayout_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pPipelineLayout; + +} CMOCK_vkCreatePipelineLayout_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyPipelineLayout_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkPipelineLayout Expected_pipelineLayout; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_pipelineLayout; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyPipelineLayout_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateSampler_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkSamplerCreateInfo* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkSampler* Expected_pSampler; + char ReturnThruPtr_pSampler_Used; + VkSampler const* ReturnThruPtr_pSampler_Val; + size_t ReturnThruPtr_pSampler_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pSampler; + +} CMOCK_vkCreateSampler_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroySampler_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkSampler Expected_sampler; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_sampler; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroySampler_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateDescriptorSetLayout_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkDescriptorSetLayoutCreateInfo* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkDescriptorSetLayout* Expected_pSetLayout; + char ReturnThruPtr_pSetLayout_Used; + VkDescriptorSetLayout const* ReturnThruPtr_pSetLayout_Val; + size_t ReturnThruPtr_pSetLayout_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pSetLayout; + +} CMOCK_vkCreateDescriptorSetLayout_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyDescriptorSetLayout_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkDescriptorSetLayout Expected_descriptorSetLayout; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_descriptorSetLayout; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyDescriptorSetLayout_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateDescriptorPool_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkDescriptorPoolCreateInfo* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkDescriptorPool* Expected_pDescriptorPool; + char ReturnThruPtr_pDescriptorPool_Used; + VkDescriptorPool const* ReturnThruPtr_pDescriptorPool_Val; + size_t ReturnThruPtr_pDescriptorPool_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pDescriptorPool; + +} CMOCK_vkCreateDescriptorPool_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyDescriptorPool_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkDescriptorPool Expected_descriptorPool; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_descriptorPool; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyDescriptorPool_CALL_INSTANCE; + +typedef struct _CMOCK_vkResetDescriptorPool_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkDescriptorPool Expected_descriptorPool; + VkDescriptorPoolResetFlags Expected_flags; + char IgnoreArg_device; + char IgnoreArg_descriptorPool; + char IgnoreArg_flags; + +} CMOCK_vkResetDescriptorPool_CALL_INSTANCE; + +typedef struct _CMOCK_vkAllocateDescriptorSets_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkDescriptorSetAllocateInfo* Expected_pAllocateInfo; + VkDescriptorSet* Expected_pDescriptorSets; + char ReturnThruPtr_pDescriptorSets_Used; + VkDescriptorSet const* ReturnThruPtr_pDescriptorSets_Val; + size_t ReturnThruPtr_pDescriptorSets_Size; + char IgnoreArg_device; + char IgnoreArg_pAllocateInfo; + char IgnoreArg_pDescriptorSets; + +} CMOCK_vkAllocateDescriptorSets_CALL_INSTANCE; + +typedef struct _CMOCK_vkFreeDescriptorSets_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkDescriptorPool Expected_descriptorPool; + uint32_t Expected_descriptorSetCount; + const VkDescriptorSet* Expected_pDescriptorSets; + char IgnoreArg_device; + char IgnoreArg_descriptorPool; + char IgnoreArg_descriptorSetCount; + char IgnoreArg_pDescriptorSets; + +} CMOCK_vkFreeDescriptorSets_CALL_INSTANCE; + +typedef struct _CMOCK_vkUpdateDescriptorSets_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + uint32_t Expected_descriptorWriteCount; + const VkWriteDescriptorSet* Expected_pDescriptorWrites; + uint32_t Expected_descriptorCopyCount; + const VkCopyDescriptorSet* Expected_pDescriptorCopies; + char IgnoreArg_device; + char IgnoreArg_descriptorWriteCount; + char IgnoreArg_pDescriptorWrites; + char IgnoreArg_descriptorCopyCount; + char IgnoreArg_pDescriptorCopies; + +} CMOCK_vkUpdateDescriptorSets_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateFramebuffer_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkFramebufferCreateInfo* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkFramebuffer* Expected_pFramebuffer; + char ReturnThruPtr_pFramebuffer_Used; + VkFramebuffer const* ReturnThruPtr_pFramebuffer_Val; + size_t ReturnThruPtr_pFramebuffer_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pFramebuffer; + +} CMOCK_vkCreateFramebuffer_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyFramebuffer_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkFramebuffer Expected_framebuffer; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_framebuffer; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyFramebuffer_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateRenderPass_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkRenderPassCreateInfo* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkRenderPass* Expected_pRenderPass; + char ReturnThruPtr_pRenderPass_Used; + VkRenderPass const* ReturnThruPtr_pRenderPass_Val; + size_t ReturnThruPtr_pRenderPass_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pRenderPass; + +} CMOCK_vkCreateRenderPass_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyRenderPass_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkRenderPass Expected_renderPass; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_renderPass; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyRenderPass_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetRenderAreaGranularity_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkRenderPass Expected_renderPass; + VkExtent2D* Expected_pGranularity; + char ReturnThruPtr_pGranularity_Used; + VkExtent2D const* ReturnThruPtr_pGranularity_Val; + size_t ReturnThruPtr_pGranularity_Size; + char IgnoreArg_device; + char IgnoreArg_renderPass; + char IgnoreArg_pGranularity; + +} CMOCK_vkGetRenderAreaGranularity_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateCommandPool_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkCommandPoolCreateInfo* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkCommandPool* Expected_pCommandPool; + char ReturnThruPtr_pCommandPool_Used; + VkCommandPool const* ReturnThruPtr_pCommandPool_Val; + size_t ReturnThruPtr_pCommandPool_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pCommandPool; + +} CMOCK_vkCreateCommandPool_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyCommandPool_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkCommandPool Expected_commandPool; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_commandPool; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyCommandPool_CALL_INSTANCE; + +typedef struct _CMOCK_vkResetCommandPool_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkCommandPool Expected_commandPool; + VkCommandPoolResetFlags Expected_flags; + char IgnoreArg_device; + char IgnoreArg_commandPool; + char IgnoreArg_flags; + +} CMOCK_vkResetCommandPool_CALL_INSTANCE; + +typedef struct _CMOCK_vkAllocateCommandBuffers_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkCommandBufferAllocateInfo* Expected_pAllocateInfo; + VkCommandBuffer* Expected_pCommandBuffers; + char ReturnThruPtr_pCommandBuffers_Used; + VkCommandBuffer const* ReturnThruPtr_pCommandBuffers_Val; + size_t ReturnThruPtr_pCommandBuffers_Size; + char IgnoreArg_device; + char IgnoreArg_pAllocateInfo; + char IgnoreArg_pCommandBuffers; + +} CMOCK_vkAllocateCommandBuffers_CALL_INSTANCE; + +typedef struct _CMOCK_vkFreeCommandBuffers_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkCommandPool Expected_commandPool; + uint32_t Expected_commandBufferCount; + const VkCommandBuffer* Expected_pCommandBuffers; + char IgnoreArg_device; + char IgnoreArg_commandPool; + char IgnoreArg_commandBufferCount; + char IgnoreArg_pCommandBuffers; + +} CMOCK_vkFreeCommandBuffers_CALL_INSTANCE; + +typedef struct _CMOCK_vkBeginCommandBuffer_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkCommandBuffer Expected_commandBuffer; + const VkCommandBufferBeginInfo* Expected_pBeginInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pBeginInfo; + +} CMOCK_vkBeginCommandBuffer_CALL_INSTANCE; + +typedef struct _CMOCK_vkEndCommandBuffer_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkCommandBuffer Expected_commandBuffer; + char IgnoreArg_commandBuffer; + +} CMOCK_vkEndCommandBuffer_CALL_INSTANCE; + +typedef struct _CMOCK_vkResetCommandBuffer_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkCommandBuffer Expected_commandBuffer; + VkCommandBufferResetFlags Expected_flags; + char IgnoreArg_commandBuffer; + char IgnoreArg_flags; + +} CMOCK_vkResetCommandBuffer_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBindPipeline_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkPipelineBindPoint Expected_pipelineBindPoint; + VkPipeline Expected_pipeline; + char IgnoreArg_commandBuffer; + char IgnoreArg_pipelineBindPoint; + char IgnoreArg_pipeline; + +} CMOCK_vkCmdBindPipeline_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetViewport_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_firstViewport; + uint32_t Expected_viewportCount; + const VkViewport* Expected_pViewports; + char IgnoreArg_commandBuffer; + char IgnoreArg_firstViewport; + char IgnoreArg_viewportCount; + char IgnoreArg_pViewports; + +} CMOCK_vkCmdSetViewport_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetScissor_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_firstScissor; + uint32_t Expected_scissorCount; + const VkRect2D* Expected_pScissors; + char IgnoreArg_commandBuffer; + char IgnoreArg_firstScissor; + char IgnoreArg_scissorCount; + char IgnoreArg_pScissors; + +} CMOCK_vkCmdSetScissor_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetLineWidth_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + float Expected_lineWidth; + char IgnoreArg_commandBuffer; + char IgnoreArg_lineWidth; + +} CMOCK_vkCmdSetLineWidth_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetDepthBias_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + float Expected_depthBiasConstantFactor; + float Expected_depthBiasClamp; + float Expected_depthBiasSlopeFactor; + char IgnoreArg_commandBuffer; + char IgnoreArg_depthBiasConstantFactor; + char IgnoreArg_depthBiasClamp; + char IgnoreArg_depthBiasSlopeFactor; + +} CMOCK_vkCmdSetDepthBias_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetBlendConstants_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const float* Expected_blendConstants; + char IgnoreArg_commandBuffer; + char IgnoreArg_blendConstants; + +} CMOCK_vkCmdSetBlendConstants_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetDepthBounds_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + float Expected_minDepthBounds; + float Expected_maxDepthBounds; + char IgnoreArg_commandBuffer; + char IgnoreArg_minDepthBounds; + char IgnoreArg_maxDepthBounds; + +} CMOCK_vkCmdSetDepthBounds_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetStencilCompareMask_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkStencilFaceFlags Expected_faceMask; + uint32_t Expected_compareMask; + char IgnoreArg_commandBuffer; + char IgnoreArg_faceMask; + char IgnoreArg_compareMask; + +} CMOCK_vkCmdSetStencilCompareMask_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetStencilWriteMask_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkStencilFaceFlags Expected_faceMask; + uint32_t Expected_writeMask; + char IgnoreArg_commandBuffer; + char IgnoreArg_faceMask; + char IgnoreArg_writeMask; + +} CMOCK_vkCmdSetStencilWriteMask_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetStencilReference_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkStencilFaceFlags Expected_faceMask; + uint32_t Expected_reference; + char IgnoreArg_commandBuffer; + char IgnoreArg_faceMask; + char IgnoreArg_reference; + +} CMOCK_vkCmdSetStencilReference_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBindDescriptorSets_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkPipelineBindPoint Expected_pipelineBindPoint; + VkPipelineLayout Expected_layout; + uint32_t Expected_firstSet; + uint32_t Expected_descriptorSetCount; + const VkDescriptorSet* Expected_pDescriptorSets; + uint32_t Expected_dynamicOffsetCount; + const uint32_t* Expected_pDynamicOffsets; + char IgnoreArg_commandBuffer; + char IgnoreArg_pipelineBindPoint; + char IgnoreArg_layout; + char IgnoreArg_firstSet; + char IgnoreArg_descriptorSetCount; + char IgnoreArg_pDescriptorSets; + char IgnoreArg_dynamicOffsetCount; + char IgnoreArg_pDynamicOffsets; + +} CMOCK_vkCmdBindDescriptorSets_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBindIndexBuffer_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBuffer Expected_buffer; + VkDeviceSize Expected_offset; + VkIndexType Expected_indexType; + char IgnoreArg_commandBuffer; + char IgnoreArg_buffer; + char IgnoreArg_offset; + char IgnoreArg_indexType; + +} CMOCK_vkCmdBindIndexBuffer_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBindVertexBuffers_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_firstBinding; + uint32_t Expected_bindingCount; + const VkBuffer* Expected_pBuffers; + const VkDeviceSize* Expected_pOffsets; + char IgnoreArg_commandBuffer; + char IgnoreArg_firstBinding; + char IgnoreArg_bindingCount; + char IgnoreArg_pBuffers; + char IgnoreArg_pOffsets; + +} CMOCK_vkCmdBindVertexBuffers_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDraw_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_vertexCount; + uint32_t Expected_instanceCount; + uint32_t Expected_firstVertex; + uint32_t Expected_firstInstance; + char IgnoreArg_commandBuffer; + char IgnoreArg_vertexCount; + char IgnoreArg_instanceCount; + char IgnoreArg_firstVertex; + char IgnoreArg_firstInstance; + +} CMOCK_vkCmdDraw_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDrawIndexed_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_indexCount; + uint32_t Expected_instanceCount; + uint32_t Expected_firstIndex; + int32_t Expected_vertexOffset; + uint32_t Expected_firstInstance; + char IgnoreArg_commandBuffer; + char IgnoreArg_indexCount; + char IgnoreArg_instanceCount; + char IgnoreArg_firstIndex; + char IgnoreArg_vertexOffset; + char IgnoreArg_firstInstance; + +} CMOCK_vkCmdDrawIndexed_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDrawIndirect_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBuffer Expected_buffer; + VkDeviceSize Expected_offset; + uint32_t Expected_drawCount; + uint32_t Expected_stride; + char IgnoreArg_commandBuffer; + char IgnoreArg_buffer; + char IgnoreArg_offset; + char IgnoreArg_drawCount; + char IgnoreArg_stride; + +} CMOCK_vkCmdDrawIndirect_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDrawIndexedIndirect_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBuffer Expected_buffer; + VkDeviceSize Expected_offset; + uint32_t Expected_drawCount; + uint32_t Expected_stride; + char IgnoreArg_commandBuffer; + char IgnoreArg_buffer; + char IgnoreArg_offset; + char IgnoreArg_drawCount; + char IgnoreArg_stride; + +} CMOCK_vkCmdDrawIndexedIndirect_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDispatch_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_groupCountX; + uint32_t Expected_groupCountY; + uint32_t Expected_groupCountZ; + char IgnoreArg_commandBuffer; + char IgnoreArg_groupCountX; + char IgnoreArg_groupCountY; + char IgnoreArg_groupCountZ; + +} CMOCK_vkCmdDispatch_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDispatchIndirect_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBuffer Expected_buffer; + VkDeviceSize Expected_offset; + char IgnoreArg_commandBuffer; + char IgnoreArg_buffer; + char IgnoreArg_offset; + +} CMOCK_vkCmdDispatchIndirect_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdCopyBuffer_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBuffer Expected_srcBuffer; + VkBuffer Expected_dstBuffer; + uint32_t Expected_regionCount; + const VkBufferCopy* Expected_pRegions; + char IgnoreArg_commandBuffer; + char IgnoreArg_srcBuffer; + char IgnoreArg_dstBuffer; + char IgnoreArg_regionCount; + char IgnoreArg_pRegions; + +} CMOCK_vkCmdCopyBuffer_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdCopyImage_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkImage Expected_srcImage; + VkImageLayout Expected_srcImageLayout; + VkImage Expected_dstImage; + VkImageLayout Expected_dstImageLayout; + uint32_t Expected_regionCount; + const VkImageCopy* Expected_pRegions; + char IgnoreArg_commandBuffer; + char IgnoreArg_srcImage; + char IgnoreArg_srcImageLayout; + char IgnoreArg_dstImage; + char IgnoreArg_dstImageLayout; + char IgnoreArg_regionCount; + char IgnoreArg_pRegions; + +} CMOCK_vkCmdCopyImage_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBlitImage_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkImage Expected_srcImage; + VkImageLayout Expected_srcImageLayout; + VkImage Expected_dstImage; + VkImageLayout Expected_dstImageLayout; + uint32_t Expected_regionCount; + const VkImageBlit* Expected_pRegions; + VkFilter Expected_filter; + char IgnoreArg_commandBuffer; + char IgnoreArg_srcImage; + char IgnoreArg_srcImageLayout; + char IgnoreArg_dstImage; + char IgnoreArg_dstImageLayout; + char IgnoreArg_regionCount; + char IgnoreArg_pRegions; + char IgnoreArg_filter; + +} CMOCK_vkCmdBlitImage_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdCopyBufferToImage_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBuffer Expected_srcBuffer; + VkImage Expected_dstImage; + VkImageLayout Expected_dstImageLayout; + uint32_t Expected_regionCount; + const VkBufferImageCopy* Expected_pRegions; + char IgnoreArg_commandBuffer; + char IgnoreArg_srcBuffer; + char IgnoreArg_dstImage; + char IgnoreArg_dstImageLayout; + char IgnoreArg_regionCount; + char IgnoreArg_pRegions; + +} CMOCK_vkCmdCopyBufferToImage_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdCopyImageToBuffer_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkImage Expected_srcImage; + VkImageLayout Expected_srcImageLayout; + VkBuffer Expected_dstBuffer; + uint32_t Expected_regionCount; + const VkBufferImageCopy* Expected_pRegions; + char IgnoreArg_commandBuffer; + char IgnoreArg_srcImage; + char IgnoreArg_srcImageLayout; + char IgnoreArg_dstBuffer; + char IgnoreArg_regionCount; + char IgnoreArg_pRegions; + +} CMOCK_vkCmdCopyImageToBuffer_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdUpdateBuffer_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBuffer Expected_dstBuffer; + VkDeviceSize Expected_dstOffset; + VkDeviceSize Expected_dataSize; + const void* Expected_pData; + char IgnoreArg_commandBuffer; + char IgnoreArg_dstBuffer; + char IgnoreArg_dstOffset; + char IgnoreArg_dataSize; + char IgnoreArg_pData; + +} CMOCK_vkCmdUpdateBuffer_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdFillBuffer_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBuffer Expected_dstBuffer; + VkDeviceSize Expected_dstOffset; + VkDeviceSize Expected_size; + uint32_t Expected_data; + char IgnoreArg_commandBuffer; + char IgnoreArg_dstBuffer; + char IgnoreArg_dstOffset; + char IgnoreArg_size; + char IgnoreArg_data; + +} CMOCK_vkCmdFillBuffer_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdClearColorImage_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkImage Expected_image; + VkImageLayout Expected_imageLayout; + const VkClearColorValue* Expected_pColor; + uint32_t Expected_rangeCount; + const VkImageSubresourceRange* Expected_pRanges; + char IgnoreArg_commandBuffer; + char IgnoreArg_image; + char IgnoreArg_imageLayout; + char IgnoreArg_pColor; + char IgnoreArg_rangeCount; + char IgnoreArg_pRanges; + +} CMOCK_vkCmdClearColorImage_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdClearDepthStencilImage_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkImage Expected_image; + VkImageLayout Expected_imageLayout; + const VkClearDepthStencilValue* Expected_pDepthStencil; + uint32_t Expected_rangeCount; + const VkImageSubresourceRange* Expected_pRanges; + char IgnoreArg_commandBuffer; + char IgnoreArg_image; + char IgnoreArg_imageLayout; + char IgnoreArg_pDepthStencil; + char IgnoreArg_rangeCount; + char IgnoreArg_pRanges; + +} CMOCK_vkCmdClearDepthStencilImage_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdClearAttachments_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_attachmentCount; + const VkClearAttachment* Expected_pAttachments; + uint32_t Expected_rectCount; + const VkClearRect* Expected_pRects; + char IgnoreArg_commandBuffer; + char IgnoreArg_attachmentCount; + char IgnoreArg_pAttachments; + char IgnoreArg_rectCount; + char IgnoreArg_pRects; + +} CMOCK_vkCmdClearAttachments_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdResolveImage_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkImage Expected_srcImage; + VkImageLayout Expected_srcImageLayout; + VkImage Expected_dstImage; + VkImageLayout Expected_dstImageLayout; + uint32_t Expected_regionCount; + const VkImageResolve* Expected_pRegions; + char IgnoreArg_commandBuffer; + char IgnoreArg_srcImage; + char IgnoreArg_srcImageLayout; + char IgnoreArg_dstImage; + char IgnoreArg_dstImageLayout; + char IgnoreArg_regionCount; + char IgnoreArg_pRegions; + +} CMOCK_vkCmdResolveImage_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetEvent_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkEvent Expected_event; + VkPipelineStageFlags Expected_stageMask; + char IgnoreArg_commandBuffer; + char IgnoreArg_event; + char IgnoreArg_stageMask; + +} CMOCK_vkCmdSetEvent_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdResetEvent_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkEvent Expected_event; + VkPipelineStageFlags Expected_stageMask; + char IgnoreArg_commandBuffer; + char IgnoreArg_event; + char IgnoreArg_stageMask; + +} CMOCK_vkCmdResetEvent_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdWaitEvents_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_eventCount; + const VkEvent* Expected_pEvents; + VkPipelineStageFlags Expected_srcStageMask; + VkPipelineStageFlags Expected_dstStageMask; + uint32_t Expected_memoryBarrierCount; + const VkMemoryBarrier* Expected_pMemoryBarriers; + uint32_t Expected_bufferMemoryBarrierCount; + const VkBufferMemoryBarrier* Expected_pBufferMemoryBarriers; + uint32_t Expected_imageMemoryBarrierCount; + const VkImageMemoryBarrier* Expected_pImageMemoryBarriers; + char IgnoreArg_commandBuffer; + char IgnoreArg_eventCount; + char IgnoreArg_pEvents; + char IgnoreArg_srcStageMask; + char IgnoreArg_dstStageMask; + char IgnoreArg_memoryBarrierCount; + char IgnoreArg_pMemoryBarriers; + char IgnoreArg_bufferMemoryBarrierCount; + char IgnoreArg_pBufferMemoryBarriers; + char IgnoreArg_imageMemoryBarrierCount; + char IgnoreArg_pImageMemoryBarriers; + +} CMOCK_vkCmdWaitEvents_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkPipelineStageFlags Expected_srcStageMask; + VkPipelineStageFlags Expected_dstStageMask; + VkDependencyFlags Expected_dependencyFlags; + uint32_t Expected_memoryBarrierCount; + const VkMemoryBarrier* Expected_pMemoryBarriers; + uint32_t Expected_bufferMemoryBarrierCount; + const VkBufferMemoryBarrier* Expected_pBufferMemoryBarriers; + uint32_t Expected_imageMemoryBarrierCount; + const VkImageMemoryBarrier* Expected_pImageMemoryBarriers; + char IgnoreArg_commandBuffer; + char IgnoreArg_srcStageMask; + char IgnoreArg_dstStageMask; + char IgnoreArg_dependencyFlags; + char IgnoreArg_memoryBarrierCount; + char IgnoreArg_pMemoryBarriers; + char IgnoreArg_bufferMemoryBarrierCount; + char IgnoreArg_pBufferMemoryBarriers; + char IgnoreArg_imageMemoryBarrierCount; + char IgnoreArg_pImageMemoryBarriers; + +} CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBeginQuery_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkQueryPool Expected_queryPool; + uint32_t Expected_query; + VkQueryControlFlags Expected_flags; + char IgnoreArg_commandBuffer; + char IgnoreArg_queryPool; + char IgnoreArg_query; + char IgnoreArg_flags; + +} CMOCK_vkCmdBeginQuery_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdEndQuery_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkQueryPool Expected_queryPool; + uint32_t Expected_query; + char IgnoreArg_commandBuffer; + char IgnoreArg_queryPool; + char IgnoreArg_query; + +} CMOCK_vkCmdEndQuery_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdResetQueryPool_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkQueryPool Expected_queryPool; + uint32_t Expected_firstQuery; + uint32_t Expected_queryCount; + char IgnoreArg_commandBuffer; + char IgnoreArg_queryPool; + char IgnoreArg_firstQuery; + char IgnoreArg_queryCount; + +} CMOCK_vkCmdResetQueryPool_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdWriteTimestamp_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkPipelineStageFlagBits Expected_pipelineStage; + VkQueryPool Expected_queryPool; + uint32_t Expected_query; + char IgnoreArg_commandBuffer; + char IgnoreArg_pipelineStage; + char IgnoreArg_queryPool; + char IgnoreArg_query; + +} CMOCK_vkCmdWriteTimestamp_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdCopyQueryPoolResults_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkQueryPool Expected_queryPool; + uint32_t Expected_firstQuery; + uint32_t Expected_queryCount; + VkBuffer Expected_dstBuffer; + VkDeviceSize Expected_dstOffset; + VkDeviceSize Expected_stride; + VkQueryResultFlags Expected_flags; + char IgnoreArg_commandBuffer; + char IgnoreArg_queryPool; + char IgnoreArg_firstQuery; + char IgnoreArg_queryCount; + char IgnoreArg_dstBuffer; + char IgnoreArg_dstOffset; + char IgnoreArg_stride; + char IgnoreArg_flags; + +} CMOCK_vkCmdCopyQueryPoolResults_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdPushConstants_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkPipelineLayout Expected_layout; + VkShaderStageFlags Expected_stageFlags; + uint32_t Expected_offset; + uint32_t Expected_size; + const void* Expected_pValues; + char IgnoreArg_commandBuffer; + char IgnoreArg_layout; + char IgnoreArg_stageFlags; + char IgnoreArg_offset; + char IgnoreArg_size; + char IgnoreArg_pValues; + +} CMOCK_vkCmdPushConstants_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBeginRenderPass_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkRenderPassBeginInfo* Expected_pRenderPassBegin; + VkSubpassContents Expected_contents; + char IgnoreArg_commandBuffer; + char IgnoreArg_pRenderPassBegin; + char IgnoreArg_contents; + +} CMOCK_vkCmdBeginRenderPass_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdNextSubpass_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkSubpassContents Expected_contents; + char IgnoreArg_commandBuffer; + char IgnoreArg_contents; + +} CMOCK_vkCmdNextSubpass_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdEndRenderPass_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + char IgnoreArg_commandBuffer; + +} CMOCK_vkCmdEndRenderPass_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdExecuteCommands_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_commandBufferCount; + const VkCommandBuffer* Expected_pCommandBuffers; + char IgnoreArg_commandBuffer; + char IgnoreArg_commandBufferCount; + char IgnoreArg_pCommandBuffers; + +} CMOCK_vkCmdExecuteCommands_CALL_INSTANCE; + +typedef struct _CMOCK_vkEnumerateInstanceVersion_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + uint32_t* Expected_pApiVersion; + char ReturnThruPtr_pApiVersion_Used; + uint32_t const* ReturnThruPtr_pApiVersion_Val; + size_t ReturnThruPtr_pApiVersion_Size; + char IgnoreArg_pApiVersion; + +} CMOCK_vkEnumerateInstanceVersion_CALL_INSTANCE; + +typedef struct _CMOCK_vkBindBufferMemory2_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + uint32_t Expected_bindInfoCount; + const VkBindBufferMemoryInfo* Expected_pBindInfos; + char IgnoreArg_device; + char IgnoreArg_bindInfoCount; + char IgnoreArg_pBindInfos; + +} CMOCK_vkBindBufferMemory2_CALL_INSTANCE; + +typedef struct _CMOCK_vkBindImageMemory2_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + uint32_t Expected_bindInfoCount; + const VkBindImageMemoryInfo* Expected_pBindInfos; + char IgnoreArg_device; + char IgnoreArg_bindInfoCount; + char IgnoreArg_pBindInfos; + +} CMOCK_vkBindImageMemory2_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDeviceGroupPeerMemoryFeatures_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + uint32_t Expected_heapIndex; + uint32_t Expected_localDeviceIndex; + uint32_t Expected_remoteDeviceIndex; + VkPeerMemoryFeatureFlags* Expected_pPeerMemoryFeatures; + char ReturnThruPtr_pPeerMemoryFeatures_Used; + VkPeerMemoryFeatureFlags const* ReturnThruPtr_pPeerMemoryFeatures_Val; + size_t ReturnThruPtr_pPeerMemoryFeatures_Size; + char IgnoreArg_device; + char IgnoreArg_heapIndex; + char IgnoreArg_localDeviceIndex; + char IgnoreArg_remoteDeviceIndex; + char IgnoreArg_pPeerMemoryFeatures; + +} CMOCK_vkGetDeviceGroupPeerMemoryFeatures_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetDeviceMask_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_deviceMask; + char IgnoreArg_commandBuffer; + char IgnoreArg_deviceMask; + +} CMOCK_vkCmdSetDeviceMask_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDispatchBase_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_baseGroupX; + uint32_t Expected_baseGroupY; + uint32_t Expected_baseGroupZ; + uint32_t Expected_groupCountX; + uint32_t Expected_groupCountY; + uint32_t Expected_groupCountZ; + char IgnoreArg_commandBuffer; + char IgnoreArg_baseGroupX; + char IgnoreArg_baseGroupY; + char IgnoreArg_baseGroupZ; + char IgnoreArg_groupCountX; + char IgnoreArg_groupCountY; + char IgnoreArg_groupCountZ; + +} CMOCK_vkCmdDispatchBase_CALL_INSTANCE; + +typedef struct _CMOCK_vkEnumeratePhysicalDeviceGroups_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkInstance Expected_instance; + uint32_t* Expected_pPhysicalDeviceGroupCount; + VkPhysicalDeviceGroupProperties* Expected_pPhysicalDeviceGroupProperties; + char ReturnThruPtr_pPhysicalDeviceGroupCount_Used; + uint32_t const* ReturnThruPtr_pPhysicalDeviceGroupCount_Val; + size_t ReturnThruPtr_pPhysicalDeviceGroupCount_Size; + char ReturnThruPtr_pPhysicalDeviceGroupProperties_Used; + VkPhysicalDeviceGroupProperties const* ReturnThruPtr_pPhysicalDeviceGroupProperties_Val; + size_t ReturnThruPtr_pPhysicalDeviceGroupProperties_Size; + char IgnoreArg_instance; + char IgnoreArg_pPhysicalDeviceGroupCount; + char IgnoreArg_pPhysicalDeviceGroupProperties; + +} CMOCK_vkEnumeratePhysicalDeviceGroups_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetImageMemoryRequirements2_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + const VkImageMemoryRequirementsInfo2* Expected_pInfo; + VkMemoryRequirements2* Expected_pMemoryRequirements; + char ReturnThruPtr_pMemoryRequirements_Used; + VkMemoryRequirements2 const* ReturnThruPtr_pMemoryRequirements_Val; + size_t ReturnThruPtr_pMemoryRequirements_Size; + char IgnoreArg_device; + char IgnoreArg_pInfo; + char IgnoreArg_pMemoryRequirements; + +} CMOCK_vkGetImageMemoryRequirements2_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetBufferMemoryRequirements2_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + const VkBufferMemoryRequirementsInfo2* Expected_pInfo; + VkMemoryRequirements2* Expected_pMemoryRequirements; + char ReturnThruPtr_pMemoryRequirements_Used; + VkMemoryRequirements2 const* ReturnThruPtr_pMemoryRequirements_Val; + size_t ReturnThruPtr_pMemoryRequirements_Size; + char IgnoreArg_device; + char IgnoreArg_pInfo; + char IgnoreArg_pMemoryRequirements; + +} CMOCK_vkGetBufferMemoryRequirements2_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetImageSparseMemoryRequirements2_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + const VkImageSparseMemoryRequirementsInfo2* Expected_pInfo; + uint32_t* Expected_pSparseMemoryRequirementCount; + VkSparseImageMemoryRequirements2* Expected_pSparseMemoryRequirements; + char ReturnThruPtr_pSparseMemoryRequirementCount_Used; + uint32_t const* ReturnThruPtr_pSparseMemoryRequirementCount_Val; + size_t ReturnThruPtr_pSparseMemoryRequirementCount_Size; + char ReturnThruPtr_pSparseMemoryRequirements_Used; + VkSparseImageMemoryRequirements2 const* ReturnThruPtr_pSparseMemoryRequirements_Val; + size_t ReturnThruPtr_pSparseMemoryRequirements_Size; + char IgnoreArg_device; + char IgnoreArg_pInfo; + char IgnoreArg_pSparseMemoryRequirementCount; + char IgnoreArg_pSparseMemoryRequirements; + +} CMOCK_vkGetImageSparseMemoryRequirements2_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceFeatures2_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkPhysicalDevice Expected_physicalDevice; + VkPhysicalDeviceFeatures2* Expected_pFeatures; + char ReturnThruPtr_pFeatures_Used; + VkPhysicalDeviceFeatures2 const* ReturnThruPtr_pFeatures_Val; + size_t ReturnThruPtr_pFeatures_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pFeatures; + +} CMOCK_vkGetPhysicalDeviceFeatures2_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceProperties2_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkPhysicalDevice Expected_physicalDevice; + VkPhysicalDeviceProperties2* Expected_pProperties; + char ReturnThruPtr_pProperties_Used; + VkPhysicalDeviceProperties2 const* ReturnThruPtr_pProperties_Val; + size_t ReturnThruPtr_pProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pProperties; + +} CMOCK_vkGetPhysicalDeviceProperties2_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceFormatProperties2_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkPhysicalDevice Expected_physicalDevice; + VkFormat Expected_format; + VkFormatProperties2* Expected_pFormatProperties; + char ReturnThruPtr_pFormatProperties_Used; + VkFormatProperties2 const* ReturnThruPtr_pFormatProperties_Val; + size_t ReturnThruPtr_pFormatProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_format; + char IgnoreArg_pFormatProperties; + +} CMOCK_vkGetPhysicalDeviceFormatProperties2_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceImageFormatProperties2_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + const VkPhysicalDeviceImageFormatInfo2* Expected_pImageFormatInfo; + VkImageFormatProperties2* Expected_pImageFormatProperties; + char ReturnThruPtr_pImageFormatProperties_Used; + VkImageFormatProperties2 const* ReturnThruPtr_pImageFormatProperties_Val; + size_t ReturnThruPtr_pImageFormatProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pImageFormatInfo; + char IgnoreArg_pImageFormatProperties; + +} CMOCK_vkGetPhysicalDeviceImageFormatProperties2_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkPhysicalDevice Expected_physicalDevice; + uint32_t* Expected_pQueueFamilyPropertyCount; + VkQueueFamilyProperties2* Expected_pQueueFamilyProperties; + char ReturnThruPtr_pQueueFamilyPropertyCount_Used; + uint32_t const* ReturnThruPtr_pQueueFamilyPropertyCount_Val; + size_t ReturnThruPtr_pQueueFamilyPropertyCount_Size; + char ReturnThruPtr_pQueueFamilyProperties_Used; + VkQueueFamilyProperties2 const* ReturnThruPtr_pQueueFamilyProperties_Val; + size_t ReturnThruPtr_pQueueFamilyProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pQueueFamilyPropertyCount; + char IgnoreArg_pQueueFamilyProperties; + +} CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceMemoryProperties2_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkPhysicalDevice Expected_physicalDevice; + VkPhysicalDeviceMemoryProperties2* Expected_pMemoryProperties; + char ReturnThruPtr_pMemoryProperties_Used; + VkPhysicalDeviceMemoryProperties2 const* ReturnThruPtr_pMemoryProperties_Val; + size_t ReturnThruPtr_pMemoryProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pMemoryProperties; + +} CMOCK_vkGetPhysicalDeviceMemoryProperties2_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkPhysicalDevice Expected_physicalDevice; + const VkPhysicalDeviceSparseImageFormatInfo2* Expected_pFormatInfo; + uint32_t* Expected_pPropertyCount; + VkSparseImageFormatProperties2* Expected_pProperties; + char ReturnThruPtr_pPropertyCount_Used; + uint32_t const* ReturnThruPtr_pPropertyCount_Val; + size_t ReturnThruPtr_pPropertyCount_Size; + char ReturnThruPtr_pProperties_Used; + VkSparseImageFormatProperties2 const* ReturnThruPtr_pProperties_Val; + size_t ReturnThruPtr_pProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pFormatInfo; + char IgnoreArg_pPropertyCount; + char IgnoreArg_pProperties; + +} CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2_CALL_INSTANCE; + +typedef struct _CMOCK_vkTrimCommandPool_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkCommandPool Expected_commandPool; + VkCommandPoolTrimFlags Expected_flags; + char IgnoreArg_device; + char IgnoreArg_commandPool; + char IgnoreArg_flags; + +} CMOCK_vkTrimCommandPool_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDeviceQueue2_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + const VkDeviceQueueInfo2* Expected_pQueueInfo; + VkQueue* Expected_pQueue; + char ReturnThruPtr_pQueue_Used; + VkQueue const* ReturnThruPtr_pQueue_Val; + size_t ReturnThruPtr_pQueue_Size; + char IgnoreArg_device; + char IgnoreArg_pQueueInfo; + char IgnoreArg_pQueue; + +} CMOCK_vkGetDeviceQueue2_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateSamplerYcbcrConversion_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkSamplerYcbcrConversionCreateInfo* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkSamplerYcbcrConversion* Expected_pYcbcrConversion; + char ReturnThruPtr_pYcbcrConversion_Used; + VkSamplerYcbcrConversion const* ReturnThruPtr_pYcbcrConversion_Val; + size_t ReturnThruPtr_pYcbcrConversion_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pYcbcrConversion; + +} CMOCK_vkCreateSamplerYcbcrConversion_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroySamplerYcbcrConversion_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkSamplerYcbcrConversion Expected_ycbcrConversion; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_ycbcrConversion; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroySamplerYcbcrConversion_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateDescriptorUpdateTemplate_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkDescriptorUpdateTemplateCreateInfo* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkDescriptorUpdateTemplate* Expected_pDescriptorUpdateTemplate; + char ReturnThruPtr_pDescriptorUpdateTemplate_Used; + VkDescriptorUpdateTemplate const* ReturnThruPtr_pDescriptorUpdateTemplate_Val; + size_t ReturnThruPtr_pDescriptorUpdateTemplate_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pDescriptorUpdateTemplate; + +} CMOCK_vkCreateDescriptorUpdateTemplate_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyDescriptorUpdateTemplate_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkDescriptorUpdateTemplate Expected_descriptorUpdateTemplate; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_descriptorUpdateTemplate; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyDescriptorUpdateTemplate_CALL_INSTANCE; + +typedef struct _CMOCK_vkUpdateDescriptorSetWithTemplate_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkDescriptorSet Expected_descriptorSet; + VkDescriptorUpdateTemplate Expected_descriptorUpdateTemplate; + const void* Expected_pData; + char IgnoreArg_device; + char IgnoreArg_descriptorSet; + char IgnoreArg_descriptorUpdateTemplate; + char IgnoreArg_pData; + +} CMOCK_vkUpdateDescriptorSetWithTemplate_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceExternalBufferProperties_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkPhysicalDevice Expected_physicalDevice; + const VkPhysicalDeviceExternalBufferInfo* Expected_pExternalBufferInfo; + VkExternalBufferProperties* Expected_pExternalBufferProperties; + char ReturnThruPtr_pExternalBufferProperties_Used; + VkExternalBufferProperties const* ReturnThruPtr_pExternalBufferProperties_Val; + size_t ReturnThruPtr_pExternalBufferProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pExternalBufferInfo; + char IgnoreArg_pExternalBufferProperties; + +} CMOCK_vkGetPhysicalDeviceExternalBufferProperties_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceExternalFenceProperties_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkPhysicalDevice Expected_physicalDevice; + const VkPhysicalDeviceExternalFenceInfo* Expected_pExternalFenceInfo; + VkExternalFenceProperties* Expected_pExternalFenceProperties; + char ReturnThruPtr_pExternalFenceProperties_Used; + VkExternalFenceProperties const* ReturnThruPtr_pExternalFenceProperties_Val; + size_t ReturnThruPtr_pExternalFenceProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pExternalFenceInfo; + char IgnoreArg_pExternalFenceProperties; + +} CMOCK_vkGetPhysicalDeviceExternalFenceProperties_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceExternalSemaphoreProperties_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkPhysicalDevice Expected_physicalDevice; + const VkPhysicalDeviceExternalSemaphoreInfo* Expected_pExternalSemaphoreInfo; + VkExternalSemaphoreProperties* Expected_pExternalSemaphoreProperties; + char ReturnThruPtr_pExternalSemaphoreProperties_Used; + VkExternalSemaphoreProperties const* ReturnThruPtr_pExternalSemaphoreProperties_Val; + size_t ReturnThruPtr_pExternalSemaphoreProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pExternalSemaphoreInfo; + char IgnoreArg_pExternalSemaphoreProperties; + +} CMOCK_vkGetPhysicalDeviceExternalSemaphoreProperties_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDescriptorSetLayoutSupport_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + const VkDescriptorSetLayoutCreateInfo* Expected_pCreateInfo; + VkDescriptorSetLayoutSupport* Expected_pSupport; + char ReturnThruPtr_pSupport_Used; + VkDescriptorSetLayoutSupport const* ReturnThruPtr_pSupport_Val; + size_t ReturnThruPtr_pSupport_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pSupport; + +} CMOCK_vkGetDescriptorSetLayoutSupport_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDrawIndirectCount_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBuffer Expected_buffer; + VkDeviceSize Expected_offset; + VkBuffer Expected_countBuffer; + VkDeviceSize Expected_countBufferOffset; + uint32_t Expected_maxDrawCount; + uint32_t Expected_stride; + char IgnoreArg_commandBuffer; + char IgnoreArg_buffer; + char IgnoreArg_offset; + char IgnoreArg_countBuffer; + char IgnoreArg_countBufferOffset; + char IgnoreArg_maxDrawCount; + char IgnoreArg_stride; + +} CMOCK_vkCmdDrawIndirectCount_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDrawIndexedIndirectCount_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBuffer Expected_buffer; + VkDeviceSize Expected_offset; + VkBuffer Expected_countBuffer; + VkDeviceSize Expected_countBufferOffset; + uint32_t Expected_maxDrawCount; + uint32_t Expected_stride; + char IgnoreArg_commandBuffer; + char IgnoreArg_buffer; + char IgnoreArg_offset; + char IgnoreArg_countBuffer; + char IgnoreArg_countBufferOffset; + char IgnoreArg_maxDrawCount; + char IgnoreArg_stride; + +} CMOCK_vkCmdDrawIndexedIndirectCount_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateRenderPass2_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkRenderPassCreateInfo2* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkRenderPass* Expected_pRenderPass; + char ReturnThruPtr_pRenderPass_Used; + VkRenderPass const* ReturnThruPtr_pRenderPass_Val; + size_t ReturnThruPtr_pRenderPass_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pRenderPass; + +} CMOCK_vkCreateRenderPass2_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBeginRenderPass2_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkRenderPassBeginInfo* Expected_pRenderPassBegin; + const VkSubpassBeginInfo* Expected_pSubpassBeginInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pRenderPassBegin; + char IgnoreArg_pSubpassBeginInfo; + +} CMOCK_vkCmdBeginRenderPass2_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdNextSubpass2_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkSubpassBeginInfo* Expected_pSubpassBeginInfo; + const VkSubpassEndInfo* Expected_pSubpassEndInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pSubpassBeginInfo; + char IgnoreArg_pSubpassEndInfo; + +} CMOCK_vkCmdNextSubpass2_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdEndRenderPass2_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkSubpassEndInfo* Expected_pSubpassEndInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pSubpassEndInfo; + +} CMOCK_vkCmdEndRenderPass2_CALL_INSTANCE; + +typedef struct _CMOCK_vkResetQueryPool_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkQueryPool Expected_queryPool; + uint32_t Expected_firstQuery; + uint32_t Expected_queryCount; + char IgnoreArg_device; + char IgnoreArg_queryPool; + char IgnoreArg_firstQuery; + char IgnoreArg_queryCount; + +} CMOCK_vkResetQueryPool_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetSemaphoreCounterValue_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkSemaphore Expected_semaphore; + uint64_t* Expected_pValue; + char ReturnThruPtr_pValue_Used; + uint64_t const* ReturnThruPtr_pValue_Val; + size_t ReturnThruPtr_pValue_Size; + char IgnoreArg_device; + char IgnoreArg_semaphore; + char IgnoreArg_pValue; + +} CMOCK_vkGetSemaphoreCounterValue_CALL_INSTANCE; + +typedef struct _CMOCK_vkWaitSemaphores_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkSemaphoreWaitInfo* Expected_pWaitInfo; + uint64_t Expected_timeout; + char IgnoreArg_device; + char IgnoreArg_pWaitInfo; + char IgnoreArg_timeout; + +} CMOCK_vkWaitSemaphores_CALL_INSTANCE; + +typedef struct _CMOCK_vkSignalSemaphore_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkSemaphoreSignalInfo* Expected_pSignalInfo; + char IgnoreArg_device; + char IgnoreArg_pSignalInfo; + +} CMOCK_vkSignalSemaphore_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetBufferDeviceAddress_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDeviceAddress ReturnVal; + VkDevice Expected_device; + const VkBufferDeviceAddressInfo* Expected_pInfo; + char IgnoreArg_device; + char IgnoreArg_pInfo; + +} CMOCK_vkGetBufferDeviceAddress_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetBufferOpaqueCaptureAddress_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + uint64_t ReturnVal; + VkDevice Expected_device; + const VkBufferDeviceAddressInfo* Expected_pInfo; + char IgnoreArg_device; + char IgnoreArg_pInfo; + +} CMOCK_vkGetBufferOpaqueCaptureAddress_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDeviceMemoryOpaqueCaptureAddress_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + uint64_t ReturnVal; + VkDevice Expected_device; + const VkDeviceMemoryOpaqueCaptureAddressInfo* Expected_pInfo; + char IgnoreArg_device; + char IgnoreArg_pInfo; + +} CMOCK_vkGetDeviceMemoryOpaqueCaptureAddress_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceToolProperties_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + uint32_t* Expected_pToolCount; + VkPhysicalDeviceToolProperties* Expected_pToolProperties; + char ReturnThruPtr_pToolCount_Used; + uint32_t const* ReturnThruPtr_pToolCount_Val; + size_t ReturnThruPtr_pToolCount_Size; + char ReturnThruPtr_pToolProperties_Used; + VkPhysicalDeviceToolProperties const* ReturnThruPtr_pToolProperties_Val; + size_t ReturnThruPtr_pToolProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pToolCount; + char IgnoreArg_pToolProperties; + +} CMOCK_vkGetPhysicalDeviceToolProperties_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreatePrivateDataSlot_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkPrivateDataSlotCreateInfo* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkPrivateDataSlot* Expected_pPrivateDataSlot; + char ReturnThruPtr_pPrivateDataSlot_Used; + VkPrivateDataSlot const* ReturnThruPtr_pPrivateDataSlot_Val; + size_t ReturnThruPtr_pPrivateDataSlot_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pPrivateDataSlot; + +} CMOCK_vkCreatePrivateDataSlot_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyPrivateDataSlot_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkPrivateDataSlot Expected_privateDataSlot; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_privateDataSlot; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyPrivateDataSlot_CALL_INSTANCE; + +typedef struct _CMOCK_vkSetPrivateData_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkObjectType Expected_objectType; + uint64_t Expected_objectHandle; + VkPrivateDataSlot Expected_privateDataSlot; + uint64_t Expected_data; + char IgnoreArg_device; + char IgnoreArg_objectType; + char IgnoreArg_objectHandle; + char IgnoreArg_privateDataSlot; + char IgnoreArg_data; + +} CMOCK_vkSetPrivateData_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPrivateData_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkObjectType Expected_objectType; + uint64_t Expected_objectHandle; + VkPrivateDataSlot Expected_privateDataSlot; + uint64_t* Expected_pData; + char ReturnThruPtr_pData_Used; + uint64_t const* ReturnThruPtr_pData_Val; + size_t ReturnThruPtr_pData_Size; + char IgnoreArg_device; + char IgnoreArg_objectType; + char IgnoreArg_objectHandle; + char IgnoreArg_privateDataSlot; + char IgnoreArg_pData; + +} CMOCK_vkGetPrivateData_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetEvent2_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkEvent Expected_event; + const VkDependencyInfo* Expected_pDependencyInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_event; + char IgnoreArg_pDependencyInfo; + +} CMOCK_vkCmdSetEvent2_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdResetEvent2_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkEvent Expected_event; + VkPipelineStageFlags2 Expected_stageMask; + char IgnoreArg_commandBuffer; + char IgnoreArg_event; + char IgnoreArg_stageMask; + +} CMOCK_vkCmdResetEvent2_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdWaitEvents2_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_eventCount; + const VkEvent* Expected_pEvents; + const VkDependencyInfo* Expected_pDependencyInfos; + char IgnoreArg_commandBuffer; + char IgnoreArg_eventCount; + char IgnoreArg_pEvents; + char IgnoreArg_pDependencyInfos; + +} CMOCK_vkCmdWaitEvents2_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdPipelineBarrier2_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkDependencyInfo* Expected_pDependencyInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pDependencyInfo; + +} CMOCK_vkCmdPipelineBarrier2_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdWriteTimestamp2_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkPipelineStageFlags2 Expected_stage; + VkQueryPool Expected_queryPool; + uint32_t Expected_query; + char IgnoreArg_commandBuffer; + char IgnoreArg_stage; + char IgnoreArg_queryPool; + char IgnoreArg_query; + +} CMOCK_vkCmdWriteTimestamp2_CALL_INSTANCE; + +typedef struct _CMOCK_vkQueueSubmit2_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkQueue Expected_queue; + uint32_t Expected_submitCount; + const VkSubmitInfo2* Expected_pSubmits; + VkFence Expected_fence; + char IgnoreArg_queue; + char IgnoreArg_submitCount; + char IgnoreArg_pSubmits; + char IgnoreArg_fence; + +} CMOCK_vkQueueSubmit2_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdCopyBuffer2_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkCopyBufferInfo2* Expected_pCopyBufferInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pCopyBufferInfo; + +} CMOCK_vkCmdCopyBuffer2_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdCopyImage2_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkCopyImageInfo2* Expected_pCopyImageInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pCopyImageInfo; + +} CMOCK_vkCmdCopyImage2_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdCopyBufferToImage2_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkCopyBufferToImageInfo2* Expected_pCopyBufferToImageInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pCopyBufferToImageInfo; + +} CMOCK_vkCmdCopyBufferToImage2_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdCopyImageToBuffer2_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkCopyImageToBufferInfo2* Expected_pCopyImageToBufferInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pCopyImageToBufferInfo; + +} CMOCK_vkCmdCopyImageToBuffer2_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBlitImage2_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkBlitImageInfo2* Expected_pBlitImageInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pBlitImageInfo; + +} CMOCK_vkCmdBlitImage2_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdResolveImage2_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkResolveImageInfo2* Expected_pResolveImageInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pResolveImageInfo; + +} CMOCK_vkCmdResolveImage2_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBeginRendering_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkRenderingInfo* Expected_pRenderingInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pRenderingInfo; + +} CMOCK_vkCmdBeginRendering_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdEndRendering_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + char IgnoreArg_commandBuffer; + +} CMOCK_vkCmdEndRendering_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetCullMode_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkCullModeFlags Expected_cullMode; + char IgnoreArg_commandBuffer; + char IgnoreArg_cullMode; + +} CMOCK_vkCmdSetCullMode_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetFrontFace_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkFrontFace Expected_frontFace; + char IgnoreArg_commandBuffer; + char IgnoreArg_frontFace; + +} CMOCK_vkCmdSetFrontFace_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetPrimitiveTopology_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkPrimitiveTopology Expected_primitiveTopology; + char IgnoreArg_commandBuffer; + char IgnoreArg_primitiveTopology; + +} CMOCK_vkCmdSetPrimitiveTopology_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetViewportWithCount_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_viewportCount; + const VkViewport* Expected_pViewports; + char IgnoreArg_commandBuffer; + char IgnoreArg_viewportCount; + char IgnoreArg_pViewports; + +} CMOCK_vkCmdSetViewportWithCount_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetScissorWithCount_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_scissorCount; + const VkRect2D* Expected_pScissors; + char IgnoreArg_commandBuffer; + char IgnoreArg_scissorCount; + char IgnoreArg_pScissors; + +} CMOCK_vkCmdSetScissorWithCount_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBindVertexBuffers2_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_firstBinding; + uint32_t Expected_bindingCount; + const VkBuffer* Expected_pBuffers; + const VkDeviceSize* Expected_pOffsets; + const VkDeviceSize* Expected_pSizes; + const VkDeviceSize* Expected_pStrides; + char IgnoreArg_commandBuffer; + char IgnoreArg_firstBinding; + char IgnoreArg_bindingCount; + char IgnoreArg_pBuffers; + char IgnoreArg_pOffsets; + char IgnoreArg_pSizes; + char IgnoreArg_pStrides; + +} CMOCK_vkCmdBindVertexBuffers2_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetDepthTestEnable_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBool32 Expected_depthTestEnable; + char IgnoreArg_commandBuffer; + char IgnoreArg_depthTestEnable; + +} CMOCK_vkCmdSetDepthTestEnable_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetDepthWriteEnable_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBool32 Expected_depthWriteEnable; + char IgnoreArg_commandBuffer; + char IgnoreArg_depthWriteEnable; + +} CMOCK_vkCmdSetDepthWriteEnable_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetDepthCompareOp_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkCompareOp Expected_depthCompareOp; + char IgnoreArg_commandBuffer; + char IgnoreArg_depthCompareOp; + +} CMOCK_vkCmdSetDepthCompareOp_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetDepthBoundsTestEnable_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBool32 Expected_depthBoundsTestEnable; + char IgnoreArg_commandBuffer; + char IgnoreArg_depthBoundsTestEnable; + +} CMOCK_vkCmdSetDepthBoundsTestEnable_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetStencilTestEnable_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBool32 Expected_stencilTestEnable; + char IgnoreArg_commandBuffer; + char IgnoreArg_stencilTestEnable; + +} CMOCK_vkCmdSetStencilTestEnable_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetStencilOp_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkStencilFaceFlags Expected_faceMask; + VkStencilOp Expected_failOp; + VkStencilOp Expected_passOp; + VkStencilOp Expected_depthFailOp; + VkCompareOp Expected_compareOp; + char IgnoreArg_commandBuffer; + char IgnoreArg_faceMask; + char IgnoreArg_failOp; + char IgnoreArg_passOp; + char IgnoreArg_depthFailOp; + char IgnoreArg_compareOp; + +} CMOCK_vkCmdSetStencilOp_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetRasterizerDiscardEnable_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBool32 Expected_rasterizerDiscardEnable; + char IgnoreArg_commandBuffer; + char IgnoreArg_rasterizerDiscardEnable; + +} CMOCK_vkCmdSetRasterizerDiscardEnable_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetDepthBiasEnable_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBool32 Expected_depthBiasEnable; + char IgnoreArg_commandBuffer; + char IgnoreArg_depthBiasEnable; + +} CMOCK_vkCmdSetDepthBiasEnable_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetPrimitiveRestartEnable_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBool32 Expected_primitiveRestartEnable; + char IgnoreArg_commandBuffer; + char IgnoreArg_primitiveRestartEnable; + +} CMOCK_vkCmdSetPrimitiveRestartEnable_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDeviceBufferMemoryRequirements_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + const VkDeviceBufferMemoryRequirements* Expected_pInfo; + VkMemoryRequirements2* Expected_pMemoryRequirements; + char ReturnThruPtr_pMemoryRequirements_Used; + VkMemoryRequirements2 const* ReturnThruPtr_pMemoryRequirements_Val; + size_t ReturnThruPtr_pMemoryRequirements_Size; + char IgnoreArg_device; + char IgnoreArg_pInfo; + char IgnoreArg_pMemoryRequirements; + +} CMOCK_vkGetDeviceBufferMemoryRequirements_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDeviceImageMemoryRequirements_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + const VkDeviceImageMemoryRequirements* Expected_pInfo; + VkMemoryRequirements2* Expected_pMemoryRequirements; + char ReturnThruPtr_pMemoryRequirements_Used; + VkMemoryRequirements2 const* ReturnThruPtr_pMemoryRequirements_Val; + size_t ReturnThruPtr_pMemoryRequirements_Size; + char IgnoreArg_device; + char IgnoreArg_pInfo; + char IgnoreArg_pMemoryRequirements; + +} CMOCK_vkGetDeviceImageMemoryRequirements_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDeviceImageSparseMemoryRequirements_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + const VkDeviceImageMemoryRequirements* Expected_pInfo; + uint32_t* Expected_pSparseMemoryRequirementCount; + VkSparseImageMemoryRequirements2* Expected_pSparseMemoryRequirements; + char ReturnThruPtr_pSparseMemoryRequirementCount_Used; + uint32_t const* ReturnThruPtr_pSparseMemoryRequirementCount_Val; + size_t ReturnThruPtr_pSparseMemoryRequirementCount_Size; + char ReturnThruPtr_pSparseMemoryRequirements_Used; + VkSparseImageMemoryRequirements2 const* ReturnThruPtr_pSparseMemoryRequirements_Val; + size_t ReturnThruPtr_pSparseMemoryRequirements_Size; + char IgnoreArg_device; + char IgnoreArg_pInfo; + char IgnoreArg_pSparseMemoryRequirementCount; + char IgnoreArg_pSparseMemoryRequirements; + +} CMOCK_vkGetDeviceImageSparseMemoryRequirements_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroySurfaceKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkInstance Expected_instance; + VkSurfaceKHR Expected_surface; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_instance; + char IgnoreArg_surface; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroySurfaceKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + uint32_t Expected_queueFamilyIndex; + VkSurfaceKHR Expected_surface; + VkBool32* Expected_pSupported; + char ReturnThruPtr_pSupported_Used; + VkBool32 const* ReturnThruPtr_pSupported_Val; + size_t ReturnThruPtr_pSupported_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_queueFamilyIndex; + char IgnoreArg_surface; + char IgnoreArg_pSupported; + +} CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + VkSurfaceKHR Expected_surface; + VkSurfaceCapabilitiesKHR* Expected_pSurfaceCapabilities; + char ReturnThruPtr_pSurfaceCapabilities_Used; + VkSurfaceCapabilitiesKHR const* ReturnThruPtr_pSurfaceCapabilities_Val; + size_t ReturnThruPtr_pSurfaceCapabilities_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_surface; + char IgnoreArg_pSurfaceCapabilities; + +} CMOCK_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + VkSurfaceKHR Expected_surface; + uint32_t* Expected_pSurfaceFormatCount; + VkSurfaceFormatKHR* Expected_pSurfaceFormats; + char ReturnThruPtr_pSurfaceFormatCount_Used; + uint32_t const* ReturnThruPtr_pSurfaceFormatCount_Val; + size_t ReturnThruPtr_pSurfaceFormatCount_Size; + char ReturnThruPtr_pSurfaceFormats_Used; + VkSurfaceFormatKHR const* ReturnThruPtr_pSurfaceFormats_Val; + size_t ReturnThruPtr_pSurfaceFormats_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_surface; + char IgnoreArg_pSurfaceFormatCount; + char IgnoreArg_pSurfaceFormats; + +} CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + VkSurfaceKHR Expected_surface; + uint32_t* Expected_pPresentModeCount; + VkPresentModeKHR* Expected_pPresentModes; + char ReturnThruPtr_pPresentModeCount_Used; + uint32_t const* ReturnThruPtr_pPresentModeCount_Val; + size_t ReturnThruPtr_pPresentModeCount_Size; + char ReturnThruPtr_pPresentModes_Used; + VkPresentModeKHR const* ReturnThruPtr_pPresentModes_Val; + size_t ReturnThruPtr_pPresentModes_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_surface; + char IgnoreArg_pPresentModeCount; + char IgnoreArg_pPresentModes; + +} CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateSwapchainKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkSwapchainCreateInfoKHR* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkSwapchainKHR* Expected_pSwapchain; + char ReturnThruPtr_pSwapchain_Used; + VkSwapchainKHR const* ReturnThruPtr_pSwapchain_Val; + size_t ReturnThruPtr_pSwapchain_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pSwapchain; + +} CMOCK_vkCreateSwapchainKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroySwapchainKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkSwapchainKHR Expected_swapchain; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_swapchain; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroySwapchainKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetSwapchainImagesKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkSwapchainKHR Expected_swapchain; + uint32_t* Expected_pSwapchainImageCount; + VkImage* Expected_pSwapchainImages; + char ReturnThruPtr_pSwapchainImageCount_Used; + uint32_t const* ReturnThruPtr_pSwapchainImageCount_Val; + size_t ReturnThruPtr_pSwapchainImageCount_Size; + char ReturnThruPtr_pSwapchainImages_Used; + VkImage const* ReturnThruPtr_pSwapchainImages_Val; + size_t ReturnThruPtr_pSwapchainImages_Size; + char IgnoreArg_device; + char IgnoreArg_swapchain; + char IgnoreArg_pSwapchainImageCount; + char IgnoreArg_pSwapchainImages; + +} CMOCK_vkGetSwapchainImagesKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkAcquireNextImageKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkSwapchainKHR Expected_swapchain; + uint64_t Expected_timeout; + VkSemaphore Expected_semaphore; + VkFence Expected_fence; + uint32_t* Expected_pImageIndex; + char ReturnThruPtr_pImageIndex_Used; + uint32_t const* ReturnThruPtr_pImageIndex_Val; + size_t ReturnThruPtr_pImageIndex_Size; + char IgnoreArg_device; + char IgnoreArg_swapchain; + char IgnoreArg_timeout; + char IgnoreArg_semaphore; + char IgnoreArg_fence; + char IgnoreArg_pImageIndex; + +} CMOCK_vkAcquireNextImageKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkQueuePresentKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkQueue Expected_queue; + const VkPresentInfoKHR* Expected_pPresentInfo; + char IgnoreArg_queue; + char IgnoreArg_pPresentInfo; + +} CMOCK_vkQueuePresentKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDeviceGroupPresentCapabilitiesKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkDeviceGroupPresentCapabilitiesKHR* Expected_pDeviceGroupPresentCapabilities; + char ReturnThruPtr_pDeviceGroupPresentCapabilities_Used; + VkDeviceGroupPresentCapabilitiesKHR const* ReturnThruPtr_pDeviceGroupPresentCapabilities_Val; + size_t ReturnThruPtr_pDeviceGroupPresentCapabilities_Size; + char IgnoreArg_device; + char IgnoreArg_pDeviceGroupPresentCapabilities; + +} CMOCK_vkGetDeviceGroupPresentCapabilitiesKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDeviceGroupSurfacePresentModesKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkSurfaceKHR Expected_surface; + VkDeviceGroupPresentModeFlagsKHR* Expected_pModes; + char ReturnThruPtr_pModes_Used; + VkDeviceGroupPresentModeFlagsKHR const* ReturnThruPtr_pModes_Val; + size_t ReturnThruPtr_pModes_Size; + char IgnoreArg_device; + char IgnoreArg_surface; + char IgnoreArg_pModes; + +} CMOCK_vkGetDeviceGroupSurfacePresentModesKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + VkSurfaceKHR Expected_surface; + uint32_t* Expected_pRectCount; + VkRect2D* Expected_pRects; + char ReturnThruPtr_pRectCount_Used; + uint32_t const* ReturnThruPtr_pRectCount_Val; + size_t ReturnThruPtr_pRectCount_Size; + char ReturnThruPtr_pRects_Used; + VkRect2D const* ReturnThruPtr_pRects_Val; + size_t ReturnThruPtr_pRects_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_surface; + char IgnoreArg_pRectCount; + char IgnoreArg_pRects; + +} CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkAcquireNextImage2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkAcquireNextImageInfoKHR* Expected_pAcquireInfo; + uint32_t* Expected_pImageIndex; + char ReturnThruPtr_pImageIndex_Used; + uint32_t const* ReturnThruPtr_pImageIndex_Val; + size_t ReturnThruPtr_pImageIndex_Size; + char IgnoreArg_device; + char IgnoreArg_pAcquireInfo; + char IgnoreArg_pImageIndex; + +} CMOCK_vkAcquireNextImage2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + uint32_t* Expected_pPropertyCount; + VkDisplayPropertiesKHR* Expected_pProperties; + char ReturnThruPtr_pPropertyCount_Used; + uint32_t const* ReturnThruPtr_pPropertyCount_Val; + size_t ReturnThruPtr_pPropertyCount_Size; + char ReturnThruPtr_pProperties_Used; + VkDisplayPropertiesKHR const* ReturnThruPtr_pProperties_Val; + size_t ReturnThruPtr_pProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pPropertyCount; + char IgnoreArg_pProperties; + +} CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + uint32_t* Expected_pPropertyCount; + VkDisplayPlanePropertiesKHR* Expected_pProperties; + char ReturnThruPtr_pPropertyCount_Used; + uint32_t const* ReturnThruPtr_pPropertyCount_Val; + size_t ReturnThruPtr_pPropertyCount_Size; + char ReturnThruPtr_pProperties_Used; + VkDisplayPlanePropertiesKHR const* ReturnThruPtr_pProperties_Val; + size_t ReturnThruPtr_pProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pPropertyCount; + char IgnoreArg_pProperties; + +} CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + uint32_t Expected_planeIndex; + uint32_t* Expected_pDisplayCount; + VkDisplayKHR* Expected_pDisplays; + char ReturnThruPtr_pDisplayCount_Used; + uint32_t const* ReturnThruPtr_pDisplayCount_Val; + size_t ReturnThruPtr_pDisplayCount_Size; + char ReturnThruPtr_pDisplays_Used; + VkDisplayKHR const* ReturnThruPtr_pDisplays_Val; + size_t ReturnThruPtr_pDisplays_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_planeIndex; + char IgnoreArg_pDisplayCount; + char IgnoreArg_pDisplays; + +} CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDisplayModePropertiesKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + VkDisplayKHR Expected_display; + uint32_t* Expected_pPropertyCount; + VkDisplayModePropertiesKHR* Expected_pProperties; + char ReturnThruPtr_pPropertyCount_Used; + uint32_t const* ReturnThruPtr_pPropertyCount_Val; + size_t ReturnThruPtr_pPropertyCount_Size; + char ReturnThruPtr_pProperties_Used; + VkDisplayModePropertiesKHR const* ReturnThruPtr_pProperties_Val; + size_t ReturnThruPtr_pProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_display; + char IgnoreArg_pPropertyCount; + char IgnoreArg_pProperties; + +} CMOCK_vkGetDisplayModePropertiesKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateDisplayModeKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + VkDisplayKHR Expected_display; + const VkDisplayModeCreateInfoKHR* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkDisplayModeKHR* Expected_pMode; + char ReturnThruPtr_pMode_Used; + VkDisplayModeKHR const* ReturnThruPtr_pMode_Val; + size_t ReturnThruPtr_pMode_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_display; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pMode; + +} CMOCK_vkCreateDisplayModeKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + VkDisplayModeKHR Expected_mode; + uint32_t Expected_planeIndex; + VkDisplayPlaneCapabilitiesKHR* Expected_pCapabilities; + char ReturnThruPtr_pCapabilities_Used; + VkDisplayPlaneCapabilitiesKHR const* ReturnThruPtr_pCapabilities_Val; + size_t ReturnThruPtr_pCapabilities_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_mode; + char IgnoreArg_planeIndex; + char IgnoreArg_pCapabilities; + +} CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkInstance Expected_instance; + const VkDisplaySurfaceCreateInfoKHR* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkSurfaceKHR* Expected_pSurface; + char ReturnThruPtr_pSurface_Used; + VkSurfaceKHR const* ReturnThruPtr_pSurface_Val; + size_t ReturnThruPtr_pSurface_Size; + char IgnoreArg_instance; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pSurface; + +} CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateSharedSwapchainsKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + uint32_t Expected_swapchainCount; + const VkSwapchainCreateInfoKHR* Expected_pCreateInfos; + const VkAllocationCallbacks* Expected_pAllocator; + VkSwapchainKHR* Expected_pSwapchains; + char ReturnThruPtr_pSwapchains_Used; + VkSwapchainKHR const* ReturnThruPtr_pSwapchains_Val; + size_t ReturnThruPtr_pSwapchains_Size; + char IgnoreArg_device; + char IgnoreArg_swapchainCount; + char IgnoreArg_pCreateInfos; + char IgnoreArg_pAllocator; + char IgnoreArg_pSwapchains; + +} CMOCK_vkCreateSharedSwapchainsKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceVideoCapabilitiesKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + const VkVideoProfileInfoKHR* Expected_pVideoProfile; + VkVideoCapabilitiesKHR* Expected_pCapabilities; + char ReturnThruPtr_pCapabilities_Used; + VkVideoCapabilitiesKHR const* ReturnThruPtr_pCapabilities_Val; + size_t ReturnThruPtr_pCapabilities_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pVideoProfile; + char IgnoreArg_pCapabilities; + +} CMOCK_vkGetPhysicalDeviceVideoCapabilitiesKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + const VkPhysicalDeviceVideoFormatInfoKHR* Expected_pVideoFormatInfo; + uint32_t* Expected_pVideoFormatPropertyCount; + VkVideoFormatPropertiesKHR* Expected_pVideoFormatProperties; + char ReturnThruPtr_pVideoFormatPropertyCount_Used; + uint32_t const* ReturnThruPtr_pVideoFormatPropertyCount_Val; + size_t ReturnThruPtr_pVideoFormatPropertyCount_Size; + char ReturnThruPtr_pVideoFormatProperties_Used; + VkVideoFormatPropertiesKHR const* ReturnThruPtr_pVideoFormatProperties_Val; + size_t ReturnThruPtr_pVideoFormatProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pVideoFormatInfo; + char IgnoreArg_pVideoFormatPropertyCount; + char IgnoreArg_pVideoFormatProperties; + +} CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateVideoSessionKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkVideoSessionCreateInfoKHR* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkVideoSessionKHR* Expected_pVideoSession; + char ReturnThruPtr_pVideoSession_Used; + VkVideoSessionKHR const* ReturnThruPtr_pVideoSession_Val; + size_t ReturnThruPtr_pVideoSession_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pVideoSession; + +} CMOCK_vkCreateVideoSessionKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyVideoSessionKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkVideoSessionKHR Expected_videoSession; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_videoSession; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyVideoSessionKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkVideoSessionKHR Expected_videoSession; + uint32_t* Expected_pMemoryRequirementsCount; + VkVideoSessionMemoryRequirementsKHR* Expected_pMemoryRequirements; + char ReturnThruPtr_pMemoryRequirementsCount_Used; + uint32_t const* ReturnThruPtr_pMemoryRequirementsCount_Val; + size_t ReturnThruPtr_pMemoryRequirementsCount_Size; + char ReturnThruPtr_pMemoryRequirements_Used; + VkVideoSessionMemoryRequirementsKHR const* ReturnThruPtr_pMemoryRequirements_Val; + size_t ReturnThruPtr_pMemoryRequirements_Size; + char IgnoreArg_device; + char IgnoreArg_videoSession; + char IgnoreArg_pMemoryRequirementsCount; + char IgnoreArg_pMemoryRequirements; + +} CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkBindVideoSessionMemoryKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkVideoSessionKHR Expected_videoSession; + uint32_t Expected_bindSessionMemoryInfoCount; + const VkBindVideoSessionMemoryInfoKHR* Expected_pBindSessionMemoryInfos; + char IgnoreArg_device; + char IgnoreArg_videoSession; + char IgnoreArg_bindSessionMemoryInfoCount; + char IgnoreArg_pBindSessionMemoryInfos; + +} CMOCK_vkBindVideoSessionMemoryKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateVideoSessionParametersKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkVideoSessionParametersCreateInfoKHR* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkVideoSessionParametersKHR* Expected_pVideoSessionParameters; + char ReturnThruPtr_pVideoSessionParameters_Used; + VkVideoSessionParametersKHR const* ReturnThruPtr_pVideoSessionParameters_Val; + size_t ReturnThruPtr_pVideoSessionParameters_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pVideoSessionParameters; + +} CMOCK_vkCreateVideoSessionParametersKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkUpdateVideoSessionParametersKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkVideoSessionParametersKHR Expected_videoSessionParameters; + const VkVideoSessionParametersUpdateInfoKHR* Expected_pUpdateInfo; + char IgnoreArg_device; + char IgnoreArg_videoSessionParameters; + char IgnoreArg_pUpdateInfo; + +} CMOCK_vkUpdateVideoSessionParametersKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyVideoSessionParametersKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkVideoSessionParametersKHR Expected_videoSessionParameters; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_videoSessionParameters; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyVideoSessionParametersKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBeginVideoCodingKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkVideoBeginCodingInfoKHR* Expected_pBeginInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pBeginInfo; + +} CMOCK_vkCmdBeginVideoCodingKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdEndVideoCodingKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkVideoEndCodingInfoKHR* Expected_pEndCodingInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pEndCodingInfo; + +} CMOCK_vkCmdEndVideoCodingKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdControlVideoCodingKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkVideoCodingControlInfoKHR* Expected_pCodingControlInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pCodingControlInfo; + +} CMOCK_vkCmdControlVideoCodingKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDecodeVideoKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkVideoDecodeInfoKHR* Expected_pDecodeInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pDecodeInfo; + +} CMOCK_vkCmdDecodeVideoKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBeginRenderingKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkRenderingInfo* Expected_pRenderingInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pRenderingInfo; + +} CMOCK_vkCmdBeginRenderingKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdEndRenderingKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + char IgnoreArg_commandBuffer; + +} CMOCK_vkCmdEndRenderingKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceFeatures2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkPhysicalDevice Expected_physicalDevice; + VkPhysicalDeviceFeatures2* Expected_pFeatures; + char ReturnThruPtr_pFeatures_Used; + VkPhysicalDeviceFeatures2 const* ReturnThruPtr_pFeatures_Val; + size_t ReturnThruPtr_pFeatures_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pFeatures; + +} CMOCK_vkGetPhysicalDeviceFeatures2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceProperties2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkPhysicalDevice Expected_physicalDevice; + VkPhysicalDeviceProperties2* Expected_pProperties; + char ReturnThruPtr_pProperties_Used; + VkPhysicalDeviceProperties2 const* ReturnThruPtr_pProperties_Val; + size_t ReturnThruPtr_pProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pProperties; + +} CMOCK_vkGetPhysicalDeviceProperties2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceFormatProperties2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkPhysicalDevice Expected_physicalDevice; + VkFormat Expected_format; + VkFormatProperties2* Expected_pFormatProperties; + char ReturnThruPtr_pFormatProperties_Used; + VkFormatProperties2 const* ReturnThruPtr_pFormatProperties_Val; + size_t ReturnThruPtr_pFormatProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_format; + char IgnoreArg_pFormatProperties; + +} CMOCK_vkGetPhysicalDeviceFormatProperties2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceImageFormatProperties2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + const VkPhysicalDeviceImageFormatInfo2* Expected_pImageFormatInfo; + VkImageFormatProperties2* Expected_pImageFormatProperties; + char ReturnThruPtr_pImageFormatProperties_Used; + VkImageFormatProperties2 const* ReturnThruPtr_pImageFormatProperties_Val; + size_t ReturnThruPtr_pImageFormatProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pImageFormatInfo; + char IgnoreArg_pImageFormatProperties; + +} CMOCK_vkGetPhysicalDeviceImageFormatProperties2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkPhysicalDevice Expected_physicalDevice; + uint32_t* Expected_pQueueFamilyPropertyCount; + VkQueueFamilyProperties2* Expected_pQueueFamilyProperties; + char ReturnThruPtr_pQueueFamilyPropertyCount_Used; + uint32_t const* ReturnThruPtr_pQueueFamilyPropertyCount_Val; + size_t ReturnThruPtr_pQueueFamilyPropertyCount_Size; + char ReturnThruPtr_pQueueFamilyProperties_Used; + VkQueueFamilyProperties2 const* ReturnThruPtr_pQueueFamilyProperties_Val; + size_t ReturnThruPtr_pQueueFamilyProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pQueueFamilyPropertyCount; + char IgnoreArg_pQueueFamilyProperties; + +} CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceMemoryProperties2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkPhysicalDevice Expected_physicalDevice; + VkPhysicalDeviceMemoryProperties2* Expected_pMemoryProperties; + char ReturnThruPtr_pMemoryProperties_Used; + VkPhysicalDeviceMemoryProperties2 const* ReturnThruPtr_pMemoryProperties_Val; + size_t ReturnThruPtr_pMemoryProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pMemoryProperties; + +} CMOCK_vkGetPhysicalDeviceMemoryProperties2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkPhysicalDevice Expected_physicalDevice; + const VkPhysicalDeviceSparseImageFormatInfo2* Expected_pFormatInfo; + uint32_t* Expected_pPropertyCount; + VkSparseImageFormatProperties2* Expected_pProperties; + char ReturnThruPtr_pPropertyCount_Used; + uint32_t const* ReturnThruPtr_pPropertyCount_Val; + size_t ReturnThruPtr_pPropertyCount_Size; + char ReturnThruPtr_pProperties_Used; + VkSparseImageFormatProperties2 const* ReturnThruPtr_pProperties_Val; + size_t ReturnThruPtr_pProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pFormatInfo; + char IgnoreArg_pPropertyCount; + char IgnoreArg_pProperties; + +} CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDeviceGroupPeerMemoryFeaturesKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + uint32_t Expected_heapIndex; + uint32_t Expected_localDeviceIndex; + uint32_t Expected_remoteDeviceIndex; + VkPeerMemoryFeatureFlags* Expected_pPeerMemoryFeatures; + char ReturnThruPtr_pPeerMemoryFeatures_Used; + VkPeerMemoryFeatureFlags const* ReturnThruPtr_pPeerMemoryFeatures_Val; + size_t ReturnThruPtr_pPeerMemoryFeatures_Size; + char IgnoreArg_device; + char IgnoreArg_heapIndex; + char IgnoreArg_localDeviceIndex; + char IgnoreArg_remoteDeviceIndex; + char IgnoreArg_pPeerMemoryFeatures; + +} CMOCK_vkGetDeviceGroupPeerMemoryFeaturesKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetDeviceMaskKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_deviceMask; + char IgnoreArg_commandBuffer; + char IgnoreArg_deviceMask; + +} CMOCK_vkCmdSetDeviceMaskKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDispatchBaseKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_baseGroupX; + uint32_t Expected_baseGroupY; + uint32_t Expected_baseGroupZ; + uint32_t Expected_groupCountX; + uint32_t Expected_groupCountY; + uint32_t Expected_groupCountZ; + char IgnoreArg_commandBuffer; + char IgnoreArg_baseGroupX; + char IgnoreArg_baseGroupY; + char IgnoreArg_baseGroupZ; + char IgnoreArg_groupCountX; + char IgnoreArg_groupCountY; + char IgnoreArg_groupCountZ; + +} CMOCK_vkCmdDispatchBaseKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkTrimCommandPoolKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkCommandPool Expected_commandPool; + VkCommandPoolTrimFlags Expected_flags; + char IgnoreArg_device; + char IgnoreArg_commandPool; + char IgnoreArg_flags; + +} CMOCK_vkTrimCommandPoolKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkInstance Expected_instance; + uint32_t* Expected_pPhysicalDeviceGroupCount; + VkPhysicalDeviceGroupProperties* Expected_pPhysicalDeviceGroupProperties; + char ReturnThruPtr_pPhysicalDeviceGroupCount_Used; + uint32_t const* ReturnThruPtr_pPhysicalDeviceGroupCount_Val; + size_t ReturnThruPtr_pPhysicalDeviceGroupCount_Size; + char ReturnThruPtr_pPhysicalDeviceGroupProperties_Used; + VkPhysicalDeviceGroupProperties const* ReturnThruPtr_pPhysicalDeviceGroupProperties_Val; + size_t ReturnThruPtr_pPhysicalDeviceGroupProperties_Size; + char IgnoreArg_instance; + char IgnoreArg_pPhysicalDeviceGroupCount; + char IgnoreArg_pPhysicalDeviceGroupProperties; + +} CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceExternalBufferPropertiesKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkPhysicalDevice Expected_physicalDevice; + const VkPhysicalDeviceExternalBufferInfo* Expected_pExternalBufferInfo; + VkExternalBufferProperties* Expected_pExternalBufferProperties; + char ReturnThruPtr_pExternalBufferProperties_Used; + VkExternalBufferProperties const* ReturnThruPtr_pExternalBufferProperties_Val; + size_t ReturnThruPtr_pExternalBufferProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pExternalBufferInfo; + char IgnoreArg_pExternalBufferProperties; + +} CMOCK_vkGetPhysicalDeviceExternalBufferPropertiesKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetMemoryFdKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkMemoryGetFdInfoKHR* Expected_pGetFdInfo; + int* Expected_pFd; + char ReturnThruPtr_pFd_Used; + int const* ReturnThruPtr_pFd_Val; + size_t ReturnThruPtr_pFd_Size; + char IgnoreArg_device; + char IgnoreArg_pGetFdInfo; + char IgnoreArg_pFd; + +} CMOCK_vkGetMemoryFdKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetMemoryFdPropertiesKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkExternalMemoryHandleTypeFlagBits Expected_handleType; + int Expected_fd; + VkMemoryFdPropertiesKHR* Expected_pMemoryFdProperties; + char ReturnThruPtr_pMemoryFdProperties_Used; + VkMemoryFdPropertiesKHR const* ReturnThruPtr_pMemoryFdProperties_Val; + size_t ReturnThruPtr_pMemoryFdProperties_Size; + char IgnoreArg_device; + char IgnoreArg_handleType; + char IgnoreArg_fd; + char IgnoreArg_pMemoryFdProperties; + +} CMOCK_vkGetMemoryFdPropertiesKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkPhysicalDevice Expected_physicalDevice; + const VkPhysicalDeviceExternalSemaphoreInfo* Expected_pExternalSemaphoreInfo; + VkExternalSemaphoreProperties* Expected_pExternalSemaphoreProperties; + char ReturnThruPtr_pExternalSemaphoreProperties_Used; + VkExternalSemaphoreProperties const* ReturnThruPtr_pExternalSemaphoreProperties_Val; + size_t ReturnThruPtr_pExternalSemaphoreProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pExternalSemaphoreInfo; + char IgnoreArg_pExternalSemaphoreProperties; + +} CMOCK_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkImportSemaphoreFdKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkImportSemaphoreFdInfoKHR* Expected_pImportSemaphoreFdInfo; + char IgnoreArg_device; + char IgnoreArg_pImportSemaphoreFdInfo; + +} CMOCK_vkImportSemaphoreFdKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetSemaphoreFdKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkSemaphoreGetFdInfoKHR* Expected_pGetFdInfo; + int* Expected_pFd; + char ReturnThruPtr_pFd_Used; + int const* ReturnThruPtr_pFd_Val; + size_t ReturnThruPtr_pFd_Size; + char IgnoreArg_device; + char IgnoreArg_pGetFdInfo; + char IgnoreArg_pFd; + +} CMOCK_vkGetSemaphoreFdKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdPushDescriptorSetKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkPipelineBindPoint Expected_pipelineBindPoint; + VkPipelineLayout Expected_layout; + uint32_t Expected_set; + uint32_t Expected_descriptorWriteCount; + const VkWriteDescriptorSet* Expected_pDescriptorWrites; + char IgnoreArg_commandBuffer; + char IgnoreArg_pipelineBindPoint; + char IgnoreArg_layout; + char IgnoreArg_set; + char IgnoreArg_descriptorWriteCount; + char IgnoreArg_pDescriptorWrites; + +} CMOCK_vkCmdPushDescriptorSetKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdPushDescriptorSetWithTemplateKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkDescriptorUpdateTemplate Expected_descriptorUpdateTemplate; + VkPipelineLayout Expected_layout; + uint32_t Expected_set; + const void* Expected_pData; + char IgnoreArg_commandBuffer; + char IgnoreArg_descriptorUpdateTemplate; + char IgnoreArg_layout; + char IgnoreArg_set; + char IgnoreArg_pData; + +} CMOCK_vkCmdPushDescriptorSetWithTemplateKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkDescriptorUpdateTemplateCreateInfo* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkDescriptorUpdateTemplate* Expected_pDescriptorUpdateTemplate; + char ReturnThruPtr_pDescriptorUpdateTemplate_Used; + VkDescriptorUpdateTemplate const* ReturnThruPtr_pDescriptorUpdateTemplate_Val; + size_t ReturnThruPtr_pDescriptorUpdateTemplate_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pDescriptorUpdateTemplate; + +} CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyDescriptorUpdateTemplateKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkDescriptorUpdateTemplate Expected_descriptorUpdateTemplate; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_descriptorUpdateTemplate; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyDescriptorUpdateTemplateKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkUpdateDescriptorSetWithTemplateKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkDescriptorSet Expected_descriptorSet; + VkDescriptorUpdateTemplate Expected_descriptorUpdateTemplate; + const void* Expected_pData; + char IgnoreArg_device; + char IgnoreArg_descriptorSet; + char IgnoreArg_descriptorUpdateTemplate; + char IgnoreArg_pData; + +} CMOCK_vkUpdateDescriptorSetWithTemplateKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateRenderPass2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkRenderPassCreateInfo2* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkRenderPass* Expected_pRenderPass; + char ReturnThruPtr_pRenderPass_Used; + VkRenderPass const* ReturnThruPtr_pRenderPass_Val; + size_t ReturnThruPtr_pRenderPass_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pRenderPass; + +} CMOCK_vkCreateRenderPass2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBeginRenderPass2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkRenderPassBeginInfo* Expected_pRenderPassBegin; + const VkSubpassBeginInfo* Expected_pSubpassBeginInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pRenderPassBegin; + char IgnoreArg_pSubpassBeginInfo; + +} CMOCK_vkCmdBeginRenderPass2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdNextSubpass2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkSubpassBeginInfo* Expected_pSubpassBeginInfo; + const VkSubpassEndInfo* Expected_pSubpassEndInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pSubpassBeginInfo; + char IgnoreArg_pSubpassEndInfo; + +} CMOCK_vkCmdNextSubpass2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdEndRenderPass2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkSubpassEndInfo* Expected_pSubpassEndInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pSubpassEndInfo; + +} CMOCK_vkCmdEndRenderPass2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetSwapchainStatusKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkSwapchainKHR Expected_swapchain; + char IgnoreArg_device; + char IgnoreArg_swapchain; + +} CMOCK_vkGetSwapchainStatusKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceExternalFencePropertiesKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkPhysicalDevice Expected_physicalDevice; + const VkPhysicalDeviceExternalFenceInfo* Expected_pExternalFenceInfo; + VkExternalFenceProperties* Expected_pExternalFenceProperties; + char ReturnThruPtr_pExternalFenceProperties_Used; + VkExternalFenceProperties const* ReturnThruPtr_pExternalFenceProperties_Val; + size_t ReturnThruPtr_pExternalFenceProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pExternalFenceInfo; + char IgnoreArg_pExternalFenceProperties; + +} CMOCK_vkGetPhysicalDeviceExternalFencePropertiesKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkImportFenceFdKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkImportFenceFdInfoKHR* Expected_pImportFenceFdInfo; + char IgnoreArg_device; + char IgnoreArg_pImportFenceFdInfo; + +} CMOCK_vkImportFenceFdKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetFenceFdKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkFenceGetFdInfoKHR* Expected_pGetFdInfo; + int* Expected_pFd; + char ReturnThruPtr_pFd_Used; + int const* ReturnThruPtr_pFd_Val; + size_t ReturnThruPtr_pFd_Size; + char IgnoreArg_device; + char IgnoreArg_pGetFdInfo; + char IgnoreArg_pFd; + +} CMOCK_vkGetFenceFdKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + uint32_t Expected_queueFamilyIndex; + uint32_t* Expected_pCounterCount; + VkPerformanceCounterKHR* Expected_pCounters; + VkPerformanceCounterDescriptionKHR* Expected_pCounterDescriptions; + char ReturnThruPtr_pCounterCount_Used; + uint32_t const* ReturnThruPtr_pCounterCount_Val; + size_t ReturnThruPtr_pCounterCount_Size; + char ReturnThruPtr_pCounters_Used; + VkPerformanceCounterKHR const* ReturnThruPtr_pCounters_Val; + size_t ReturnThruPtr_pCounters_Size; + char ReturnThruPtr_pCounterDescriptions_Used; + VkPerformanceCounterDescriptionKHR const* ReturnThruPtr_pCounterDescriptions_Val; + size_t ReturnThruPtr_pCounterDescriptions_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_queueFamilyIndex; + char IgnoreArg_pCounterCount; + char IgnoreArg_pCounters; + char IgnoreArg_pCounterDescriptions; + +} CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkPhysicalDevice Expected_physicalDevice; + const VkQueryPoolPerformanceCreateInfoKHR* Expected_pPerformanceQueryCreateInfo; + uint32_t* Expected_pNumPasses; + char ReturnThruPtr_pNumPasses_Used; + uint32_t const* ReturnThruPtr_pNumPasses_Val; + size_t ReturnThruPtr_pNumPasses_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pPerformanceQueryCreateInfo; + char IgnoreArg_pNumPasses; + +} CMOCK_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkAcquireProfilingLockKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkAcquireProfilingLockInfoKHR* Expected_pInfo; + char IgnoreArg_device; + char IgnoreArg_pInfo; + +} CMOCK_vkAcquireProfilingLockKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkReleaseProfilingLockKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + char IgnoreArg_device; + +} CMOCK_vkReleaseProfilingLockKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + const VkPhysicalDeviceSurfaceInfo2KHR* Expected_pSurfaceInfo; + VkSurfaceCapabilities2KHR* Expected_pSurfaceCapabilities; + char ReturnThruPtr_pSurfaceCapabilities_Used; + VkSurfaceCapabilities2KHR const* ReturnThruPtr_pSurfaceCapabilities_Val; + size_t ReturnThruPtr_pSurfaceCapabilities_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pSurfaceInfo; + char IgnoreArg_pSurfaceCapabilities; + +} CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + const VkPhysicalDeviceSurfaceInfo2KHR* Expected_pSurfaceInfo; + uint32_t* Expected_pSurfaceFormatCount; + VkSurfaceFormat2KHR* Expected_pSurfaceFormats; + char ReturnThruPtr_pSurfaceFormatCount_Used; + uint32_t const* ReturnThruPtr_pSurfaceFormatCount_Val; + size_t ReturnThruPtr_pSurfaceFormatCount_Size; + char ReturnThruPtr_pSurfaceFormats_Used; + VkSurfaceFormat2KHR const* ReturnThruPtr_pSurfaceFormats_Val; + size_t ReturnThruPtr_pSurfaceFormats_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pSurfaceInfo; + char IgnoreArg_pSurfaceFormatCount; + char IgnoreArg_pSurfaceFormats; + +} CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + uint32_t* Expected_pPropertyCount; + VkDisplayProperties2KHR* Expected_pProperties; + char ReturnThruPtr_pPropertyCount_Used; + uint32_t const* ReturnThruPtr_pPropertyCount_Val; + size_t ReturnThruPtr_pPropertyCount_Size; + char ReturnThruPtr_pProperties_Used; + VkDisplayProperties2KHR const* ReturnThruPtr_pProperties_Val; + size_t ReturnThruPtr_pProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pPropertyCount; + char IgnoreArg_pProperties; + +} CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + uint32_t* Expected_pPropertyCount; + VkDisplayPlaneProperties2KHR* Expected_pProperties; + char ReturnThruPtr_pPropertyCount_Used; + uint32_t const* ReturnThruPtr_pPropertyCount_Val; + size_t ReturnThruPtr_pPropertyCount_Size; + char ReturnThruPtr_pProperties_Used; + VkDisplayPlaneProperties2KHR const* ReturnThruPtr_pProperties_Val; + size_t ReturnThruPtr_pProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pPropertyCount; + char IgnoreArg_pProperties; + +} CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDisplayModeProperties2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + VkDisplayKHR Expected_display; + uint32_t* Expected_pPropertyCount; + VkDisplayModeProperties2KHR* Expected_pProperties; + char ReturnThruPtr_pPropertyCount_Used; + uint32_t const* ReturnThruPtr_pPropertyCount_Val; + size_t ReturnThruPtr_pPropertyCount_Size; + char ReturnThruPtr_pProperties_Used; + VkDisplayModeProperties2KHR const* ReturnThruPtr_pProperties_Val; + size_t ReturnThruPtr_pProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_display; + char IgnoreArg_pPropertyCount; + char IgnoreArg_pProperties; + +} CMOCK_vkGetDisplayModeProperties2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDisplayPlaneCapabilities2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + const VkDisplayPlaneInfo2KHR* Expected_pDisplayPlaneInfo; + VkDisplayPlaneCapabilities2KHR* Expected_pCapabilities; + char ReturnThruPtr_pCapabilities_Used; + VkDisplayPlaneCapabilities2KHR const* ReturnThruPtr_pCapabilities_Val; + size_t ReturnThruPtr_pCapabilities_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pDisplayPlaneInfo; + char IgnoreArg_pCapabilities; + +} CMOCK_vkGetDisplayPlaneCapabilities2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetImageMemoryRequirements2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + const VkImageMemoryRequirementsInfo2* Expected_pInfo; + VkMemoryRequirements2* Expected_pMemoryRequirements; + char ReturnThruPtr_pMemoryRequirements_Used; + VkMemoryRequirements2 const* ReturnThruPtr_pMemoryRequirements_Val; + size_t ReturnThruPtr_pMemoryRequirements_Size; + char IgnoreArg_device; + char IgnoreArg_pInfo; + char IgnoreArg_pMemoryRequirements; + +} CMOCK_vkGetImageMemoryRequirements2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetBufferMemoryRequirements2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + const VkBufferMemoryRequirementsInfo2* Expected_pInfo; + VkMemoryRequirements2* Expected_pMemoryRequirements; + char ReturnThruPtr_pMemoryRequirements_Used; + VkMemoryRequirements2 const* ReturnThruPtr_pMemoryRequirements_Val; + size_t ReturnThruPtr_pMemoryRequirements_Size; + char IgnoreArg_device; + char IgnoreArg_pInfo; + char IgnoreArg_pMemoryRequirements; + +} CMOCK_vkGetBufferMemoryRequirements2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetImageSparseMemoryRequirements2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + const VkImageSparseMemoryRequirementsInfo2* Expected_pInfo; + uint32_t* Expected_pSparseMemoryRequirementCount; + VkSparseImageMemoryRequirements2* Expected_pSparseMemoryRequirements; + char ReturnThruPtr_pSparseMemoryRequirementCount_Used; + uint32_t const* ReturnThruPtr_pSparseMemoryRequirementCount_Val; + size_t ReturnThruPtr_pSparseMemoryRequirementCount_Size; + char ReturnThruPtr_pSparseMemoryRequirements_Used; + VkSparseImageMemoryRequirements2 const* ReturnThruPtr_pSparseMemoryRequirements_Val; + size_t ReturnThruPtr_pSparseMemoryRequirements_Size; + char IgnoreArg_device; + char IgnoreArg_pInfo; + char IgnoreArg_pSparseMemoryRequirementCount; + char IgnoreArg_pSparseMemoryRequirements; + +} CMOCK_vkGetImageSparseMemoryRequirements2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateSamplerYcbcrConversionKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkSamplerYcbcrConversionCreateInfo* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkSamplerYcbcrConversion* Expected_pYcbcrConversion; + char ReturnThruPtr_pYcbcrConversion_Used; + VkSamplerYcbcrConversion const* ReturnThruPtr_pYcbcrConversion_Val; + size_t ReturnThruPtr_pYcbcrConversion_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pYcbcrConversion; + +} CMOCK_vkCreateSamplerYcbcrConversionKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroySamplerYcbcrConversionKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkSamplerYcbcrConversion Expected_ycbcrConversion; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_ycbcrConversion; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroySamplerYcbcrConversionKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkBindBufferMemory2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + uint32_t Expected_bindInfoCount; + const VkBindBufferMemoryInfo* Expected_pBindInfos; + char IgnoreArg_device; + char IgnoreArg_bindInfoCount; + char IgnoreArg_pBindInfos; + +} CMOCK_vkBindBufferMemory2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkBindImageMemory2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + uint32_t Expected_bindInfoCount; + const VkBindImageMemoryInfo* Expected_pBindInfos; + char IgnoreArg_device; + char IgnoreArg_bindInfoCount; + char IgnoreArg_pBindInfos; + +} CMOCK_vkBindImageMemory2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDescriptorSetLayoutSupportKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + const VkDescriptorSetLayoutCreateInfo* Expected_pCreateInfo; + VkDescriptorSetLayoutSupport* Expected_pSupport; + char ReturnThruPtr_pSupport_Used; + VkDescriptorSetLayoutSupport const* ReturnThruPtr_pSupport_Val; + size_t ReturnThruPtr_pSupport_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pSupport; + +} CMOCK_vkGetDescriptorSetLayoutSupportKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDrawIndirectCountKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBuffer Expected_buffer; + VkDeviceSize Expected_offset; + VkBuffer Expected_countBuffer; + VkDeviceSize Expected_countBufferOffset; + uint32_t Expected_maxDrawCount; + uint32_t Expected_stride; + char IgnoreArg_commandBuffer; + char IgnoreArg_buffer; + char IgnoreArg_offset; + char IgnoreArg_countBuffer; + char IgnoreArg_countBufferOffset; + char IgnoreArg_maxDrawCount; + char IgnoreArg_stride; + +} CMOCK_vkCmdDrawIndirectCountKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBuffer Expected_buffer; + VkDeviceSize Expected_offset; + VkBuffer Expected_countBuffer; + VkDeviceSize Expected_countBufferOffset; + uint32_t Expected_maxDrawCount; + uint32_t Expected_stride; + char IgnoreArg_commandBuffer; + char IgnoreArg_buffer; + char IgnoreArg_offset; + char IgnoreArg_countBuffer; + char IgnoreArg_countBufferOffset; + char IgnoreArg_maxDrawCount; + char IgnoreArg_stride; + +} CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetSemaphoreCounterValueKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkSemaphore Expected_semaphore; + uint64_t* Expected_pValue; + char ReturnThruPtr_pValue_Used; + uint64_t const* ReturnThruPtr_pValue_Val; + size_t ReturnThruPtr_pValue_Size; + char IgnoreArg_device; + char IgnoreArg_semaphore; + char IgnoreArg_pValue; + +} CMOCK_vkGetSemaphoreCounterValueKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkWaitSemaphoresKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkSemaphoreWaitInfo* Expected_pWaitInfo; + uint64_t Expected_timeout; + char IgnoreArg_device; + char IgnoreArg_pWaitInfo; + char IgnoreArg_timeout; + +} CMOCK_vkWaitSemaphoresKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkSignalSemaphoreKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkSemaphoreSignalInfo* Expected_pSignalInfo; + char IgnoreArg_device; + char IgnoreArg_pSignalInfo; + +} CMOCK_vkSignalSemaphoreKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + uint32_t* Expected_pFragmentShadingRateCount; + VkPhysicalDeviceFragmentShadingRateKHR* Expected_pFragmentShadingRates; + char ReturnThruPtr_pFragmentShadingRateCount_Used; + uint32_t const* ReturnThruPtr_pFragmentShadingRateCount_Val; + size_t ReturnThruPtr_pFragmentShadingRateCount_Size; + char ReturnThruPtr_pFragmentShadingRates_Used; + VkPhysicalDeviceFragmentShadingRateKHR const* ReturnThruPtr_pFragmentShadingRates_Val; + size_t ReturnThruPtr_pFragmentShadingRates_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pFragmentShadingRateCount; + char IgnoreArg_pFragmentShadingRates; + +} CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetFragmentShadingRateKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkExtent2D* Expected_pFragmentSize; + const VkFragmentShadingRateCombinerOpKHR* Expected_combinerOps; + char IgnoreArg_commandBuffer; + char IgnoreArg_pFragmentSize; + char IgnoreArg_combinerOps; + +} CMOCK_vkCmdSetFragmentShadingRateKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkWaitForPresentKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkSwapchainKHR Expected_swapchain; + uint64_t Expected_presentId; + uint64_t Expected_timeout; + char IgnoreArg_device; + char IgnoreArg_swapchain; + char IgnoreArg_presentId; + char IgnoreArg_timeout; + +} CMOCK_vkWaitForPresentKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetBufferDeviceAddressKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDeviceAddress ReturnVal; + VkDevice Expected_device; + const VkBufferDeviceAddressInfo* Expected_pInfo; + char IgnoreArg_device; + char IgnoreArg_pInfo; + +} CMOCK_vkGetBufferDeviceAddressKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetBufferOpaqueCaptureAddressKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + uint64_t ReturnVal; + VkDevice Expected_device; + const VkBufferDeviceAddressInfo* Expected_pInfo; + char IgnoreArg_device; + char IgnoreArg_pInfo; + +} CMOCK_vkGetBufferOpaqueCaptureAddressKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDeviceMemoryOpaqueCaptureAddressKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + uint64_t ReturnVal; + VkDevice Expected_device; + const VkDeviceMemoryOpaqueCaptureAddressInfo* Expected_pInfo; + char IgnoreArg_device; + char IgnoreArg_pInfo; + +} CMOCK_vkGetDeviceMemoryOpaqueCaptureAddressKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateDeferredOperationKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkAllocationCallbacks* Expected_pAllocator; + VkDeferredOperationKHR* Expected_pDeferredOperation; + char ReturnThruPtr_pDeferredOperation_Used; + VkDeferredOperationKHR const* ReturnThruPtr_pDeferredOperation_Val; + size_t ReturnThruPtr_pDeferredOperation_Size; + char IgnoreArg_device; + char IgnoreArg_pAllocator; + char IgnoreArg_pDeferredOperation; + +} CMOCK_vkCreateDeferredOperationKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyDeferredOperationKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkDeferredOperationKHR Expected_operation; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_operation; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyDeferredOperationKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDeferredOperationMaxConcurrencyKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + uint32_t ReturnVal; + VkDevice Expected_device; + VkDeferredOperationKHR Expected_operation; + char IgnoreArg_device; + char IgnoreArg_operation; + +} CMOCK_vkGetDeferredOperationMaxConcurrencyKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDeferredOperationResultKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkDeferredOperationKHR Expected_operation; + char IgnoreArg_device; + char IgnoreArg_operation; + +} CMOCK_vkGetDeferredOperationResultKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkDeferredOperationJoinKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkDeferredOperationKHR Expected_operation; + char IgnoreArg_device; + char IgnoreArg_operation; + +} CMOCK_vkDeferredOperationJoinKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPipelineExecutablePropertiesKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkPipelineInfoKHR* Expected_pPipelineInfo; + uint32_t* Expected_pExecutableCount; + VkPipelineExecutablePropertiesKHR* Expected_pProperties; + char ReturnThruPtr_pExecutableCount_Used; + uint32_t const* ReturnThruPtr_pExecutableCount_Val; + size_t ReturnThruPtr_pExecutableCount_Size; + char ReturnThruPtr_pProperties_Used; + VkPipelineExecutablePropertiesKHR const* ReturnThruPtr_pProperties_Val; + size_t ReturnThruPtr_pProperties_Size; + char IgnoreArg_device; + char IgnoreArg_pPipelineInfo; + char IgnoreArg_pExecutableCount; + char IgnoreArg_pProperties; + +} CMOCK_vkGetPipelineExecutablePropertiesKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPipelineExecutableStatisticsKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkPipelineExecutableInfoKHR* Expected_pExecutableInfo; + uint32_t* Expected_pStatisticCount; + VkPipelineExecutableStatisticKHR* Expected_pStatistics; + char ReturnThruPtr_pStatisticCount_Used; + uint32_t const* ReturnThruPtr_pStatisticCount_Val; + size_t ReturnThruPtr_pStatisticCount_Size; + char ReturnThruPtr_pStatistics_Used; + VkPipelineExecutableStatisticKHR const* ReturnThruPtr_pStatistics_Val; + size_t ReturnThruPtr_pStatistics_Size; + char IgnoreArg_device; + char IgnoreArg_pExecutableInfo; + char IgnoreArg_pStatisticCount; + char IgnoreArg_pStatistics; + +} CMOCK_vkGetPipelineExecutableStatisticsKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkPipelineExecutableInfoKHR* Expected_pExecutableInfo; + uint32_t* Expected_pInternalRepresentationCount; + VkPipelineExecutableInternalRepresentationKHR* Expected_pInternalRepresentations; + char ReturnThruPtr_pInternalRepresentationCount_Used; + uint32_t const* ReturnThruPtr_pInternalRepresentationCount_Val; + size_t ReturnThruPtr_pInternalRepresentationCount_Size; + char ReturnThruPtr_pInternalRepresentations_Used; + VkPipelineExecutableInternalRepresentationKHR const* ReturnThruPtr_pInternalRepresentations_Val; + size_t ReturnThruPtr_pInternalRepresentations_Size; + char IgnoreArg_device; + char IgnoreArg_pExecutableInfo; + char IgnoreArg_pInternalRepresentationCount; + char IgnoreArg_pInternalRepresentations; + +} CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkMapMemory2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkMemoryMapInfoKHR* Expected_pMemoryMapInfo; + void** Expected_ppData; + char ReturnThruPtr_ppData_Used; + void* const* ReturnThruPtr_ppData_Val; + size_t ReturnThruPtr_ppData_Size; + char IgnoreArg_device; + char IgnoreArg_pMemoryMapInfo; + char IgnoreArg_ppData; + +} CMOCK_vkMapMemory2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkUnmapMemory2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkMemoryUnmapInfoKHR* Expected_pMemoryUnmapInfo; + char IgnoreArg_device; + char IgnoreArg_pMemoryUnmapInfo; + +} CMOCK_vkUnmapMemory2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetEvent2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkEvent Expected_event; + const VkDependencyInfo* Expected_pDependencyInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_event; + char IgnoreArg_pDependencyInfo; + +} CMOCK_vkCmdSetEvent2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdResetEvent2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkEvent Expected_event; + VkPipelineStageFlags2 Expected_stageMask; + char IgnoreArg_commandBuffer; + char IgnoreArg_event; + char IgnoreArg_stageMask; + +} CMOCK_vkCmdResetEvent2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdWaitEvents2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_eventCount; + const VkEvent* Expected_pEvents; + const VkDependencyInfo* Expected_pDependencyInfos; + char IgnoreArg_commandBuffer; + char IgnoreArg_eventCount; + char IgnoreArg_pEvents; + char IgnoreArg_pDependencyInfos; + +} CMOCK_vkCmdWaitEvents2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdPipelineBarrier2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkDependencyInfo* Expected_pDependencyInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pDependencyInfo; + +} CMOCK_vkCmdPipelineBarrier2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdWriteTimestamp2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkPipelineStageFlags2 Expected_stage; + VkQueryPool Expected_queryPool; + uint32_t Expected_query; + char IgnoreArg_commandBuffer; + char IgnoreArg_stage; + char IgnoreArg_queryPool; + char IgnoreArg_query; + +} CMOCK_vkCmdWriteTimestamp2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkQueueSubmit2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkQueue Expected_queue; + uint32_t Expected_submitCount; + const VkSubmitInfo2* Expected_pSubmits; + VkFence Expected_fence; + char IgnoreArg_queue; + char IgnoreArg_submitCount; + char IgnoreArg_pSubmits; + char IgnoreArg_fence; + +} CMOCK_vkQueueSubmit2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdWriteBufferMarker2AMD_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkPipelineStageFlags2 Expected_stage; + VkBuffer Expected_dstBuffer; + VkDeviceSize Expected_dstOffset; + uint32_t Expected_marker; + char IgnoreArg_commandBuffer; + char IgnoreArg_stage; + char IgnoreArg_dstBuffer; + char IgnoreArg_dstOffset; + char IgnoreArg_marker; + +} CMOCK_vkCmdWriteBufferMarker2AMD_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetQueueCheckpointData2NV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkQueue Expected_queue; + uint32_t* Expected_pCheckpointDataCount; + VkCheckpointData2NV* Expected_pCheckpointData; + char ReturnThruPtr_pCheckpointDataCount_Used; + uint32_t const* ReturnThruPtr_pCheckpointDataCount_Val; + size_t ReturnThruPtr_pCheckpointDataCount_Size; + char ReturnThruPtr_pCheckpointData_Used; + VkCheckpointData2NV const* ReturnThruPtr_pCheckpointData_Val; + size_t ReturnThruPtr_pCheckpointData_Size; + char IgnoreArg_queue; + char IgnoreArg_pCheckpointDataCount; + char IgnoreArg_pCheckpointData; + +} CMOCK_vkGetQueueCheckpointData2NV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdCopyBuffer2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkCopyBufferInfo2* Expected_pCopyBufferInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pCopyBufferInfo; + +} CMOCK_vkCmdCopyBuffer2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdCopyImage2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkCopyImageInfo2* Expected_pCopyImageInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pCopyImageInfo; + +} CMOCK_vkCmdCopyImage2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdCopyBufferToImage2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkCopyBufferToImageInfo2* Expected_pCopyBufferToImageInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pCopyBufferToImageInfo; + +} CMOCK_vkCmdCopyBufferToImage2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdCopyImageToBuffer2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkCopyImageToBufferInfo2* Expected_pCopyImageToBufferInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pCopyImageToBufferInfo; + +} CMOCK_vkCmdCopyImageToBuffer2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBlitImage2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkBlitImageInfo2* Expected_pBlitImageInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pBlitImageInfo; + +} CMOCK_vkCmdBlitImage2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdResolveImage2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkResolveImageInfo2* Expected_pResolveImageInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pResolveImageInfo; + +} CMOCK_vkCmdResolveImage2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdTraceRaysIndirect2KHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkDeviceAddress Expected_indirectDeviceAddress; + char IgnoreArg_commandBuffer; + char IgnoreArg_indirectDeviceAddress; + +} CMOCK_vkCmdTraceRaysIndirect2KHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDeviceBufferMemoryRequirementsKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + const VkDeviceBufferMemoryRequirements* Expected_pInfo; + VkMemoryRequirements2* Expected_pMemoryRequirements; + char ReturnThruPtr_pMemoryRequirements_Used; + VkMemoryRequirements2 const* ReturnThruPtr_pMemoryRequirements_Val; + size_t ReturnThruPtr_pMemoryRequirements_Size; + char IgnoreArg_device; + char IgnoreArg_pInfo; + char IgnoreArg_pMemoryRequirements; + +} CMOCK_vkGetDeviceBufferMemoryRequirementsKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDeviceImageMemoryRequirementsKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + const VkDeviceImageMemoryRequirements* Expected_pInfo; + VkMemoryRequirements2* Expected_pMemoryRequirements; + char ReturnThruPtr_pMemoryRequirements_Used; + VkMemoryRequirements2 const* ReturnThruPtr_pMemoryRequirements_Val; + size_t ReturnThruPtr_pMemoryRequirements_Size; + char IgnoreArg_device; + char IgnoreArg_pInfo; + char IgnoreArg_pMemoryRequirements; + +} CMOCK_vkGetDeviceImageMemoryRequirementsKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDeviceImageSparseMemoryRequirementsKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + const VkDeviceImageMemoryRequirements* Expected_pInfo; + uint32_t* Expected_pSparseMemoryRequirementCount; + VkSparseImageMemoryRequirements2* Expected_pSparseMemoryRequirements; + char ReturnThruPtr_pSparseMemoryRequirementCount_Used; + uint32_t const* ReturnThruPtr_pSparseMemoryRequirementCount_Val; + size_t ReturnThruPtr_pSparseMemoryRequirementCount_Size; + char ReturnThruPtr_pSparseMemoryRequirements_Used; + VkSparseImageMemoryRequirements2 const* ReturnThruPtr_pSparseMemoryRequirements_Val; + size_t ReturnThruPtr_pSparseMemoryRequirements_Size; + char IgnoreArg_device; + char IgnoreArg_pInfo; + char IgnoreArg_pSparseMemoryRequirementCount; + char IgnoreArg_pSparseMemoryRequirements; + +} CMOCK_vkGetDeviceImageSparseMemoryRequirementsKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateDebugReportCallbackEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkInstance Expected_instance; + const VkDebugReportCallbackCreateInfoEXT* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkDebugReportCallbackEXT* Expected_pCallback; + char ReturnThruPtr_pCallback_Used; + VkDebugReportCallbackEXT const* ReturnThruPtr_pCallback_Val; + size_t ReturnThruPtr_pCallback_Size; + char IgnoreArg_instance; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pCallback; + +} CMOCK_vkCreateDebugReportCallbackEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyDebugReportCallbackEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkInstance Expected_instance; + VkDebugReportCallbackEXT Expected_callback; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_instance; + char IgnoreArg_callback; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyDebugReportCallbackEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkDebugReportMessageEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkInstance Expected_instance; + VkDebugReportFlagsEXT Expected_flags; + VkDebugReportObjectTypeEXT Expected_objectType; + uint64_t Expected_object; + size_t Expected_location; + int32_t Expected_messageCode; + const char* Expected_pLayerPrefix; + const char* Expected_pMessage; + char IgnoreArg_instance; + char IgnoreArg_flags; + char IgnoreArg_objectType; + char IgnoreArg_object; + char IgnoreArg_location; + char IgnoreArg_messageCode; + char IgnoreArg_pLayerPrefix; + char IgnoreArg_pMessage; + +} CMOCK_vkDebugReportMessageEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkDebugMarkerSetObjectTagEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkDebugMarkerObjectTagInfoEXT* Expected_pTagInfo; + char IgnoreArg_device; + char IgnoreArg_pTagInfo; + +} CMOCK_vkDebugMarkerSetObjectTagEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkDebugMarkerSetObjectNameEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkDebugMarkerObjectNameInfoEXT* Expected_pNameInfo; + char IgnoreArg_device; + char IgnoreArg_pNameInfo; + +} CMOCK_vkDebugMarkerSetObjectNameEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDebugMarkerBeginEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkDebugMarkerMarkerInfoEXT* Expected_pMarkerInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pMarkerInfo; + +} CMOCK_vkCmdDebugMarkerBeginEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDebugMarkerEndEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + char IgnoreArg_commandBuffer; + +} CMOCK_vkCmdDebugMarkerEndEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDebugMarkerInsertEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkDebugMarkerMarkerInfoEXT* Expected_pMarkerInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pMarkerInfo; + +} CMOCK_vkCmdDebugMarkerInsertEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBindTransformFeedbackBuffersEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_firstBinding; + uint32_t Expected_bindingCount; + const VkBuffer* Expected_pBuffers; + const VkDeviceSize* Expected_pOffsets; + const VkDeviceSize* Expected_pSizes; + char IgnoreArg_commandBuffer; + char IgnoreArg_firstBinding; + char IgnoreArg_bindingCount; + char IgnoreArg_pBuffers; + char IgnoreArg_pOffsets; + char IgnoreArg_pSizes; + +} CMOCK_vkCmdBindTransformFeedbackBuffersEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBeginTransformFeedbackEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_firstCounterBuffer; + uint32_t Expected_counterBufferCount; + const VkBuffer* Expected_pCounterBuffers; + const VkDeviceSize* Expected_pCounterBufferOffsets; + char IgnoreArg_commandBuffer; + char IgnoreArg_firstCounterBuffer; + char IgnoreArg_counterBufferCount; + char IgnoreArg_pCounterBuffers; + char IgnoreArg_pCounterBufferOffsets; + +} CMOCK_vkCmdBeginTransformFeedbackEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdEndTransformFeedbackEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_firstCounterBuffer; + uint32_t Expected_counterBufferCount; + const VkBuffer* Expected_pCounterBuffers; + const VkDeviceSize* Expected_pCounterBufferOffsets; + char IgnoreArg_commandBuffer; + char IgnoreArg_firstCounterBuffer; + char IgnoreArg_counterBufferCount; + char IgnoreArg_pCounterBuffers; + char IgnoreArg_pCounterBufferOffsets; + +} CMOCK_vkCmdEndTransformFeedbackEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBeginQueryIndexedEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkQueryPool Expected_queryPool; + uint32_t Expected_query; + VkQueryControlFlags Expected_flags; + uint32_t Expected_index; + char IgnoreArg_commandBuffer; + char IgnoreArg_queryPool; + char IgnoreArg_query; + char IgnoreArg_flags; + char IgnoreArg_index; + +} CMOCK_vkCmdBeginQueryIndexedEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdEndQueryIndexedEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkQueryPool Expected_queryPool; + uint32_t Expected_query; + uint32_t Expected_index; + char IgnoreArg_commandBuffer; + char IgnoreArg_queryPool; + char IgnoreArg_query; + char IgnoreArg_index; + +} CMOCK_vkCmdEndQueryIndexedEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDrawIndirectByteCountEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_instanceCount; + uint32_t Expected_firstInstance; + VkBuffer Expected_counterBuffer; + VkDeviceSize Expected_counterBufferOffset; + uint32_t Expected_counterOffset; + uint32_t Expected_vertexStride; + char IgnoreArg_commandBuffer; + char IgnoreArg_instanceCount; + char IgnoreArg_firstInstance; + char IgnoreArg_counterBuffer; + char IgnoreArg_counterBufferOffset; + char IgnoreArg_counterOffset; + char IgnoreArg_vertexStride; + +} CMOCK_vkCmdDrawIndirectByteCountEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateCuModuleNVX_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkCuModuleCreateInfoNVX* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkCuModuleNVX* Expected_pModule; + char ReturnThruPtr_pModule_Used; + VkCuModuleNVX const* ReturnThruPtr_pModule_Val; + size_t ReturnThruPtr_pModule_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pModule; + +} CMOCK_vkCreateCuModuleNVX_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateCuFunctionNVX_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkCuFunctionCreateInfoNVX* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkCuFunctionNVX* Expected_pFunction; + char ReturnThruPtr_pFunction_Used; + VkCuFunctionNVX const* ReturnThruPtr_pFunction_Val; + size_t ReturnThruPtr_pFunction_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pFunction; + +} CMOCK_vkCreateCuFunctionNVX_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyCuModuleNVX_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkCuModuleNVX Expected_module; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_module; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyCuModuleNVX_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyCuFunctionNVX_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkCuFunctionNVX Expected_function; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_function; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyCuFunctionNVX_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdCuLaunchKernelNVX_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkCuLaunchInfoNVX* Expected_pLaunchInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pLaunchInfo; + +} CMOCK_vkCmdCuLaunchKernelNVX_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetImageViewHandleNVX_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + uint32_t ReturnVal; + VkDevice Expected_device; + const VkImageViewHandleInfoNVX* Expected_pInfo; + char IgnoreArg_device; + char IgnoreArg_pInfo; + +} CMOCK_vkGetImageViewHandleNVX_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetImageViewAddressNVX_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkImageView Expected_imageView; + VkImageViewAddressPropertiesNVX* Expected_pProperties; + char ReturnThruPtr_pProperties_Used; + VkImageViewAddressPropertiesNVX const* ReturnThruPtr_pProperties_Val; + size_t ReturnThruPtr_pProperties_Size; + char IgnoreArg_device; + char IgnoreArg_imageView; + char IgnoreArg_pProperties; + +} CMOCK_vkGetImageViewAddressNVX_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDrawIndirectCountAMD_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBuffer Expected_buffer; + VkDeviceSize Expected_offset; + VkBuffer Expected_countBuffer; + VkDeviceSize Expected_countBufferOffset; + uint32_t Expected_maxDrawCount; + uint32_t Expected_stride; + char IgnoreArg_commandBuffer; + char IgnoreArg_buffer; + char IgnoreArg_offset; + char IgnoreArg_countBuffer; + char IgnoreArg_countBufferOffset; + char IgnoreArg_maxDrawCount; + char IgnoreArg_stride; + +} CMOCK_vkCmdDrawIndirectCountAMD_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBuffer Expected_buffer; + VkDeviceSize Expected_offset; + VkBuffer Expected_countBuffer; + VkDeviceSize Expected_countBufferOffset; + uint32_t Expected_maxDrawCount; + uint32_t Expected_stride; + char IgnoreArg_commandBuffer; + char IgnoreArg_buffer; + char IgnoreArg_offset; + char IgnoreArg_countBuffer; + char IgnoreArg_countBufferOffset; + char IgnoreArg_maxDrawCount; + char IgnoreArg_stride; + +} CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkPipeline Expected_pipeline; + VkShaderStageFlagBits Expected_shaderStage; + VkShaderInfoTypeAMD Expected_infoType; + size_t* Expected_pInfoSize; + void* Expected_pInfo; + char ReturnThruPtr_pInfoSize_Used; + size_t const* ReturnThruPtr_pInfoSize_Val; + size_t ReturnThruPtr_pInfoSize_Size; + char ReturnThruPtr_pInfo_Used; + void const* ReturnThruPtr_pInfo_Val; + size_t ReturnThruPtr_pInfo_Size; + char IgnoreArg_device; + char IgnoreArg_pipeline; + char IgnoreArg_shaderStage; + char IgnoreArg_infoType; + char IgnoreArg_pInfoSize; + char IgnoreArg_pInfo; + +} CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + VkFormat Expected_format; + VkImageType Expected_type; + VkImageTiling Expected_tiling; + VkImageUsageFlags Expected_usage; + VkImageCreateFlags Expected_flags; + VkExternalMemoryHandleTypeFlagsNV Expected_externalHandleType; + VkExternalImageFormatPropertiesNV* Expected_pExternalImageFormatProperties; + char ReturnThruPtr_pExternalImageFormatProperties_Used; + VkExternalImageFormatPropertiesNV const* ReturnThruPtr_pExternalImageFormatProperties_Val; + size_t ReturnThruPtr_pExternalImageFormatProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_format; + char IgnoreArg_type; + char IgnoreArg_tiling; + char IgnoreArg_usage; + char IgnoreArg_flags; + char IgnoreArg_externalHandleType; + char IgnoreArg_pExternalImageFormatProperties; + +} CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBeginConditionalRenderingEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkConditionalRenderingBeginInfoEXT* Expected_pConditionalRenderingBegin; + char IgnoreArg_commandBuffer; + char IgnoreArg_pConditionalRenderingBegin; + +} CMOCK_vkCmdBeginConditionalRenderingEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdEndConditionalRenderingEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + char IgnoreArg_commandBuffer; + +} CMOCK_vkCmdEndConditionalRenderingEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetViewportWScalingNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_firstViewport; + uint32_t Expected_viewportCount; + const VkViewportWScalingNV* Expected_pViewportWScalings; + char IgnoreArg_commandBuffer; + char IgnoreArg_firstViewport; + char IgnoreArg_viewportCount; + char IgnoreArg_pViewportWScalings; + +} CMOCK_vkCmdSetViewportWScalingNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkReleaseDisplayEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + VkDisplayKHR Expected_display; + char IgnoreArg_physicalDevice; + char IgnoreArg_display; + +} CMOCK_vkReleaseDisplayEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2EXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + VkSurfaceKHR Expected_surface; + VkSurfaceCapabilities2EXT* Expected_pSurfaceCapabilities; + char ReturnThruPtr_pSurfaceCapabilities_Used; + VkSurfaceCapabilities2EXT const* ReturnThruPtr_pSurfaceCapabilities_Val; + size_t ReturnThruPtr_pSurfaceCapabilities_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_surface; + char IgnoreArg_pSurfaceCapabilities; + +} CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2EXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkDisplayPowerControlEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkDisplayKHR Expected_display; + const VkDisplayPowerInfoEXT* Expected_pDisplayPowerInfo; + char IgnoreArg_device; + char IgnoreArg_display; + char IgnoreArg_pDisplayPowerInfo; + +} CMOCK_vkDisplayPowerControlEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkRegisterDeviceEventEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkDeviceEventInfoEXT* Expected_pDeviceEventInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkFence* Expected_pFence; + char ReturnThruPtr_pFence_Used; + VkFence const* ReturnThruPtr_pFence_Val; + size_t ReturnThruPtr_pFence_Size; + char IgnoreArg_device; + char IgnoreArg_pDeviceEventInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pFence; + +} CMOCK_vkRegisterDeviceEventEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkRegisterDisplayEventEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkDisplayKHR Expected_display; + const VkDisplayEventInfoEXT* Expected_pDisplayEventInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkFence* Expected_pFence; + char ReturnThruPtr_pFence_Used; + VkFence const* ReturnThruPtr_pFence_Val; + size_t ReturnThruPtr_pFence_Size; + char IgnoreArg_device; + char IgnoreArg_display; + char IgnoreArg_pDisplayEventInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pFence; + +} CMOCK_vkRegisterDisplayEventEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetSwapchainCounterEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkSwapchainKHR Expected_swapchain; + VkSurfaceCounterFlagBitsEXT Expected_counter; + uint64_t* Expected_pCounterValue; + char ReturnThruPtr_pCounterValue_Used; + uint64_t const* ReturnThruPtr_pCounterValue_Val; + size_t ReturnThruPtr_pCounterValue_Size; + char IgnoreArg_device; + char IgnoreArg_swapchain; + char IgnoreArg_counter; + char IgnoreArg_pCounterValue; + +} CMOCK_vkGetSwapchainCounterEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetRefreshCycleDurationGOOGLE_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkSwapchainKHR Expected_swapchain; + VkRefreshCycleDurationGOOGLE* Expected_pDisplayTimingProperties; + char ReturnThruPtr_pDisplayTimingProperties_Used; + VkRefreshCycleDurationGOOGLE const* ReturnThruPtr_pDisplayTimingProperties_Val; + size_t ReturnThruPtr_pDisplayTimingProperties_Size; + char IgnoreArg_device; + char IgnoreArg_swapchain; + char IgnoreArg_pDisplayTimingProperties; + +} CMOCK_vkGetRefreshCycleDurationGOOGLE_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPastPresentationTimingGOOGLE_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkSwapchainKHR Expected_swapchain; + uint32_t* Expected_pPresentationTimingCount; + VkPastPresentationTimingGOOGLE* Expected_pPresentationTimings; + char ReturnThruPtr_pPresentationTimingCount_Used; + uint32_t const* ReturnThruPtr_pPresentationTimingCount_Val; + size_t ReturnThruPtr_pPresentationTimingCount_Size; + char ReturnThruPtr_pPresentationTimings_Used; + VkPastPresentationTimingGOOGLE const* ReturnThruPtr_pPresentationTimings_Val; + size_t ReturnThruPtr_pPresentationTimings_Size; + char IgnoreArg_device; + char IgnoreArg_swapchain; + char IgnoreArg_pPresentationTimingCount; + char IgnoreArg_pPresentationTimings; + +} CMOCK_vkGetPastPresentationTimingGOOGLE_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetDiscardRectangleEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_firstDiscardRectangle; + uint32_t Expected_discardRectangleCount; + const VkRect2D* Expected_pDiscardRectangles; + char IgnoreArg_commandBuffer; + char IgnoreArg_firstDiscardRectangle; + char IgnoreArg_discardRectangleCount; + char IgnoreArg_pDiscardRectangles; + +} CMOCK_vkCmdSetDiscardRectangleEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetDiscardRectangleEnableEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBool32 Expected_discardRectangleEnable; + char IgnoreArg_commandBuffer; + char IgnoreArg_discardRectangleEnable; + +} CMOCK_vkCmdSetDiscardRectangleEnableEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetDiscardRectangleModeEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkDiscardRectangleModeEXT Expected_discardRectangleMode; + char IgnoreArg_commandBuffer; + char IgnoreArg_discardRectangleMode; + +} CMOCK_vkCmdSetDiscardRectangleModeEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkSetHdrMetadataEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + uint32_t Expected_swapchainCount; + const VkSwapchainKHR* Expected_pSwapchains; + const VkHdrMetadataEXT* Expected_pMetadata; + char IgnoreArg_device; + char IgnoreArg_swapchainCount; + char IgnoreArg_pSwapchains; + char IgnoreArg_pMetadata; + +} CMOCK_vkSetHdrMetadataEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkSetDebugUtilsObjectNameEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkDebugUtilsObjectNameInfoEXT* Expected_pNameInfo; + char IgnoreArg_device; + char IgnoreArg_pNameInfo; + +} CMOCK_vkSetDebugUtilsObjectNameEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkSetDebugUtilsObjectTagEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkDebugUtilsObjectTagInfoEXT* Expected_pTagInfo; + char IgnoreArg_device; + char IgnoreArg_pTagInfo; + +} CMOCK_vkSetDebugUtilsObjectTagEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkQueueBeginDebugUtilsLabelEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkQueue Expected_queue; + const VkDebugUtilsLabelEXT* Expected_pLabelInfo; + char IgnoreArg_queue; + char IgnoreArg_pLabelInfo; + +} CMOCK_vkQueueBeginDebugUtilsLabelEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkQueueEndDebugUtilsLabelEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkQueue Expected_queue; + char IgnoreArg_queue; + +} CMOCK_vkQueueEndDebugUtilsLabelEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkQueueInsertDebugUtilsLabelEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkQueue Expected_queue; + const VkDebugUtilsLabelEXT* Expected_pLabelInfo; + char IgnoreArg_queue; + char IgnoreArg_pLabelInfo; + +} CMOCK_vkQueueInsertDebugUtilsLabelEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBeginDebugUtilsLabelEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkDebugUtilsLabelEXT* Expected_pLabelInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pLabelInfo; + +} CMOCK_vkCmdBeginDebugUtilsLabelEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdEndDebugUtilsLabelEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + char IgnoreArg_commandBuffer; + +} CMOCK_vkCmdEndDebugUtilsLabelEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdInsertDebugUtilsLabelEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkDebugUtilsLabelEXT* Expected_pLabelInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pLabelInfo; + +} CMOCK_vkCmdInsertDebugUtilsLabelEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateDebugUtilsMessengerEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkInstance Expected_instance; + const VkDebugUtilsMessengerCreateInfoEXT* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkDebugUtilsMessengerEXT* Expected_pMessenger; + char ReturnThruPtr_pMessenger_Used; + VkDebugUtilsMessengerEXT const* ReturnThruPtr_pMessenger_Val; + size_t ReturnThruPtr_pMessenger_Size; + char IgnoreArg_instance; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pMessenger; + +} CMOCK_vkCreateDebugUtilsMessengerEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyDebugUtilsMessengerEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkInstance Expected_instance; + VkDebugUtilsMessengerEXT Expected_messenger; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_instance; + char IgnoreArg_messenger; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyDebugUtilsMessengerEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkSubmitDebugUtilsMessageEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkInstance Expected_instance; + VkDebugUtilsMessageSeverityFlagBitsEXT Expected_messageSeverity; + VkDebugUtilsMessageTypeFlagsEXT Expected_messageTypes; + const VkDebugUtilsMessengerCallbackDataEXT* Expected_pCallbackData; + char IgnoreArg_instance; + char IgnoreArg_messageSeverity; + char IgnoreArg_messageTypes; + char IgnoreArg_pCallbackData; + +} CMOCK_vkSubmitDebugUtilsMessageEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetSampleLocationsEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkSampleLocationsInfoEXT* Expected_pSampleLocationsInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pSampleLocationsInfo; + +} CMOCK_vkCmdSetSampleLocationsEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceMultisamplePropertiesEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkPhysicalDevice Expected_physicalDevice; + VkSampleCountFlagBits Expected_samples; + VkMultisamplePropertiesEXT* Expected_pMultisampleProperties; + char ReturnThruPtr_pMultisampleProperties_Used; + VkMultisamplePropertiesEXT const* ReturnThruPtr_pMultisampleProperties_Val; + size_t ReturnThruPtr_pMultisampleProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_samples; + char IgnoreArg_pMultisampleProperties; + +} CMOCK_vkGetPhysicalDeviceMultisamplePropertiesEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetImageDrmFormatModifierPropertiesEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkImage Expected_image; + VkImageDrmFormatModifierPropertiesEXT* Expected_pProperties; + char ReturnThruPtr_pProperties_Used; + VkImageDrmFormatModifierPropertiesEXT const* ReturnThruPtr_pProperties_Val; + size_t ReturnThruPtr_pProperties_Size; + char IgnoreArg_device; + char IgnoreArg_image; + char IgnoreArg_pProperties; + +} CMOCK_vkGetImageDrmFormatModifierPropertiesEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateValidationCacheEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkValidationCacheCreateInfoEXT* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkValidationCacheEXT* Expected_pValidationCache; + char ReturnThruPtr_pValidationCache_Used; + VkValidationCacheEXT const* ReturnThruPtr_pValidationCache_Val; + size_t ReturnThruPtr_pValidationCache_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pValidationCache; + +} CMOCK_vkCreateValidationCacheEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyValidationCacheEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkValidationCacheEXT Expected_validationCache; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_validationCache; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyValidationCacheEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkMergeValidationCachesEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkValidationCacheEXT Expected_dstCache; + uint32_t Expected_srcCacheCount; + const VkValidationCacheEXT* Expected_pSrcCaches; + char IgnoreArg_device; + char IgnoreArg_dstCache; + char IgnoreArg_srcCacheCount; + char IgnoreArg_pSrcCaches; + +} CMOCK_vkMergeValidationCachesEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetValidationCacheDataEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkValidationCacheEXT Expected_validationCache; + size_t* Expected_pDataSize; + void* Expected_pData; + char ReturnThruPtr_pDataSize_Used; + size_t const* ReturnThruPtr_pDataSize_Val; + size_t ReturnThruPtr_pDataSize_Size; + char ReturnThruPtr_pData_Used; + void const* ReturnThruPtr_pData_Val; + size_t ReturnThruPtr_pData_Size; + char IgnoreArg_device; + char IgnoreArg_validationCache; + char IgnoreArg_pDataSize; + char IgnoreArg_pData; + +} CMOCK_vkGetValidationCacheDataEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBindShadingRateImageNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkImageView Expected_imageView; + VkImageLayout Expected_imageLayout; + char IgnoreArg_commandBuffer; + char IgnoreArg_imageView; + char IgnoreArg_imageLayout; + +} CMOCK_vkCmdBindShadingRateImageNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetViewportShadingRatePaletteNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_firstViewport; + uint32_t Expected_viewportCount; + const VkShadingRatePaletteNV* Expected_pShadingRatePalettes; + char IgnoreArg_commandBuffer; + char IgnoreArg_firstViewport; + char IgnoreArg_viewportCount; + char IgnoreArg_pShadingRatePalettes; + +} CMOCK_vkCmdSetViewportShadingRatePaletteNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetCoarseSampleOrderNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkCoarseSampleOrderTypeNV Expected_sampleOrderType; + uint32_t Expected_customSampleOrderCount; + const VkCoarseSampleOrderCustomNV* Expected_pCustomSampleOrders; + char IgnoreArg_commandBuffer; + char IgnoreArg_sampleOrderType; + char IgnoreArg_customSampleOrderCount; + char IgnoreArg_pCustomSampleOrders; + +} CMOCK_vkCmdSetCoarseSampleOrderNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateAccelerationStructureNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkAccelerationStructureCreateInfoNV* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkAccelerationStructureNV* Expected_pAccelerationStructure; + char ReturnThruPtr_pAccelerationStructure_Used; + VkAccelerationStructureNV const* ReturnThruPtr_pAccelerationStructure_Val; + size_t ReturnThruPtr_pAccelerationStructure_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pAccelerationStructure; + +} CMOCK_vkCreateAccelerationStructureNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyAccelerationStructureNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkAccelerationStructureNV Expected_accelerationStructure; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_accelerationStructure; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyAccelerationStructureNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetAccelerationStructureMemoryRequirementsNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + const VkAccelerationStructureMemoryRequirementsInfoNV* Expected_pInfo; + VkMemoryRequirements2KHR* Expected_pMemoryRequirements; + char ReturnThruPtr_pMemoryRequirements_Used; + VkMemoryRequirements2KHR const* ReturnThruPtr_pMemoryRequirements_Val; + size_t ReturnThruPtr_pMemoryRequirements_Size; + char IgnoreArg_device; + char IgnoreArg_pInfo; + char IgnoreArg_pMemoryRequirements; + +} CMOCK_vkGetAccelerationStructureMemoryRequirementsNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkBindAccelerationStructureMemoryNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + uint32_t Expected_bindInfoCount; + const VkBindAccelerationStructureMemoryInfoNV* Expected_pBindInfos; + char IgnoreArg_device; + char IgnoreArg_bindInfoCount; + char IgnoreArg_pBindInfos; + +} CMOCK_vkBindAccelerationStructureMemoryNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBuildAccelerationStructureNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkAccelerationStructureInfoNV* Expected_pInfo; + VkBuffer Expected_instanceData; + VkDeviceSize Expected_instanceOffset; + VkBool32 Expected_update; + VkAccelerationStructureNV Expected_dst; + VkAccelerationStructureNV Expected_src; + VkBuffer Expected_scratch; + VkDeviceSize Expected_scratchOffset; + char IgnoreArg_commandBuffer; + char IgnoreArg_pInfo; + char IgnoreArg_instanceData; + char IgnoreArg_instanceOffset; + char IgnoreArg_update; + char IgnoreArg_dst; + char IgnoreArg_src; + char IgnoreArg_scratch; + char IgnoreArg_scratchOffset; + +} CMOCK_vkCmdBuildAccelerationStructureNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdCopyAccelerationStructureNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkAccelerationStructureNV Expected_dst; + VkAccelerationStructureNV Expected_src; + VkCopyAccelerationStructureModeKHR Expected_mode; + char IgnoreArg_commandBuffer; + char IgnoreArg_dst; + char IgnoreArg_src; + char IgnoreArg_mode; + +} CMOCK_vkCmdCopyAccelerationStructureNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBuffer Expected_raygenShaderBindingTableBuffer; + VkDeviceSize Expected_raygenShaderBindingOffset; + VkBuffer Expected_missShaderBindingTableBuffer; + VkDeviceSize Expected_missShaderBindingOffset; + VkDeviceSize Expected_missShaderBindingStride; + VkBuffer Expected_hitShaderBindingTableBuffer; + VkDeviceSize Expected_hitShaderBindingOffset; + VkDeviceSize Expected_hitShaderBindingStride; + VkBuffer Expected_callableShaderBindingTableBuffer; + VkDeviceSize Expected_callableShaderBindingOffset; + VkDeviceSize Expected_callableShaderBindingStride; + uint32_t Expected_width; + uint32_t Expected_height; + uint32_t Expected_depth; + char IgnoreArg_commandBuffer; + char IgnoreArg_raygenShaderBindingTableBuffer; + char IgnoreArg_raygenShaderBindingOffset; + char IgnoreArg_missShaderBindingTableBuffer; + char IgnoreArg_missShaderBindingOffset; + char IgnoreArg_missShaderBindingStride; + char IgnoreArg_hitShaderBindingTableBuffer; + char IgnoreArg_hitShaderBindingOffset; + char IgnoreArg_hitShaderBindingStride; + char IgnoreArg_callableShaderBindingTableBuffer; + char IgnoreArg_callableShaderBindingOffset; + char IgnoreArg_callableShaderBindingStride; + char IgnoreArg_width; + char IgnoreArg_height; + char IgnoreArg_depth; + +} CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateRayTracingPipelinesNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkPipelineCache Expected_pipelineCache; + uint32_t Expected_createInfoCount; + const VkRayTracingPipelineCreateInfoNV* Expected_pCreateInfos; + const VkAllocationCallbacks* Expected_pAllocator; + VkPipeline* Expected_pPipelines; + char ReturnThruPtr_pPipelines_Used; + VkPipeline const* ReturnThruPtr_pPipelines_Val; + size_t ReturnThruPtr_pPipelines_Size; + char IgnoreArg_device; + char IgnoreArg_pipelineCache; + char IgnoreArg_createInfoCount; + char IgnoreArg_pCreateInfos; + char IgnoreArg_pAllocator; + char IgnoreArg_pPipelines; + +} CMOCK_vkCreateRayTracingPipelinesNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkPipeline Expected_pipeline; + uint32_t Expected_firstGroup; + uint32_t Expected_groupCount; + size_t Expected_dataSize; + void* Expected_pData; + char ReturnThruPtr_pData_Used; + void const* ReturnThruPtr_pData_Val; + size_t ReturnThruPtr_pData_Size; + char IgnoreArg_device; + char IgnoreArg_pipeline; + char IgnoreArg_firstGroup; + char IgnoreArg_groupCount; + char IgnoreArg_dataSize; + char IgnoreArg_pData; + +} CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkPipeline Expected_pipeline; + uint32_t Expected_firstGroup; + uint32_t Expected_groupCount; + size_t Expected_dataSize; + void* Expected_pData; + char ReturnThruPtr_pData_Used; + void const* ReturnThruPtr_pData_Val; + size_t ReturnThruPtr_pData_Size; + char IgnoreArg_device; + char IgnoreArg_pipeline; + char IgnoreArg_firstGroup; + char IgnoreArg_groupCount; + char IgnoreArg_dataSize; + char IgnoreArg_pData; + +} CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetAccelerationStructureHandleNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkAccelerationStructureNV Expected_accelerationStructure; + size_t Expected_dataSize; + void* Expected_pData; + char ReturnThruPtr_pData_Used; + void const* ReturnThruPtr_pData_Val; + size_t ReturnThruPtr_pData_Size; + char IgnoreArg_device; + char IgnoreArg_accelerationStructure; + char IgnoreArg_dataSize; + char IgnoreArg_pData; + +} CMOCK_vkGetAccelerationStructureHandleNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdWriteAccelerationStructuresPropertiesNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_accelerationStructureCount; + const VkAccelerationStructureNV* Expected_pAccelerationStructures; + VkQueryType Expected_queryType; + VkQueryPool Expected_queryPool; + uint32_t Expected_firstQuery; + char IgnoreArg_commandBuffer; + char IgnoreArg_accelerationStructureCount; + char IgnoreArg_pAccelerationStructures; + char IgnoreArg_queryType; + char IgnoreArg_queryPool; + char IgnoreArg_firstQuery; + +} CMOCK_vkCmdWriteAccelerationStructuresPropertiesNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCompileDeferredNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkPipeline Expected_pipeline; + uint32_t Expected_shader; + char IgnoreArg_device; + char IgnoreArg_pipeline; + char IgnoreArg_shader; + +} CMOCK_vkCompileDeferredNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkExternalMemoryHandleTypeFlagBits Expected_handleType; + const void* Expected_pHostPointer; + VkMemoryHostPointerPropertiesEXT* Expected_pMemoryHostPointerProperties; + char ReturnThruPtr_pMemoryHostPointerProperties_Used; + VkMemoryHostPointerPropertiesEXT const* ReturnThruPtr_pMemoryHostPointerProperties_Val; + size_t ReturnThruPtr_pMemoryHostPointerProperties_Size; + char IgnoreArg_device; + char IgnoreArg_handleType; + char IgnoreArg_pHostPointer; + char IgnoreArg_pMemoryHostPointerProperties; + +} CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdWriteBufferMarkerAMD_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkPipelineStageFlagBits Expected_pipelineStage; + VkBuffer Expected_dstBuffer; + VkDeviceSize Expected_dstOffset; + uint32_t Expected_marker; + char IgnoreArg_commandBuffer; + char IgnoreArg_pipelineStage; + char IgnoreArg_dstBuffer; + char IgnoreArg_dstOffset; + char IgnoreArg_marker; + +} CMOCK_vkCmdWriteBufferMarkerAMD_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + uint32_t* Expected_pTimeDomainCount; + VkTimeDomainEXT* Expected_pTimeDomains; + char ReturnThruPtr_pTimeDomainCount_Used; + uint32_t const* ReturnThruPtr_pTimeDomainCount_Val; + size_t ReturnThruPtr_pTimeDomainCount_Size; + char ReturnThruPtr_pTimeDomains_Used; + VkTimeDomainEXT const* ReturnThruPtr_pTimeDomains_Val; + size_t ReturnThruPtr_pTimeDomains_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pTimeDomainCount; + char IgnoreArg_pTimeDomains; + +} CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetCalibratedTimestampsEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + uint32_t Expected_timestampCount; + const VkCalibratedTimestampInfoEXT* Expected_pTimestampInfos; + uint64_t* Expected_pTimestamps; + uint64_t* Expected_pMaxDeviation; + char ReturnThruPtr_pTimestamps_Used; + uint64_t const* ReturnThruPtr_pTimestamps_Val; + size_t ReturnThruPtr_pTimestamps_Size; + char ReturnThruPtr_pMaxDeviation_Used; + uint64_t const* ReturnThruPtr_pMaxDeviation_Val; + size_t ReturnThruPtr_pMaxDeviation_Size; + char IgnoreArg_device; + char IgnoreArg_timestampCount; + char IgnoreArg_pTimestampInfos; + char IgnoreArg_pTimestamps; + char IgnoreArg_pMaxDeviation; + +} CMOCK_vkGetCalibratedTimestampsEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDrawMeshTasksNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_taskCount; + uint32_t Expected_firstTask; + char IgnoreArg_commandBuffer; + char IgnoreArg_taskCount; + char IgnoreArg_firstTask; + +} CMOCK_vkCmdDrawMeshTasksNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDrawMeshTasksIndirectNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBuffer Expected_buffer; + VkDeviceSize Expected_offset; + uint32_t Expected_drawCount; + uint32_t Expected_stride; + char IgnoreArg_commandBuffer; + char IgnoreArg_buffer; + char IgnoreArg_offset; + char IgnoreArg_drawCount; + char IgnoreArg_stride; + +} CMOCK_vkCmdDrawMeshTasksIndirectNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBuffer Expected_buffer; + VkDeviceSize Expected_offset; + VkBuffer Expected_countBuffer; + VkDeviceSize Expected_countBufferOffset; + uint32_t Expected_maxDrawCount; + uint32_t Expected_stride; + char IgnoreArg_commandBuffer; + char IgnoreArg_buffer; + char IgnoreArg_offset; + char IgnoreArg_countBuffer; + char IgnoreArg_countBufferOffset; + char IgnoreArg_maxDrawCount; + char IgnoreArg_stride; + +} CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetExclusiveScissorEnableNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_firstExclusiveScissor; + uint32_t Expected_exclusiveScissorCount; + const VkBool32* Expected_pExclusiveScissorEnables; + char IgnoreArg_commandBuffer; + char IgnoreArg_firstExclusiveScissor; + char IgnoreArg_exclusiveScissorCount; + char IgnoreArg_pExclusiveScissorEnables; + +} CMOCK_vkCmdSetExclusiveScissorEnableNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetExclusiveScissorNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_firstExclusiveScissor; + uint32_t Expected_exclusiveScissorCount; + const VkRect2D* Expected_pExclusiveScissors; + char IgnoreArg_commandBuffer; + char IgnoreArg_firstExclusiveScissor; + char IgnoreArg_exclusiveScissorCount; + char IgnoreArg_pExclusiveScissors; + +} CMOCK_vkCmdSetExclusiveScissorNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetCheckpointNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const void* Expected_pCheckpointMarker; + char IgnoreArg_commandBuffer; + char IgnoreArg_pCheckpointMarker; + +} CMOCK_vkCmdSetCheckpointNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetQueueCheckpointDataNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkQueue Expected_queue; + uint32_t* Expected_pCheckpointDataCount; + VkCheckpointDataNV* Expected_pCheckpointData; + char ReturnThruPtr_pCheckpointDataCount_Used; + uint32_t const* ReturnThruPtr_pCheckpointDataCount_Val; + size_t ReturnThruPtr_pCheckpointDataCount_Size; + char ReturnThruPtr_pCheckpointData_Used; + VkCheckpointDataNV const* ReturnThruPtr_pCheckpointData_Val; + size_t ReturnThruPtr_pCheckpointData_Size; + char IgnoreArg_queue; + char IgnoreArg_pCheckpointDataCount; + char IgnoreArg_pCheckpointData; + +} CMOCK_vkGetQueueCheckpointDataNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkInitializePerformanceApiINTEL_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkInitializePerformanceApiInfoINTEL* Expected_pInitializeInfo; + char IgnoreArg_device; + char IgnoreArg_pInitializeInfo; + +} CMOCK_vkInitializePerformanceApiINTEL_CALL_INSTANCE; + +typedef struct _CMOCK_vkUninitializePerformanceApiINTEL_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + char IgnoreArg_device; + +} CMOCK_vkUninitializePerformanceApiINTEL_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetPerformanceMarkerINTEL_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkCommandBuffer Expected_commandBuffer; + const VkPerformanceMarkerInfoINTEL* Expected_pMarkerInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pMarkerInfo; + +} CMOCK_vkCmdSetPerformanceMarkerINTEL_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetPerformanceStreamMarkerINTEL_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkCommandBuffer Expected_commandBuffer; + const VkPerformanceStreamMarkerInfoINTEL* Expected_pMarkerInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pMarkerInfo; + +} CMOCK_vkCmdSetPerformanceStreamMarkerINTEL_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetPerformanceOverrideINTEL_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkCommandBuffer Expected_commandBuffer; + const VkPerformanceOverrideInfoINTEL* Expected_pOverrideInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pOverrideInfo; + +} CMOCK_vkCmdSetPerformanceOverrideINTEL_CALL_INSTANCE; + +typedef struct _CMOCK_vkAcquirePerformanceConfigurationINTEL_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkPerformanceConfigurationAcquireInfoINTEL* Expected_pAcquireInfo; + VkPerformanceConfigurationINTEL* Expected_pConfiguration; + char ReturnThruPtr_pConfiguration_Used; + VkPerformanceConfigurationINTEL const* ReturnThruPtr_pConfiguration_Val; + size_t ReturnThruPtr_pConfiguration_Size; + char IgnoreArg_device; + char IgnoreArg_pAcquireInfo; + char IgnoreArg_pConfiguration; + +} CMOCK_vkAcquirePerformanceConfigurationINTEL_CALL_INSTANCE; + +typedef struct _CMOCK_vkReleasePerformanceConfigurationINTEL_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkPerformanceConfigurationINTEL Expected_configuration; + char IgnoreArg_device; + char IgnoreArg_configuration; + +} CMOCK_vkReleasePerformanceConfigurationINTEL_CALL_INSTANCE; + +typedef struct _CMOCK_vkQueueSetPerformanceConfigurationINTEL_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkQueue Expected_queue; + VkPerformanceConfigurationINTEL Expected_configuration; + char IgnoreArg_queue; + char IgnoreArg_configuration; + +} CMOCK_vkQueueSetPerformanceConfigurationINTEL_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPerformanceParameterINTEL_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkPerformanceParameterTypeINTEL Expected_parameter; + VkPerformanceValueINTEL* Expected_pValue; + char ReturnThruPtr_pValue_Used; + VkPerformanceValueINTEL const* ReturnThruPtr_pValue_Val; + size_t ReturnThruPtr_pValue_Size; + char IgnoreArg_device; + char IgnoreArg_parameter; + char IgnoreArg_pValue; + +} CMOCK_vkGetPerformanceParameterINTEL_CALL_INSTANCE; + +typedef struct _CMOCK_vkSetLocalDimmingAMD_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkSwapchainKHR Expected_swapChain; + VkBool32 Expected_localDimmingEnable; + char IgnoreArg_device; + char IgnoreArg_swapChain; + char IgnoreArg_localDimmingEnable; + +} CMOCK_vkSetLocalDimmingAMD_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetBufferDeviceAddressEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDeviceAddress ReturnVal; + VkDevice Expected_device; + const VkBufferDeviceAddressInfo* Expected_pInfo; + char IgnoreArg_device; + char IgnoreArg_pInfo; + +} CMOCK_vkGetBufferDeviceAddressEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + uint32_t* Expected_pToolCount; + VkPhysicalDeviceToolProperties* Expected_pToolProperties; + char ReturnThruPtr_pToolCount_Used; + uint32_t const* ReturnThruPtr_pToolCount_Val; + size_t ReturnThruPtr_pToolCount_Size; + char ReturnThruPtr_pToolProperties_Used; + VkPhysicalDeviceToolProperties const* ReturnThruPtr_pToolProperties_Val; + size_t ReturnThruPtr_pToolProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pToolCount; + char IgnoreArg_pToolProperties; + +} CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + uint32_t* Expected_pPropertyCount; + VkCooperativeMatrixPropertiesNV* Expected_pProperties; + char ReturnThruPtr_pPropertyCount_Used; + uint32_t const* ReturnThruPtr_pPropertyCount_Val; + size_t ReturnThruPtr_pPropertyCount_Size; + char ReturnThruPtr_pProperties_Used; + VkCooperativeMatrixPropertiesNV const* ReturnThruPtr_pProperties_Val; + size_t ReturnThruPtr_pProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pPropertyCount; + char IgnoreArg_pProperties; + +} CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + uint32_t* Expected_pCombinationCount; + VkFramebufferMixedSamplesCombinationNV* Expected_pCombinations; + char ReturnThruPtr_pCombinationCount_Used; + uint32_t const* ReturnThruPtr_pCombinationCount_Val; + size_t ReturnThruPtr_pCombinationCount_Size; + char ReturnThruPtr_pCombinations_Used; + VkFramebufferMixedSamplesCombinationNV const* ReturnThruPtr_pCombinations_Val; + size_t ReturnThruPtr_pCombinations_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pCombinationCount; + char IgnoreArg_pCombinations; + +} CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateHeadlessSurfaceEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkInstance Expected_instance; + const VkHeadlessSurfaceCreateInfoEXT* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkSurfaceKHR* Expected_pSurface; + char ReturnThruPtr_pSurface_Used; + VkSurfaceKHR const* ReturnThruPtr_pSurface_Val; + size_t ReturnThruPtr_pSurface_Size; + char IgnoreArg_instance; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pSurface; + +} CMOCK_vkCreateHeadlessSurfaceEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetLineStippleEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_lineStippleFactor; + uint16_t Expected_lineStipplePattern; + char IgnoreArg_commandBuffer; + char IgnoreArg_lineStippleFactor; + char IgnoreArg_lineStipplePattern; + +} CMOCK_vkCmdSetLineStippleEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkResetQueryPoolEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkQueryPool Expected_queryPool; + uint32_t Expected_firstQuery; + uint32_t Expected_queryCount; + char IgnoreArg_device; + char IgnoreArg_queryPool; + char IgnoreArg_firstQuery; + char IgnoreArg_queryCount; + +} CMOCK_vkResetQueryPoolEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetCullModeEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkCullModeFlags Expected_cullMode; + char IgnoreArg_commandBuffer; + char IgnoreArg_cullMode; + +} CMOCK_vkCmdSetCullModeEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetFrontFaceEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkFrontFace Expected_frontFace; + char IgnoreArg_commandBuffer; + char IgnoreArg_frontFace; + +} CMOCK_vkCmdSetFrontFaceEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetPrimitiveTopologyEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkPrimitiveTopology Expected_primitiveTopology; + char IgnoreArg_commandBuffer; + char IgnoreArg_primitiveTopology; + +} CMOCK_vkCmdSetPrimitiveTopologyEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetViewportWithCountEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_viewportCount; + const VkViewport* Expected_pViewports; + char IgnoreArg_commandBuffer; + char IgnoreArg_viewportCount; + char IgnoreArg_pViewports; + +} CMOCK_vkCmdSetViewportWithCountEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetScissorWithCountEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_scissorCount; + const VkRect2D* Expected_pScissors; + char IgnoreArg_commandBuffer; + char IgnoreArg_scissorCount; + char IgnoreArg_pScissors; + +} CMOCK_vkCmdSetScissorWithCountEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBindVertexBuffers2EXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_firstBinding; + uint32_t Expected_bindingCount; + const VkBuffer* Expected_pBuffers; + const VkDeviceSize* Expected_pOffsets; + const VkDeviceSize* Expected_pSizes; + const VkDeviceSize* Expected_pStrides; + char IgnoreArg_commandBuffer; + char IgnoreArg_firstBinding; + char IgnoreArg_bindingCount; + char IgnoreArg_pBuffers; + char IgnoreArg_pOffsets; + char IgnoreArg_pSizes; + char IgnoreArg_pStrides; + +} CMOCK_vkCmdBindVertexBuffers2EXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetDepthTestEnableEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBool32 Expected_depthTestEnable; + char IgnoreArg_commandBuffer; + char IgnoreArg_depthTestEnable; + +} CMOCK_vkCmdSetDepthTestEnableEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetDepthWriteEnableEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBool32 Expected_depthWriteEnable; + char IgnoreArg_commandBuffer; + char IgnoreArg_depthWriteEnable; + +} CMOCK_vkCmdSetDepthWriteEnableEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetDepthCompareOpEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkCompareOp Expected_depthCompareOp; + char IgnoreArg_commandBuffer; + char IgnoreArg_depthCompareOp; + +} CMOCK_vkCmdSetDepthCompareOpEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetDepthBoundsTestEnableEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBool32 Expected_depthBoundsTestEnable; + char IgnoreArg_commandBuffer; + char IgnoreArg_depthBoundsTestEnable; + +} CMOCK_vkCmdSetDepthBoundsTestEnableEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetStencilTestEnableEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBool32 Expected_stencilTestEnable; + char IgnoreArg_commandBuffer; + char IgnoreArg_stencilTestEnable; + +} CMOCK_vkCmdSetStencilTestEnableEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetStencilOpEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkStencilFaceFlags Expected_faceMask; + VkStencilOp Expected_failOp; + VkStencilOp Expected_passOp; + VkStencilOp Expected_depthFailOp; + VkCompareOp Expected_compareOp; + char IgnoreArg_commandBuffer; + char IgnoreArg_faceMask; + char IgnoreArg_failOp; + char IgnoreArg_passOp; + char IgnoreArg_depthFailOp; + char IgnoreArg_compareOp; + +} CMOCK_vkCmdSetStencilOpEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkReleaseSwapchainImagesEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkReleaseSwapchainImagesInfoEXT* Expected_pReleaseInfo; + char IgnoreArg_device; + char IgnoreArg_pReleaseInfo; + +} CMOCK_vkReleaseSwapchainImagesEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetGeneratedCommandsMemoryRequirementsNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + const VkGeneratedCommandsMemoryRequirementsInfoNV* Expected_pInfo; + VkMemoryRequirements2* Expected_pMemoryRequirements; + char ReturnThruPtr_pMemoryRequirements_Used; + VkMemoryRequirements2 const* ReturnThruPtr_pMemoryRequirements_Val; + size_t ReturnThruPtr_pMemoryRequirements_Size; + char IgnoreArg_device; + char IgnoreArg_pInfo; + char IgnoreArg_pMemoryRequirements; + +} CMOCK_vkGetGeneratedCommandsMemoryRequirementsNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdPreprocessGeneratedCommandsNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkGeneratedCommandsInfoNV* Expected_pGeneratedCommandsInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pGeneratedCommandsInfo; + +} CMOCK_vkCmdPreprocessGeneratedCommandsNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdExecuteGeneratedCommandsNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBool32 Expected_isPreprocessed; + const VkGeneratedCommandsInfoNV* Expected_pGeneratedCommandsInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_isPreprocessed; + char IgnoreArg_pGeneratedCommandsInfo; + +} CMOCK_vkCmdExecuteGeneratedCommandsNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBindPipelineShaderGroupNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkPipelineBindPoint Expected_pipelineBindPoint; + VkPipeline Expected_pipeline; + uint32_t Expected_groupIndex; + char IgnoreArg_commandBuffer; + char IgnoreArg_pipelineBindPoint; + char IgnoreArg_pipeline; + char IgnoreArg_groupIndex; + +} CMOCK_vkCmdBindPipelineShaderGroupNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateIndirectCommandsLayoutNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkIndirectCommandsLayoutCreateInfoNV* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkIndirectCommandsLayoutNV* Expected_pIndirectCommandsLayout; + char ReturnThruPtr_pIndirectCommandsLayout_Used; + VkIndirectCommandsLayoutNV const* ReturnThruPtr_pIndirectCommandsLayout_Val; + size_t ReturnThruPtr_pIndirectCommandsLayout_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pIndirectCommandsLayout; + +} CMOCK_vkCreateIndirectCommandsLayoutNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyIndirectCommandsLayoutNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkIndirectCommandsLayoutNV Expected_indirectCommandsLayout; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_indirectCommandsLayout; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyIndirectCommandsLayoutNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkAcquireDrmDisplayEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + int32_t Expected_drmFd; + VkDisplayKHR Expected_display; + char IgnoreArg_physicalDevice; + char IgnoreArg_drmFd; + char IgnoreArg_display; + +} CMOCK_vkAcquireDrmDisplayEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDrmDisplayEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + int32_t Expected_drmFd; + uint32_t Expected_connectorId; + VkDisplayKHR* Expected_display; + char ReturnThruPtr_display_Used; + VkDisplayKHR const* ReturnThruPtr_display_Val; + size_t ReturnThruPtr_display_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_drmFd; + char IgnoreArg_connectorId; + char IgnoreArg_display; + +} CMOCK_vkGetDrmDisplayEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreatePrivateDataSlotEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkPrivateDataSlotCreateInfo* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkPrivateDataSlot* Expected_pPrivateDataSlot; + char ReturnThruPtr_pPrivateDataSlot_Used; + VkPrivateDataSlot const* ReturnThruPtr_pPrivateDataSlot_Val; + size_t ReturnThruPtr_pPrivateDataSlot_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pPrivateDataSlot; + +} CMOCK_vkCreatePrivateDataSlotEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyPrivateDataSlotEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkPrivateDataSlot Expected_privateDataSlot; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_privateDataSlot; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyPrivateDataSlotEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkSetPrivateDataEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkObjectType Expected_objectType; + uint64_t Expected_objectHandle; + VkPrivateDataSlot Expected_privateDataSlot; + uint64_t Expected_data; + char IgnoreArg_device; + char IgnoreArg_objectType; + char IgnoreArg_objectHandle; + char IgnoreArg_privateDataSlot; + char IgnoreArg_data; + +} CMOCK_vkSetPrivateDataEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPrivateDataEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkObjectType Expected_objectType; + uint64_t Expected_objectHandle; + VkPrivateDataSlot Expected_privateDataSlot; + uint64_t* Expected_pData; + char ReturnThruPtr_pData_Used; + uint64_t const* ReturnThruPtr_pData_Val; + size_t ReturnThruPtr_pData_Size; + char IgnoreArg_device; + char IgnoreArg_objectType; + char IgnoreArg_objectHandle; + char IgnoreArg_privateDataSlot; + char IgnoreArg_pData; + +} CMOCK_vkGetPrivateDataEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDescriptorSetLayoutSizeEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkDescriptorSetLayout Expected_layout; + VkDeviceSize* Expected_pLayoutSizeInBytes; + char ReturnThruPtr_pLayoutSizeInBytes_Used; + VkDeviceSize const* ReturnThruPtr_pLayoutSizeInBytes_Val; + size_t ReturnThruPtr_pLayoutSizeInBytes_Size; + char IgnoreArg_device; + char IgnoreArg_layout; + char IgnoreArg_pLayoutSizeInBytes; + +} CMOCK_vkGetDescriptorSetLayoutSizeEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDescriptorSetLayoutBindingOffsetEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkDescriptorSetLayout Expected_layout; + uint32_t Expected_binding; + VkDeviceSize* Expected_pOffset; + char ReturnThruPtr_pOffset_Used; + VkDeviceSize const* ReturnThruPtr_pOffset_Val; + size_t ReturnThruPtr_pOffset_Size; + char IgnoreArg_device; + char IgnoreArg_layout; + char IgnoreArg_binding; + char IgnoreArg_pOffset; + +} CMOCK_vkGetDescriptorSetLayoutBindingOffsetEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDescriptorEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + const VkDescriptorGetInfoEXT* Expected_pDescriptorInfo; + size_t Expected_dataSize; + void* Expected_pDescriptor; + char ReturnThruPtr_pDescriptor_Used; + void const* ReturnThruPtr_pDescriptor_Val; + size_t ReturnThruPtr_pDescriptor_Size; + char IgnoreArg_device; + char IgnoreArg_pDescriptorInfo; + char IgnoreArg_dataSize; + char IgnoreArg_pDescriptor; + +} CMOCK_vkGetDescriptorEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBindDescriptorBuffersEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_bufferCount; + const VkDescriptorBufferBindingInfoEXT* Expected_pBindingInfos; + char IgnoreArg_commandBuffer; + char IgnoreArg_bufferCount; + char IgnoreArg_pBindingInfos; + +} CMOCK_vkCmdBindDescriptorBuffersEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkPipelineBindPoint Expected_pipelineBindPoint; + VkPipelineLayout Expected_layout; + uint32_t Expected_firstSet; + uint32_t Expected_setCount; + const uint32_t* Expected_pBufferIndices; + const VkDeviceSize* Expected_pOffsets; + char IgnoreArg_commandBuffer; + char IgnoreArg_pipelineBindPoint; + char IgnoreArg_layout; + char IgnoreArg_firstSet; + char IgnoreArg_setCount; + char IgnoreArg_pBufferIndices; + char IgnoreArg_pOffsets; + +} CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkPipelineBindPoint Expected_pipelineBindPoint; + VkPipelineLayout Expected_layout; + uint32_t Expected_set; + char IgnoreArg_commandBuffer; + char IgnoreArg_pipelineBindPoint; + char IgnoreArg_layout; + char IgnoreArg_set; + +} CMOCK_vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetBufferOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkBufferCaptureDescriptorDataInfoEXT* Expected_pInfo; + void* Expected_pData; + char ReturnThruPtr_pData_Used; + void const* ReturnThruPtr_pData_Val; + size_t ReturnThruPtr_pData_Size; + char IgnoreArg_device; + char IgnoreArg_pInfo; + char IgnoreArg_pData; + +} CMOCK_vkGetBufferOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetImageOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkImageCaptureDescriptorDataInfoEXT* Expected_pInfo; + void* Expected_pData; + char ReturnThruPtr_pData_Used; + void const* ReturnThruPtr_pData_Val; + size_t ReturnThruPtr_pData_Size; + char IgnoreArg_device; + char IgnoreArg_pInfo; + char IgnoreArg_pData; + +} CMOCK_vkGetImageOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetImageViewOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkImageViewCaptureDescriptorDataInfoEXT* Expected_pInfo; + void* Expected_pData; + char ReturnThruPtr_pData_Used; + void const* ReturnThruPtr_pData_Val; + size_t ReturnThruPtr_pData_Size; + char IgnoreArg_device; + char IgnoreArg_pInfo; + char IgnoreArg_pData; + +} CMOCK_vkGetImageViewOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetSamplerOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkSamplerCaptureDescriptorDataInfoEXT* Expected_pInfo; + void* Expected_pData; + char ReturnThruPtr_pData_Used; + void const* ReturnThruPtr_pData_Val; + size_t ReturnThruPtr_pData_Size; + char IgnoreArg_device; + char IgnoreArg_pInfo; + char IgnoreArg_pData; + +} CMOCK_vkGetSamplerOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkAccelerationStructureCaptureDescriptorDataInfoEXT* Expected_pInfo; + void* Expected_pData; + char ReturnThruPtr_pData_Used; + void const* ReturnThruPtr_pData_Val; + size_t ReturnThruPtr_pData_Size; + char IgnoreArg_device; + char IgnoreArg_pInfo; + char IgnoreArg_pData; + +} CMOCK_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetFragmentShadingRateEnumNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkFragmentShadingRateNV Expected_shadingRate; + const VkFragmentShadingRateCombinerOpKHR* Expected_combinerOps; + char IgnoreArg_commandBuffer; + char IgnoreArg_shadingRate; + char IgnoreArg_combinerOps; + +} CMOCK_vkCmdSetFragmentShadingRateEnumNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetImageSubresourceLayout2EXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkImage Expected_image; + const VkImageSubresource2EXT* Expected_pSubresource; + VkSubresourceLayout2EXT* Expected_pLayout; + char ReturnThruPtr_pLayout_Used; + VkSubresourceLayout2EXT const* ReturnThruPtr_pLayout_Val; + size_t ReturnThruPtr_pLayout_Size; + char IgnoreArg_device; + char IgnoreArg_image; + char IgnoreArg_pSubresource; + char IgnoreArg_pLayout; + +} CMOCK_vkGetImageSubresourceLayout2EXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDeviceFaultInfoEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkDeviceFaultCountsEXT* Expected_pFaultCounts; + VkDeviceFaultInfoEXT* Expected_pFaultInfo; + char ReturnThruPtr_pFaultCounts_Used; + VkDeviceFaultCountsEXT const* ReturnThruPtr_pFaultCounts_Val; + size_t ReturnThruPtr_pFaultCounts_Size; + char ReturnThruPtr_pFaultInfo_Used; + VkDeviceFaultInfoEXT const* ReturnThruPtr_pFaultInfo_Val; + size_t ReturnThruPtr_pFaultInfo_Size; + char IgnoreArg_device; + char IgnoreArg_pFaultCounts; + char IgnoreArg_pFaultInfo; + +} CMOCK_vkGetDeviceFaultInfoEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetVertexInputEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_vertexBindingDescriptionCount; + const VkVertexInputBindingDescription2EXT* Expected_pVertexBindingDescriptions; + uint32_t Expected_vertexAttributeDescriptionCount; + const VkVertexInputAttributeDescription2EXT* Expected_pVertexAttributeDescriptions; + char IgnoreArg_commandBuffer; + char IgnoreArg_vertexBindingDescriptionCount; + char IgnoreArg_pVertexBindingDescriptions; + char IgnoreArg_vertexAttributeDescriptionCount; + char IgnoreArg_pVertexAttributeDescriptions; + +} CMOCK_vkCmdSetVertexInputEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkRenderPass Expected_renderpass; + VkExtent2D* Expected_pMaxWorkgroupSize; + char ReturnThruPtr_pMaxWorkgroupSize_Used; + VkExtent2D const* ReturnThruPtr_pMaxWorkgroupSize_Val; + size_t ReturnThruPtr_pMaxWorkgroupSize_Size; + char IgnoreArg_device; + char IgnoreArg_renderpass; + char IgnoreArg_pMaxWorkgroupSize; + +} CMOCK_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSubpassShadingHUAWEI_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + char IgnoreArg_commandBuffer; + +} CMOCK_vkCmdSubpassShadingHUAWEI_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBindInvocationMaskHUAWEI_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkImageView Expected_imageView; + VkImageLayout Expected_imageLayout; + char IgnoreArg_commandBuffer; + char IgnoreArg_imageView; + char IgnoreArg_imageLayout; + +} CMOCK_vkCmdBindInvocationMaskHUAWEI_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetMemoryRemoteAddressNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkMemoryGetRemoteAddressInfoNV* Expected_pMemoryGetRemoteAddressInfo; + VkRemoteAddressNV* Expected_pAddress; + char ReturnThruPtr_pAddress_Used; + VkRemoteAddressNV const* ReturnThruPtr_pAddress_Val; + size_t ReturnThruPtr_pAddress_Size; + char IgnoreArg_device; + char IgnoreArg_pMemoryGetRemoteAddressInfo; + char IgnoreArg_pAddress; + +} CMOCK_vkGetMemoryRemoteAddressNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPipelinePropertiesEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkPipelineInfoEXT* Expected_pPipelineInfo; + VkBaseOutStructure* Expected_pPipelineProperties; + char ReturnThruPtr_pPipelineProperties_Used; + VkBaseOutStructure const* ReturnThruPtr_pPipelineProperties_Val; + size_t ReturnThruPtr_pPipelineProperties_Size; + char IgnoreArg_device; + char IgnoreArg_pPipelineInfo; + char IgnoreArg_pPipelineProperties; + +} CMOCK_vkGetPipelinePropertiesEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetPatchControlPointsEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_patchControlPoints; + char IgnoreArg_commandBuffer; + char IgnoreArg_patchControlPoints; + +} CMOCK_vkCmdSetPatchControlPointsEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetRasterizerDiscardEnableEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBool32 Expected_rasterizerDiscardEnable; + char IgnoreArg_commandBuffer; + char IgnoreArg_rasterizerDiscardEnable; + +} CMOCK_vkCmdSetRasterizerDiscardEnableEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetDepthBiasEnableEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBool32 Expected_depthBiasEnable; + char IgnoreArg_commandBuffer; + char IgnoreArg_depthBiasEnable; + +} CMOCK_vkCmdSetDepthBiasEnableEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetLogicOpEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkLogicOp Expected_logicOp; + char IgnoreArg_commandBuffer; + char IgnoreArg_logicOp; + +} CMOCK_vkCmdSetLogicOpEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetPrimitiveRestartEnableEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBool32 Expected_primitiveRestartEnable; + char IgnoreArg_commandBuffer; + char IgnoreArg_primitiveRestartEnable; + +} CMOCK_vkCmdSetPrimitiveRestartEnableEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetColorWriteEnableEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_attachmentCount; + const VkBool32* Expected_pColorWriteEnables; + char IgnoreArg_commandBuffer; + char IgnoreArg_attachmentCount; + char IgnoreArg_pColorWriteEnables; + +} CMOCK_vkCmdSetColorWriteEnableEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDrawMultiEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_drawCount; + const VkMultiDrawInfoEXT* Expected_pVertexInfo; + uint32_t Expected_instanceCount; + uint32_t Expected_firstInstance; + uint32_t Expected_stride; + char IgnoreArg_commandBuffer; + char IgnoreArg_drawCount; + char IgnoreArg_pVertexInfo; + char IgnoreArg_instanceCount; + char IgnoreArg_firstInstance; + char IgnoreArg_stride; + +} CMOCK_vkCmdDrawMultiEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDrawMultiIndexedEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_drawCount; + const VkMultiDrawIndexedInfoEXT* Expected_pIndexInfo; + uint32_t Expected_instanceCount; + uint32_t Expected_firstInstance; + uint32_t Expected_stride; + const int32_t* Expected_pVertexOffset; + char IgnoreArg_commandBuffer; + char IgnoreArg_drawCount; + char IgnoreArg_pIndexInfo; + char IgnoreArg_instanceCount; + char IgnoreArg_firstInstance; + char IgnoreArg_stride; + char IgnoreArg_pVertexOffset; + +} CMOCK_vkCmdDrawMultiIndexedEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateMicromapEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkMicromapCreateInfoEXT* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkMicromapEXT* Expected_pMicromap; + char ReturnThruPtr_pMicromap_Used; + VkMicromapEXT const* ReturnThruPtr_pMicromap_Val; + size_t ReturnThruPtr_pMicromap_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pMicromap; + +} CMOCK_vkCreateMicromapEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyMicromapEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkMicromapEXT Expected_micromap; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_micromap; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyMicromapEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBuildMicromapsEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_infoCount; + const VkMicromapBuildInfoEXT* Expected_pInfos; + char IgnoreArg_commandBuffer; + char IgnoreArg_infoCount; + char IgnoreArg_pInfos; + +} CMOCK_vkCmdBuildMicromapsEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkBuildMicromapsEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkDeferredOperationKHR Expected_deferredOperation; + uint32_t Expected_infoCount; + const VkMicromapBuildInfoEXT* Expected_pInfos; + char IgnoreArg_device; + char IgnoreArg_deferredOperation; + char IgnoreArg_infoCount; + char IgnoreArg_pInfos; + +} CMOCK_vkBuildMicromapsEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCopyMicromapEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkDeferredOperationKHR Expected_deferredOperation; + const VkCopyMicromapInfoEXT* Expected_pInfo; + char IgnoreArg_device; + char IgnoreArg_deferredOperation; + char IgnoreArg_pInfo; + +} CMOCK_vkCopyMicromapEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCopyMicromapToMemoryEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkDeferredOperationKHR Expected_deferredOperation; + const VkCopyMicromapToMemoryInfoEXT* Expected_pInfo; + char IgnoreArg_device; + char IgnoreArg_deferredOperation; + char IgnoreArg_pInfo; + +} CMOCK_vkCopyMicromapToMemoryEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCopyMemoryToMicromapEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkDeferredOperationKHR Expected_deferredOperation; + const VkCopyMemoryToMicromapInfoEXT* Expected_pInfo; + char IgnoreArg_device; + char IgnoreArg_deferredOperation; + char IgnoreArg_pInfo; + +} CMOCK_vkCopyMemoryToMicromapEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + uint32_t Expected_micromapCount; + const VkMicromapEXT* Expected_pMicromaps; + VkQueryType Expected_queryType; + size_t Expected_dataSize; + void* Expected_pData; + size_t Expected_stride; + char ReturnThruPtr_pData_Used; + void const* ReturnThruPtr_pData_Val; + size_t ReturnThruPtr_pData_Size; + char IgnoreArg_device; + char IgnoreArg_micromapCount; + char IgnoreArg_pMicromaps; + char IgnoreArg_queryType; + char IgnoreArg_dataSize; + char IgnoreArg_pData; + char IgnoreArg_stride; + +} CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdCopyMicromapEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkCopyMicromapInfoEXT* Expected_pInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pInfo; + +} CMOCK_vkCmdCopyMicromapEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdCopyMicromapToMemoryEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkCopyMicromapToMemoryInfoEXT* Expected_pInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pInfo; + +} CMOCK_vkCmdCopyMicromapToMemoryEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdCopyMemoryToMicromapEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkCopyMemoryToMicromapInfoEXT* Expected_pInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pInfo; + +} CMOCK_vkCmdCopyMemoryToMicromapEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdWriteMicromapsPropertiesEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_micromapCount; + const VkMicromapEXT* Expected_pMicromaps; + VkQueryType Expected_queryType; + VkQueryPool Expected_queryPool; + uint32_t Expected_firstQuery; + char IgnoreArg_commandBuffer; + char IgnoreArg_micromapCount; + char IgnoreArg_pMicromaps; + char IgnoreArg_queryType; + char IgnoreArg_queryPool; + char IgnoreArg_firstQuery; + +} CMOCK_vkCmdWriteMicromapsPropertiesEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDeviceMicromapCompatibilityEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + const VkMicromapVersionInfoEXT* Expected_pVersionInfo; + VkAccelerationStructureCompatibilityKHR* Expected_pCompatibility; + char ReturnThruPtr_pCompatibility_Used; + VkAccelerationStructureCompatibilityKHR const* ReturnThruPtr_pCompatibility_Val; + size_t ReturnThruPtr_pCompatibility_Size; + char IgnoreArg_device; + char IgnoreArg_pVersionInfo; + char IgnoreArg_pCompatibility; + +} CMOCK_vkGetDeviceMicromapCompatibilityEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetMicromapBuildSizesEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkAccelerationStructureBuildTypeKHR Expected_buildType; + const VkMicromapBuildInfoEXT* Expected_pBuildInfo; + VkMicromapBuildSizesInfoEXT* Expected_pSizeInfo; + char ReturnThruPtr_pSizeInfo_Used; + VkMicromapBuildSizesInfoEXT const* ReturnThruPtr_pSizeInfo_Val; + size_t ReturnThruPtr_pSizeInfo_Size; + char IgnoreArg_device; + char IgnoreArg_buildType; + char IgnoreArg_pBuildInfo; + char IgnoreArg_pSizeInfo; + +} CMOCK_vkGetMicromapBuildSizesEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDrawClusterHUAWEI_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_groupCountX; + uint32_t Expected_groupCountY; + uint32_t Expected_groupCountZ; + char IgnoreArg_commandBuffer; + char IgnoreArg_groupCountX; + char IgnoreArg_groupCountY; + char IgnoreArg_groupCountZ; + +} CMOCK_vkCmdDrawClusterHUAWEI_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDrawClusterIndirectHUAWEI_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBuffer Expected_buffer; + VkDeviceSize Expected_offset; + char IgnoreArg_commandBuffer; + char IgnoreArg_buffer; + char IgnoreArg_offset; + +} CMOCK_vkCmdDrawClusterIndirectHUAWEI_CALL_INSTANCE; + +typedef struct _CMOCK_vkSetDeviceMemoryPriorityEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkDeviceMemory Expected_memory; + float Expected_priority; + char IgnoreArg_device; + char IgnoreArg_memory; + char IgnoreArg_priority; + +} CMOCK_vkSetDeviceMemoryPriorityEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDescriptorSetLayoutHostMappingInfoVALVE_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + const VkDescriptorSetBindingReferenceVALVE* Expected_pBindingReference; + VkDescriptorSetLayoutHostMappingInfoVALVE* Expected_pHostMapping; + char ReturnThruPtr_pHostMapping_Used; + VkDescriptorSetLayoutHostMappingInfoVALVE const* ReturnThruPtr_pHostMapping_Val; + size_t ReturnThruPtr_pHostMapping_Size; + char IgnoreArg_device; + char IgnoreArg_pBindingReference; + char IgnoreArg_pHostMapping; + +} CMOCK_vkGetDescriptorSetLayoutHostMappingInfoVALVE_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDescriptorSetHostMappingVALVE_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkDescriptorSet Expected_descriptorSet; + void** Expected_ppData; + char ReturnThruPtr_ppData_Used; + void* const* ReturnThruPtr_ppData_Val; + size_t ReturnThruPtr_ppData_Size; + char IgnoreArg_device; + char IgnoreArg_descriptorSet; + char IgnoreArg_ppData; + +} CMOCK_vkGetDescriptorSetHostMappingVALVE_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdCopyMemoryIndirectNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkDeviceAddress Expected_copyBufferAddress; + uint32_t Expected_copyCount; + uint32_t Expected_stride; + char IgnoreArg_commandBuffer; + char IgnoreArg_copyBufferAddress; + char IgnoreArg_copyCount; + char IgnoreArg_stride; + +} CMOCK_vkCmdCopyMemoryIndirectNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkDeviceAddress Expected_copyBufferAddress; + uint32_t Expected_copyCount; + uint32_t Expected_stride; + VkImage Expected_dstImage; + VkImageLayout Expected_dstImageLayout; + const VkImageSubresourceLayers* Expected_pImageSubresources; + char IgnoreArg_commandBuffer; + char IgnoreArg_copyBufferAddress; + char IgnoreArg_copyCount; + char IgnoreArg_stride; + char IgnoreArg_dstImage; + char IgnoreArg_dstImageLayout; + char IgnoreArg_pImageSubresources; + +} CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDecompressMemoryNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_decompressRegionCount; + const VkDecompressMemoryRegionNV* Expected_pDecompressMemoryRegions; + char IgnoreArg_commandBuffer; + char IgnoreArg_decompressRegionCount; + char IgnoreArg_pDecompressMemoryRegions; + +} CMOCK_vkCmdDecompressMemoryNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDecompressMemoryIndirectCountNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkDeviceAddress Expected_indirectCommandsAddress; + VkDeviceAddress Expected_indirectCommandsCountAddress; + uint32_t Expected_stride; + char IgnoreArg_commandBuffer; + char IgnoreArg_indirectCommandsAddress; + char IgnoreArg_indirectCommandsCountAddress; + char IgnoreArg_stride; + +} CMOCK_vkCmdDecompressMemoryIndirectCountNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetTessellationDomainOriginEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkTessellationDomainOrigin Expected_domainOrigin; + char IgnoreArg_commandBuffer; + char IgnoreArg_domainOrigin; + +} CMOCK_vkCmdSetTessellationDomainOriginEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetDepthClampEnableEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBool32 Expected_depthClampEnable; + char IgnoreArg_commandBuffer; + char IgnoreArg_depthClampEnable; + +} CMOCK_vkCmdSetDepthClampEnableEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetPolygonModeEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkPolygonMode Expected_polygonMode; + char IgnoreArg_commandBuffer; + char IgnoreArg_polygonMode; + +} CMOCK_vkCmdSetPolygonModeEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetRasterizationSamplesEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkSampleCountFlagBits Expected_rasterizationSamples; + char IgnoreArg_commandBuffer; + char IgnoreArg_rasterizationSamples; + +} CMOCK_vkCmdSetRasterizationSamplesEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetSampleMaskEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkSampleCountFlagBits Expected_samples; + const VkSampleMask* Expected_pSampleMask; + char IgnoreArg_commandBuffer; + char IgnoreArg_samples; + char IgnoreArg_pSampleMask; + +} CMOCK_vkCmdSetSampleMaskEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetAlphaToCoverageEnableEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBool32 Expected_alphaToCoverageEnable; + char IgnoreArg_commandBuffer; + char IgnoreArg_alphaToCoverageEnable; + +} CMOCK_vkCmdSetAlphaToCoverageEnableEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetAlphaToOneEnableEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBool32 Expected_alphaToOneEnable; + char IgnoreArg_commandBuffer; + char IgnoreArg_alphaToOneEnable; + +} CMOCK_vkCmdSetAlphaToOneEnableEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetLogicOpEnableEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBool32 Expected_logicOpEnable; + char IgnoreArg_commandBuffer; + char IgnoreArg_logicOpEnable; + +} CMOCK_vkCmdSetLogicOpEnableEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetColorBlendEnableEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_firstAttachment; + uint32_t Expected_attachmentCount; + const VkBool32* Expected_pColorBlendEnables; + char IgnoreArg_commandBuffer; + char IgnoreArg_firstAttachment; + char IgnoreArg_attachmentCount; + char IgnoreArg_pColorBlendEnables; + +} CMOCK_vkCmdSetColorBlendEnableEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetColorBlendEquationEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_firstAttachment; + uint32_t Expected_attachmentCount; + const VkColorBlendEquationEXT* Expected_pColorBlendEquations; + char IgnoreArg_commandBuffer; + char IgnoreArg_firstAttachment; + char IgnoreArg_attachmentCount; + char IgnoreArg_pColorBlendEquations; + +} CMOCK_vkCmdSetColorBlendEquationEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetColorWriteMaskEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_firstAttachment; + uint32_t Expected_attachmentCount; + const VkColorComponentFlags* Expected_pColorWriteMasks; + char IgnoreArg_commandBuffer; + char IgnoreArg_firstAttachment; + char IgnoreArg_attachmentCount; + char IgnoreArg_pColorWriteMasks; + +} CMOCK_vkCmdSetColorWriteMaskEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetRasterizationStreamEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_rasterizationStream; + char IgnoreArg_commandBuffer; + char IgnoreArg_rasterizationStream; + +} CMOCK_vkCmdSetRasterizationStreamEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetConservativeRasterizationModeEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkConservativeRasterizationModeEXT Expected_conservativeRasterizationMode; + char IgnoreArg_commandBuffer; + char IgnoreArg_conservativeRasterizationMode; + +} CMOCK_vkCmdSetConservativeRasterizationModeEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetExtraPrimitiveOverestimationSizeEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + float Expected_extraPrimitiveOverestimationSize; + char IgnoreArg_commandBuffer; + char IgnoreArg_extraPrimitiveOverestimationSize; + +} CMOCK_vkCmdSetExtraPrimitiveOverestimationSizeEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetDepthClipEnableEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBool32 Expected_depthClipEnable; + char IgnoreArg_commandBuffer; + char IgnoreArg_depthClipEnable; + +} CMOCK_vkCmdSetDepthClipEnableEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetSampleLocationsEnableEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBool32 Expected_sampleLocationsEnable; + char IgnoreArg_commandBuffer; + char IgnoreArg_sampleLocationsEnable; + +} CMOCK_vkCmdSetSampleLocationsEnableEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetColorBlendAdvancedEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_firstAttachment; + uint32_t Expected_attachmentCount; + const VkColorBlendAdvancedEXT* Expected_pColorBlendAdvanced; + char IgnoreArg_commandBuffer; + char IgnoreArg_firstAttachment; + char IgnoreArg_attachmentCount; + char IgnoreArg_pColorBlendAdvanced; + +} CMOCK_vkCmdSetColorBlendAdvancedEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetProvokingVertexModeEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkProvokingVertexModeEXT Expected_provokingVertexMode; + char IgnoreArg_commandBuffer; + char IgnoreArg_provokingVertexMode; + +} CMOCK_vkCmdSetProvokingVertexModeEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetLineRasterizationModeEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkLineRasterizationModeEXT Expected_lineRasterizationMode; + char IgnoreArg_commandBuffer; + char IgnoreArg_lineRasterizationMode; + +} CMOCK_vkCmdSetLineRasterizationModeEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetLineStippleEnableEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBool32 Expected_stippledLineEnable; + char IgnoreArg_commandBuffer; + char IgnoreArg_stippledLineEnable; + +} CMOCK_vkCmdSetLineStippleEnableEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetDepthClipNegativeOneToOneEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBool32 Expected_negativeOneToOne; + char IgnoreArg_commandBuffer; + char IgnoreArg_negativeOneToOne; + +} CMOCK_vkCmdSetDepthClipNegativeOneToOneEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetViewportWScalingEnableNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBool32 Expected_viewportWScalingEnable; + char IgnoreArg_commandBuffer; + char IgnoreArg_viewportWScalingEnable; + +} CMOCK_vkCmdSetViewportWScalingEnableNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetViewportSwizzleNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_firstViewport; + uint32_t Expected_viewportCount; + const VkViewportSwizzleNV* Expected_pViewportSwizzles; + char IgnoreArg_commandBuffer; + char IgnoreArg_firstViewport; + char IgnoreArg_viewportCount; + char IgnoreArg_pViewportSwizzles; + +} CMOCK_vkCmdSetViewportSwizzleNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetCoverageToColorEnableNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBool32 Expected_coverageToColorEnable; + char IgnoreArg_commandBuffer; + char IgnoreArg_coverageToColorEnable; + +} CMOCK_vkCmdSetCoverageToColorEnableNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetCoverageToColorLocationNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_coverageToColorLocation; + char IgnoreArg_commandBuffer; + char IgnoreArg_coverageToColorLocation; + +} CMOCK_vkCmdSetCoverageToColorLocationNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetCoverageModulationModeNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkCoverageModulationModeNV Expected_coverageModulationMode; + char IgnoreArg_commandBuffer; + char IgnoreArg_coverageModulationMode; + +} CMOCK_vkCmdSetCoverageModulationModeNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetCoverageModulationTableEnableNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBool32 Expected_coverageModulationTableEnable; + char IgnoreArg_commandBuffer; + char IgnoreArg_coverageModulationTableEnable; + +} CMOCK_vkCmdSetCoverageModulationTableEnableNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetCoverageModulationTableNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_coverageModulationTableCount; + const float* Expected_pCoverageModulationTable; + char IgnoreArg_commandBuffer; + char IgnoreArg_coverageModulationTableCount; + char IgnoreArg_pCoverageModulationTable; + +} CMOCK_vkCmdSetCoverageModulationTableNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetShadingRateImageEnableNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBool32 Expected_shadingRateImageEnable; + char IgnoreArg_commandBuffer; + char IgnoreArg_shadingRateImageEnable; + +} CMOCK_vkCmdSetShadingRateImageEnableNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetRepresentativeFragmentTestEnableNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBool32 Expected_representativeFragmentTestEnable; + char IgnoreArg_commandBuffer; + char IgnoreArg_representativeFragmentTestEnable; + +} CMOCK_vkCmdSetRepresentativeFragmentTestEnableNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetCoverageReductionModeNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkCoverageReductionModeNV Expected_coverageReductionMode; + char IgnoreArg_commandBuffer; + char IgnoreArg_coverageReductionMode; + +} CMOCK_vkCmdSetCoverageReductionModeNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetShaderModuleIdentifierEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkShaderModule Expected_shaderModule; + VkShaderModuleIdentifierEXT* Expected_pIdentifier; + char ReturnThruPtr_pIdentifier_Used; + VkShaderModuleIdentifierEXT const* ReturnThruPtr_pIdentifier_Val; + size_t ReturnThruPtr_pIdentifier_Size; + char IgnoreArg_device; + char IgnoreArg_shaderModule; + char IgnoreArg_pIdentifier; + +} CMOCK_vkGetShaderModuleIdentifierEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetShaderModuleCreateInfoIdentifierEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + const VkShaderModuleCreateInfo* Expected_pCreateInfo; + VkShaderModuleIdentifierEXT* Expected_pIdentifier; + char ReturnThruPtr_pIdentifier_Used; + VkShaderModuleIdentifierEXT const* ReturnThruPtr_pIdentifier_Val; + size_t ReturnThruPtr_pIdentifier_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pIdentifier; + +} CMOCK_vkGetShaderModuleCreateInfoIdentifierEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkPhysicalDevice Expected_physicalDevice; + const VkOpticalFlowImageFormatInfoNV* Expected_pOpticalFlowImageFormatInfo; + uint32_t* Expected_pFormatCount; + VkOpticalFlowImageFormatPropertiesNV* Expected_pImageFormatProperties; + char ReturnThruPtr_pFormatCount_Used; + uint32_t const* ReturnThruPtr_pFormatCount_Val; + size_t ReturnThruPtr_pFormatCount_Size; + char ReturnThruPtr_pImageFormatProperties_Used; + VkOpticalFlowImageFormatPropertiesNV const* ReturnThruPtr_pImageFormatProperties_Val; + size_t ReturnThruPtr_pImageFormatProperties_Size; + char IgnoreArg_physicalDevice; + char IgnoreArg_pOpticalFlowImageFormatInfo; + char IgnoreArg_pFormatCount; + char IgnoreArg_pImageFormatProperties; + +} CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateOpticalFlowSessionNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkOpticalFlowSessionCreateInfoNV* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkOpticalFlowSessionNV* Expected_pSession; + char ReturnThruPtr_pSession_Used; + VkOpticalFlowSessionNV const* ReturnThruPtr_pSession_Val; + size_t ReturnThruPtr_pSession_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pSession; + +} CMOCK_vkCreateOpticalFlowSessionNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyOpticalFlowSessionNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkOpticalFlowSessionNV Expected_session; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_session; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyOpticalFlowSessionNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkBindOpticalFlowSessionImageNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkOpticalFlowSessionNV Expected_session; + VkOpticalFlowSessionBindingPointNV Expected_bindingPoint; + VkImageView Expected_view; + VkImageLayout Expected_layout; + char IgnoreArg_device; + char IgnoreArg_session; + char IgnoreArg_bindingPoint; + char IgnoreArg_view; + char IgnoreArg_layout; + +} CMOCK_vkBindOpticalFlowSessionImageNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdOpticalFlowExecuteNV_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkOpticalFlowSessionNV Expected_session; + const VkOpticalFlowExecuteInfoNV* Expected_pExecuteInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_session; + char IgnoreArg_pExecuteInfo; + +} CMOCK_vkCmdOpticalFlowExecuteNV_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateShadersEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + uint32_t Expected_createInfoCount; + const VkShaderCreateInfoEXT* Expected_pCreateInfos; + const VkAllocationCallbacks* Expected_pAllocator; + VkShaderEXT* Expected_pShaders; + char ReturnThruPtr_pShaders_Used; + VkShaderEXT const* ReturnThruPtr_pShaders_Val; + size_t ReturnThruPtr_pShaders_Size; + char IgnoreArg_device; + char IgnoreArg_createInfoCount; + char IgnoreArg_pCreateInfos; + char IgnoreArg_pAllocator; + char IgnoreArg_pShaders; + +} CMOCK_vkCreateShadersEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyShaderEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkShaderEXT Expected_shader; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_shader; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyShaderEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetShaderBinaryDataEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkShaderEXT Expected_shader; + size_t* Expected_pDataSize; + void* Expected_pData; + char ReturnThruPtr_pDataSize_Used; + size_t const* ReturnThruPtr_pDataSize_Val; + size_t ReturnThruPtr_pDataSize_Size; + char ReturnThruPtr_pData_Used; + void const* ReturnThruPtr_pData_Val; + size_t ReturnThruPtr_pData_Size; + char IgnoreArg_device; + char IgnoreArg_shader; + char IgnoreArg_pDataSize; + char IgnoreArg_pData; + +} CMOCK_vkGetShaderBinaryDataEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBindShadersEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_stageCount; + const VkShaderStageFlagBits* Expected_pStages; + const VkShaderEXT* Expected_pShaders; + char IgnoreArg_commandBuffer; + char IgnoreArg_stageCount; + char IgnoreArg_pStages; + char IgnoreArg_pShaders; + +} CMOCK_vkCmdBindShadersEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetFramebufferTilePropertiesQCOM_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkFramebuffer Expected_framebuffer; + uint32_t* Expected_pPropertiesCount; + VkTilePropertiesQCOM* Expected_pProperties; + char ReturnThruPtr_pPropertiesCount_Used; + uint32_t const* ReturnThruPtr_pPropertiesCount_Val; + size_t ReturnThruPtr_pPropertiesCount_Size; + char ReturnThruPtr_pProperties_Used; + VkTilePropertiesQCOM const* ReturnThruPtr_pProperties_Val; + size_t ReturnThruPtr_pProperties_Size; + char IgnoreArg_device; + char IgnoreArg_framebuffer; + char IgnoreArg_pPropertiesCount; + char IgnoreArg_pProperties; + +} CMOCK_vkGetFramebufferTilePropertiesQCOM_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDynamicRenderingTilePropertiesQCOM_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkRenderingInfo* Expected_pRenderingInfo; + VkTilePropertiesQCOM* Expected_pProperties; + char ReturnThruPtr_pProperties_Used; + VkTilePropertiesQCOM const* ReturnThruPtr_pProperties_Val; + size_t ReturnThruPtr_pProperties_Size; + char IgnoreArg_device; + char IgnoreArg_pRenderingInfo; + char IgnoreArg_pProperties; + +} CMOCK_vkGetDynamicRenderingTilePropertiesQCOM_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetAttachmentFeedbackLoopEnableEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkImageAspectFlags Expected_aspectMask; + char IgnoreArg_commandBuffer; + char IgnoreArg_aspectMask; + +} CMOCK_vkCmdSetAttachmentFeedbackLoopEnableEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateAccelerationStructureKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + const VkAccelerationStructureCreateInfoKHR* Expected_pCreateInfo; + const VkAllocationCallbacks* Expected_pAllocator; + VkAccelerationStructureKHR* Expected_pAccelerationStructure; + char ReturnThruPtr_pAccelerationStructure_Used; + VkAccelerationStructureKHR const* ReturnThruPtr_pAccelerationStructure_Val; + size_t ReturnThruPtr_pAccelerationStructure_Size; + char IgnoreArg_device; + char IgnoreArg_pCreateInfo; + char IgnoreArg_pAllocator; + char IgnoreArg_pAccelerationStructure; + +} CMOCK_vkCreateAccelerationStructureKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkDestroyAccelerationStructureKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkAccelerationStructureKHR Expected_accelerationStructure; + const VkAllocationCallbacks* Expected_pAllocator; + char IgnoreArg_device; + char IgnoreArg_accelerationStructure; + char IgnoreArg_pAllocator; + +} CMOCK_vkDestroyAccelerationStructureKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBuildAccelerationStructuresKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_infoCount; + const VkAccelerationStructureBuildGeometryInfoKHR* Expected_pInfos; + const VkAccelerationStructureBuildRangeInfoKHR* const* Expected_ppBuildRangeInfos; + char IgnoreArg_commandBuffer; + char IgnoreArg_infoCount; + char IgnoreArg_pInfos; + char IgnoreArg_ppBuildRangeInfos; + +} CMOCK_vkCmdBuildAccelerationStructuresKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdBuildAccelerationStructuresIndirectKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_infoCount; + const VkAccelerationStructureBuildGeometryInfoKHR* Expected_pInfos; + const VkDeviceAddress* Expected_pIndirectDeviceAddresses; + const uint32_t* Expected_pIndirectStrides; + const uint32_t* const* Expected_ppMaxPrimitiveCounts; + char IgnoreArg_commandBuffer; + char IgnoreArg_infoCount; + char IgnoreArg_pInfos; + char IgnoreArg_pIndirectDeviceAddresses; + char IgnoreArg_pIndirectStrides; + char IgnoreArg_ppMaxPrimitiveCounts; + +} CMOCK_vkCmdBuildAccelerationStructuresIndirectKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkBuildAccelerationStructuresKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkDeferredOperationKHR Expected_deferredOperation; + uint32_t Expected_infoCount; + const VkAccelerationStructureBuildGeometryInfoKHR* Expected_pInfos; + const VkAccelerationStructureBuildRangeInfoKHR* const* Expected_ppBuildRangeInfos; + char IgnoreArg_device; + char IgnoreArg_deferredOperation; + char IgnoreArg_infoCount; + char IgnoreArg_pInfos; + char IgnoreArg_ppBuildRangeInfos; + +} CMOCK_vkBuildAccelerationStructuresKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCopyAccelerationStructureKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkDeferredOperationKHR Expected_deferredOperation; + const VkCopyAccelerationStructureInfoKHR* Expected_pInfo; + char IgnoreArg_device; + char IgnoreArg_deferredOperation; + char IgnoreArg_pInfo; + +} CMOCK_vkCopyAccelerationStructureKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkDeferredOperationKHR Expected_deferredOperation; + const VkCopyAccelerationStructureToMemoryInfoKHR* Expected_pInfo; + char IgnoreArg_device; + char IgnoreArg_deferredOperation; + char IgnoreArg_pInfo; + +} CMOCK_vkCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkDeferredOperationKHR Expected_deferredOperation; + const VkCopyMemoryToAccelerationStructureInfoKHR* Expected_pInfo; + char IgnoreArg_device; + char IgnoreArg_deferredOperation; + char IgnoreArg_pInfo; + +} CMOCK_vkCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + uint32_t Expected_accelerationStructureCount; + const VkAccelerationStructureKHR* Expected_pAccelerationStructures; + VkQueryType Expected_queryType; + size_t Expected_dataSize; + void* Expected_pData; + size_t Expected_stride; + char ReturnThruPtr_pData_Used; + void const* ReturnThruPtr_pData_Val; + size_t ReturnThruPtr_pData_Size; + char IgnoreArg_device; + char IgnoreArg_accelerationStructureCount; + char IgnoreArg_pAccelerationStructures; + char IgnoreArg_queryType; + char IgnoreArg_dataSize; + char IgnoreArg_pData; + char IgnoreArg_stride; + +} CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdCopyAccelerationStructureKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkCopyAccelerationStructureInfoKHR* Expected_pInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pInfo; + +} CMOCK_vkCmdCopyAccelerationStructureKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkCopyAccelerationStructureToMemoryInfoKHR* Expected_pInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pInfo; + +} CMOCK_vkCmdCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkCopyMemoryToAccelerationStructureInfoKHR* Expected_pInfo; + char IgnoreArg_commandBuffer; + char IgnoreArg_pInfo; + +} CMOCK_vkCmdCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetAccelerationStructureDeviceAddressKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDeviceAddress ReturnVal; + VkDevice Expected_device; + const VkAccelerationStructureDeviceAddressInfoKHR* Expected_pInfo; + char IgnoreArg_device; + char IgnoreArg_pInfo; + +} CMOCK_vkGetAccelerationStructureDeviceAddressKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_accelerationStructureCount; + const VkAccelerationStructureKHR* Expected_pAccelerationStructures; + VkQueryType Expected_queryType; + VkQueryPool Expected_queryPool; + uint32_t Expected_firstQuery; + char IgnoreArg_commandBuffer; + char IgnoreArg_accelerationStructureCount; + char IgnoreArg_pAccelerationStructures; + char IgnoreArg_queryType; + char IgnoreArg_queryPool; + char IgnoreArg_firstQuery; + +} CMOCK_vkCmdWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetDeviceAccelerationStructureCompatibilityKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + const VkAccelerationStructureVersionInfoKHR* Expected_pVersionInfo; + VkAccelerationStructureCompatibilityKHR* Expected_pCompatibility; + char ReturnThruPtr_pCompatibility_Used; + VkAccelerationStructureCompatibilityKHR const* ReturnThruPtr_pCompatibility_Val; + size_t ReturnThruPtr_pCompatibility_Size; + char IgnoreArg_device; + char IgnoreArg_pVersionInfo; + char IgnoreArg_pCompatibility; + +} CMOCK_vkGetDeviceAccelerationStructureCompatibilityKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetAccelerationStructureBuildSizesKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDevice Expected_device; + VkAccelerationStructureBuildTypeKHR Expected_buildType; + const VkAccelerationStructureBuildGeometryInfoKHR* Expected_pBuildInfo; + const uint32_t* Expected_pMaxPrimitiveCounts; + VkAccelerationStructureBuildSizesInfoKHR* Expected_pSizeInfo; + char ReturnThruPtr_pSizeInfo_Used; + VkAccelerationStructureBuildSizesInfoKHR const* ReturnThruPtr_pSizeInfo_Val; + size_t ReturnThruPtr_pSizeInfo_Size; + char IgnoreArg_device; + char IgnoreArg_buildType; + char IgnoreArg_pBuildInfo; + char IgnoreArg_pMaxPrimitiveCounts; + char IgnoreArg_pSizeInfo; + +} CMOCK_vkGetAccelerationStructureBuildSizesKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdTraceRaysKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkStridedDeviceAddressRegionKHR* Expected_pRaygenShaderBindingTable; + const VkStridedDeviceAddressRegionKHR* Expected_pMissShaderBindingTable; + const VkStridedDeviceAddressRegionKHR* Expected_pHitShaderBindingTable; + const VkStridedDeviceAddressRegionKHR* Expected_pCallableShaderBindingTable; + uint32_t Expected_width; + uint32_t Expected_height; + uint32_t Expected_depth; + char IgnoreArg_commandBuffer; + char IgnoreArg_pRaygenShaderBindingTable; + char IgnoreArg_pMissShaderBindingTable; + char IgnoreArg_pHitShaderBindingTable; + char IgnoreArg_pCallableShaderBindingTable; + char IgnoreArg_width; + char IgnoreArg_height; + char IgnoreArg_depth; + +} CMOCK_vkCmdTraceRaysKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkDeferredOperationKHR Expected_deferredOperation; + VkPipelineCache Expected_pipelineCache; + uint32_t Expected_createInfoCount; + const VkRayTracingPipelineCreateInfoKHR* Expected_pCreateInfos; + const VkAllocationCallbacks* Expected_pAllocator; + VkPipeline* Expected_pPipelines; + char ReturnThruPtr_pPipelines_Used; + VkPipeline const* ReturnThruPtr_pPipelines_Val; + size_t ReturnThruPtr_pPipelines_Size; + char IgnoreArg_device; + char IgnoreArg_deferredOperation; + char IgnoreArg_pipelineCache; + char IgnoreArg_createInfoCount; + char IgnoreArg_pCreateInfos; + char IgnoreArg_pAllocator; + char IgnoreArg_pPipelines; + +} CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkResult ReturnVal; + VkDevice Expected_device; + VkPipeline Expected_pipeline; + uint32_t Expected_firstGroup; + uint32_t Expected_groupCount; + size_t Expected_dataSize; + void* Expected_pData; + char ReturnThruPtr_pData_Used; + void const* ReturnThruPtr_pData_Val; + size_t ReturnThruPtr_pData_Size; + char IgnoreArg_device; + char IgnoreArg_pipeline; + char IgnoreArg_firstGroup; + char IgnoreArg_groupCount; + char IgnoreArg_dataSize; + char IgnoreArg_pData; + +} CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdTraceRaysIndirectKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + const VkStridedDeviceAddressRegionKHR* Expected_pRaygenShaderBindingTable; + const VkStridedDeviceAddressRegionKHR* Expected_pMissShaderBindingTable; + const VkStridedDeviceAddressRegionKHR* Expected_pHitShaderBindingTable; + const VkStridedDeviceAddressRegionKHR* Expected_pCallableShaderBindingTable; + VkDeviceAddress Expected_indirectDeviceAddress; + char IgnoreArg_commandBuffer; + char IgnoreArg_pRaygenShaderBindingTable; + char IgnoreArg_pMissShaderBindingTable; + char IgnoreArg_pHitShaderBindingTable; + char IgnoreArg_pCallableShaderBindingTable; + char IgnoreArg_indirectDeviceAddress; + +} CMOCK_vkCmdTraceRaysIndirectKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkGetRayTracingShaderGroupStackSizeKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkDeviceSize ReturnVal; + VkDevice Expected_device; + VkPipeline Expected_pipeline; + uint32_t Expected_group; + VkShaderGroupShaderKHR Expected_groupShader; + char IgnoreArg_device; + char IgnoreArg_pipeline; + char IgnoreArg_group; + char IgnoreArg_groupShader; + +} CMOCK_vkGetRayTracingShaderGroupStackSizeKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdSetRayTracingPipelineStackSizeKHR_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_pipelineStackSize; + char IgnoreArg_commandBuffer; + char IgnoreArg_pipelineStackSize; + +} CMOCK_vkCmdSetRayTracingPipelineStackSizeKHR_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDrawMeshTasksEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + uint32_t Expected_groupCountX; + uint32_t Expected_groupCountY; + uint32_t Expected_groupCountZ; + char IgnoreArg_commandBuffer; + char IgnoreArg_groupCountX; + char IgnoreArg_groupCountY; + char IgnoreArg_groupCountZ; + +} CMOCK_vkCmdDrawMeshTasksEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDrawMeshTasksIndirectEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBuffer Expected_buffer; + VkDeviceSize Expected_offset; + uint32_t Expected_drawCount; + uint32_t Expected_stride; + char IgnoreArg_commandBuffer; + char IgnoreArg_buffer; + char IgnoreArg_offset; + char IgnoreArg_drawCount; + char IgnoreArg_stride; + +} CMOCK_vkCmdDrawMeshTasksIndirectEXT_CALL_INSTANCE; + +typedef struct _CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + VkCommandBuffer Expected_commandBuffer; + VkBuffer Expected_buffer; + VkDeviceSize Expected_offset; + VkBuffer Expected_countBuffer; + VkDeviceSize Expected_countBufferOffset; + uint32_t Expected_maxDrawCount; + uint32_t Expected_stride; + char IgnoreArg_commandBuffer; + char IgnoreArg_buffer; + char IgnoreArg_offset; + char IgnoreArg_countBuffer; + char IgnoreArg_countBufferOffset; + char IgnoreArg_maxDrawCount; + char IgnoreArg_stride; + +} CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALL_INSTANCE; + +static struct Mockvulkan_coreInstance +{ + char vkCreateInstance_IgnoreBool; + VkResult vkCreateInstance_FinalReturn; + char vkCreateInstance_CallbackBool; + CMOCK_vkCreateInstance_CALLBACK vkCreateInstance_CallbackFunctionPointer; + int vkCreateInstance_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateInstance_CallInstance; + char vkDestroyInstance_IgnoreBool; + char vkDestroyInstance_CallbackBool; + CMOCK_vkDestroyInstance_CALLBACK vkDestroyInstance_CallbackFunctionPointer; + int vkDestroyInstance_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyInstance_CallInstance; + char vkEnumeratePhysicalDevices_IgnoreBool; + VkResult vkEnumeratePhysicalDevices_FinalReturn; + char vkEnumeratePhysicalDevices_CallbackBool; + CMOCK_vkEnumeratePhysicalDevices_CALLBACK vkEnumeratePhysicalDevices_CallbackFunctionPointer; + int vkEnumeratePhysicalDevices_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkEnumeratePhysicalDevices_CallInstance; + char vkGetPhysicalDeviceFeatures_IgnoreBool; + char vkGetPhysicalDeviceFeatures_CallbackBool; + CMOCK_vkGetPhysicalDeviceFeatures_CALLBACK vkGetPhysicalDeviceFeatures_CallbackFunctionPointer; + int vkGetPhysicalDeviceFeatures_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceFeatures_CallInstance; + char vkGetPhysicalDeviceFormatProperties_IgnoreBool; + char vkGetPhysicalDeviceFormatProperties_CallbackBool; + CMOCK_vkGetPhysicalDeviceFormatProperties_CALLBACK vkGetPhysicalDeviceFormatProperties_CallbackFunctionPointer; + int vkGetPhysicalDeviceFormatProperties_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceFormatProperties_CallInstance; + char vkGetPhysicalDeviceImageFormatProperties_IgnoreBool; + VkResult vkGetPhysicalDeviceImageFormatProperties_FinalReturn; + char vkGetPhysicalDeviceImageFormatProperties_CallbackBool; + CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALLBACK vkGetPhysicalDeviceImageFormatProperties_CallbackFunctionPointer; + int vkGetPhysicalDeviceImageFormatProperties_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceImageFormatProperties_CallInstance; + char vkGetPhysicalDeviceProperties_IgnoreBool; + char vkGetPhysicalDeviceProperties_CallbackBool; + CMOCK_vkGetPhysicalDeviceProperties_CALLBACK vkGetPhysicalDeviceProperties_CallbackFunctionPointer; + int vkGetPhysicalDeviceProperties_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceProperties_CallInstance; + char vkGetPhysicalDeviceQueueFamilyProperties_IgnoreBool; + char vkGetPhysicalDeviceQueueFamilyProperties_CallbackBool; + CMOCK_vkGetPhysicalDeviceQueueFamilyProperties_CALLBACK vkGetPhysicalDeviceQueueFamilyProperties_CallbackFunctionPointer; + int vkGetPhysicalDeviceQueueFamilyProperties_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceQueueFamilyProperties_CallInstance; + char vkGetPhysicalDeviceMemoryProperties_IgnoreBool; + char vkGetPhysicalDeviceMemoryProperties_CallbackBool; + CMOCK_vkGetPhysicalDeviceMemoryProperties_CALLBACK vkGetPhysicalDeviceMemoryProperties_CallbackFunctionPointer; + int vkGetPhysicalDeviceMemoryProperties_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceMemoryProperties_CallInstance; + char vkGetInstanceProcAddr_IgnoreBool; + PFN_vkVoidFunction vkGetInstanceProcAddr_FinalReturn; + char vkGetInstanceProcAddr_CallbackBool; + CMOCK_vkGetInstanceProcAddr_CALLBACK vkGetInstanceProcAddr_CallbackFunctionPointer; + int vkGetInstanceProcAddr_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetInstanceProcAddr_CallInstance; + char vkGetDeviceProcAddr_IgnoreBool; + PFN_vkVoidFunction vkGetDeviceProcAddr_FinalReturn; + char vkGetDeviceProcAddr_CallbackBool; + CMOCK_vkGetDeviceProcAddr_CALLBACK vkGetDeviceProcAddr_CallbackFunctionPointer; + int vkGetDeviceProcAddr_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDeviceProcAddr_CallInstance; + char vkCreateDevice_IgnoreBool; + VkResult vkCreateDevice_FinalReturn; + char vkCreateDevice_CallbackBool; + CMOCK_vkCreateDevice_CALLBACK vkCreateDevice_CallbackFunctionPointer; + int vkCreateDevice_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateDevice_CallInstance; + char vkDestroyDevice_IgnoreBool; + char vkDestroyDevice_CallbackBool; + CMOCK_vkDestroyDevice_CALLBACK vkDestroyDevice_CallbackFunctionPointer; + int vkDestroyDevice_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyDevice_CallInstance; + char vkEnumerateInstanceExtensionProperties_IgnoreBool; + VkResult vkEnumerateInstanceExtensionProperties_FinalReturn; + char vkEnumerateInstanceExtensionProperties_CallbackBool; + CMOCK_vkEnumerateInstanceExtensionProperties_CALLBACK vkEnumerateInstanceExtensionProperties_CallbackFunctionPointer; + int vkEnumerateInstanceExtensionProperties_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkEnumerateInstanceExtensionProperties_CallInstance; + char vkEnumerateDeviceExtensionProperties_IgnoreBool; + VkResult vkEnumerateDeviceExtensionProperties_FinalReturn; + char vkEnumerateDeviceExtensionProperties_CallbackBool; + CMOCK_vkEnumerateDeviceExtensionProperties_CALLBACK vkEnumerateDeviceExtensionProperties_CallbackFunctionPointer; + int vkEnumerateDeviceExtensionProperties_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkEnumerateDeviceExtensionProperties_CallInstance; + char vkEnumerateInstanceLayerProperties_IgnoreBool; + VkResult vkEnumerateInstanceLayerProperties_FinalReturn; + char vkEnumerateInstanceLayerProperties_CallbackBool; + CMOCK_vkEnumerateInstanceLayerProperties_CALLBACK vkEnumerateInstanceLayerProperties_CallbackFunctionPointer; + int vkEnumerateInstanceLayerProperties_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkEnumerateInstanceLayerProperties_CallInstance; + char vkEnumerateDeviceLayerProperties_IgnoreBool; + VkResult vkEnumerateDeviceLayerProperties_FinalReturn; + char vkEnumerateDeviceLayerProperties_CallbackBool; + CMOCK_vkEnumerateDeviceLayerProperties_CALLBACK vkEnumerateDeviceLayerProperties_CallbackFunctionPointer; + int vkEnumerateDeviceLayerProperties_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkEnumerateDeviceLayerProperties_CallInstance; + char vkGetDeviceQueue_IgnoreBool; + char vkGetDeviceQueue_CallbackBool; + CMOCK_vkGetDeviceQueue_CALLBACK vkGetDeviceQueue_CallbackFunctionPointer; + int vkGetDeviceQueue_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDeviceQueue_CallInstance; + char vkQueueSubmit_IgnoreBool; + VkResult vkQueueSubmit_FinalReturn; + char vkQueueSubmit_CallbackBool; + CMOCK_vkQueueSubmit_CALLBACK vkQueueSubmit_CallbackFunctionPointer; + int vkQueueSubmit_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkQueueSubmit_CallInstance; + char vkQueueWaitIdle_IgnoreBool; + VkResult vkQueueWaitIdle_FinalReturn; + char vkQueueWaitIdle_CallbackBool; + CMOCK_vkQueueWaitIdle_CALLBACK vkQueueWaitIdle_CallbackFunctionPointer; + int vkQueueWaitIdle_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkQueueWaitIdle_CallInstance; + char vkDeviceWaitIdle_IgnoreBool; + VkResult vkDeviceWaitIdle_FinalReturn; + char vkDeviceWaitIdle_CallbackBool; + CMOCK_vkDeviceWaitIdle_CALLBACK vkDeviceWaitIdle_CallbackFunctionPointer; + int vkDeviceWaitIdle_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDeviceWaitIdle_CallInstance; + char vkAllocateMemory_IgnoreBool; + VkResult vkAllocateMemory_FinalReturn; + char vkAllocateMemory_CallbackBool; + CMOCK_vkAllocateMemory_CALLBACK vkAllocateMemory_CallbackFunctionPointer; + int vkAllocateMemory_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkAllocateMemory_CallInstance; + char vkFreeMemory_IgnoreBool; + char vkFreeMemory_CallbackBool; + CMOCK_vkFreeMemory_CALLBACK vkFreeMemory_CallbackFunctionPointer; + int vkFreeMemory_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkFreeMemory_CallInstance; + char vkMapMemory_IgnoreBool; + VkResult vkMapMemory_FinalReturn; + char vkMapMemory_CallbackBool; + CMOCK_vkMapMemory_CALLBACK vkMapMemory_CallbackFunctionPointer; + int vkMapMemory_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkMapMemory_CallInstance; + char vkUnmapMemory_IgnoreBool; + char vkUnmapMemory_CallbackBool; + CMOCK_vkUnmapMemory_CALLBACK vkUnmapMemory_CallbackFunctionPointer; + int vkUnmapMemory_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkUnmapMemory_CallInstance; + char vkFlushMappedMemoryRanges_IgnoreBool; + VkResult vkFlushMappedMemoryRanges_FinalReturn; + char vkFlushMappedMemoryRanges_CallbackBool; + CMOCK_vkFlushMappedMemoryRanges_CALLBACK vkFlushMappedMemoryRanges_CallbackFunctionPointer; + int vkFlushMappedMemoryRanges_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkFlushMappedMemoryRanges_CallInstance; + char vkInvalidateMappedMemoryRanges_IgnoreBool; + VkResult vkInvalidateMappedMemoryRanges_FinalReturn; + char vkInvalidateMappedMemoryRanges_CallbackBool; + CMOCK_vkInvalidateMappedMemoryRanges_CALLBACK vkInvalidateMappedMemoryRanges_CallbackFunctionPointer; + int vkInvalidateMappedMemoryRanges_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkInvalidateMappedMemoryRanges_CallInstance; + char vkGetDeviceMemoryCommitment_IgnoreBool; + char vkGetDeviceMemoryCommitment_CallbackBool; + CMOCK_vkGetDeviceMemoryCommitment_CALLBACK vkGetDeviceMemoryCommitment_CallbackFunctionPointer; + int vkGetDeviceMemoryCommitment_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDeviceMemoryCommitment_CallInstance; + char vkBindBufferMemory_IgnoreBool; + VkResult vkBindBufferMemory_FinalReturn; + char vkBindBufferMemory_CallbackBool; + CMOCK_vkBindBufferMemory_CALLBACK vkBindBufferMemory_CallbackFunctionPointer; + int vkBindBufferMemory_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkBindBufferMemory_CallInstance; + char vkBindImageMemory_IgnoreBool; + VkResult vkBindImageMemory_FinalReturn; + char vkBindImageMemory_CallbackBool; + CMOCK_vkBindImageMemory_CALLBACK vkBindImageMemory_CallbackFunctionPointer; + int vkBindImageMemory_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkBindImageMemory_CallInstance; + char vkGetBufferMemoryRequirements_IgnoreBool; + char vkGetBufferMemoryRequirements_CallbackBool; + CMOCK_vkGetBufferMemoryRequirements_CALLBACK vkGetBufferMemoryRequirements_CallbackFunctionPointer; + int vkGetBufferMemoryRequirements_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetBufferMemoryRequirements_CallInstance; + char vkGetImageMemoryRequirements_IgnoreBool; + char vkGetImageMemoryRequirements_CallbackBool; + CMOCK_vkGetImageMemoryRequirements_CALLBACK vkGetImageMemoryRequirements_CallbackFunctionPointer; + int vkGetImageMemoryRequirements_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetImageMemoryRequirements_CallInstance; + char vkGetImageSparseMemoryRequirements_IgnoreBool; + char vkGetImageSparseMemoryRequirements_CallbackBool; + CMOCK_vkGetImageSparseMemoryRequirements_CALLBACK vkGetImageSparseMemoryRequirements_CallbackFunctionPointer; + int vkGetImageSparseMemoryRequirements_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetImageSparseMemoryRequirements_CallInstance; + char vkGetPhysicalDeviceSparseImageFormatProperties_IgnoreBool; + char vkGetPhysicalDeviceSparseImageFormatProperties_CallbackBool; + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALLBACK vkGetPhysicalDeviceSparseImageFormatProperties_CallbackFunctionPointer; + int vkGetPhysicalDeviceSparseImageFormatProperties_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceSparseImageFormatProperties_CallInstance; + char vkQueueBindSparse_IgnoreBool; + VkResult vkQueueBindSparse_FinalReturn; + char vkQueueBindSparse_CallbackBool; + CMOCK_vkQueueBindSparse_CALLBACK vkQueueBindSparse_CallbackFunctionPointer; + int vkQueueBindSparse_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkQueueBindSparse_CallInstance; + char vkCreateFence_IgnoreBool; + VkResult vkCreateFence_FinalReturn; + char vkCreateFence_CallbackBool; + CMOCK_vkCreateFence_CALLBACK vkCreateFence_CallbackFunctionPointer; + int vkCreateFence_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateFence_CallInstance; + char vkDestroyFence_IgnoreBool; + char vkDestroyFence_CallbackBool; + CMOCK_vkDestroyFence_CALLBACK vkDestroyFence_CallbackFunctionPointer; + int vkDestroyFence_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyFence_CallInstance; + char vkResetFences_IgnoreBool; + VkResult vkResetFences_FinalReturn; + char vkResetFences_CallbackBool; + CMOCK_vkResetFences_CALLBACK vkResetFences_CallbackFunctionPointer; + int vkResetFences_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkResetFences_CallInstance; + char vkGetFenceStatus_IgnoreBool; + VkResult vkGetFenceStatus_FinalReturn; + char vkGetFenceStatus_CallbackBool; + CMOCK_vkGetFenceStatus_CALLBACK vkGetFenceStatus_CallbackFunctionPointer; + int vkGetFenceStatus_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetFenceStatus_CallInstance; + char vkWaitForFences_IgnoreBool; + VkResult vkWaitForFences_FinalReturn; + char vkWaitForFences_CallbackBool; + CMOCK_vkWaitForFences_CALLBACK vkWaitForFences_CallbackFunctionPointer; + int vkWaitForFences_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkWaitForFences_CallInstance; + char vkCreateSemaphore_IgnoreBool; + VkResult vkCreateSemaphore_FinalReturn; + char vkCreateSemaphore_CallbackBool; + CMOCK_vkCreateSemaphore_CALLBACK vkCreateSemaphore_CallbackFunctionPointer; + int vkCreateSemaphore_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateSemaphore_CallInstance; + char vkDestroySemaphore_IgnoreBool; + char vkDestroySemaphore_CallbackBool; + CMOCK_vkDestroySemaphore_CALLBACK vkDestroySemaphore_CallbackFunctionPointer; + int vkDestroySemaphore_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroySemaphore_CallInstance; + char vkCreateEvent_IgnoreBool; + VkResult vkCreateEvent_FinalReturn; + char vkCreateEvent_CallbackBool; + CMOCK_vkCreateEvent_CALLBACK vkCreateEvent_CallbackFunctionPointer; + int vkCreateEvent_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateEvent_CallInstance; + char vkDestroyEvent_IgnoreBool; + char vkDestroyEvent_CallbackBool; + CMOCK_vkDestroyEvent_CALLBACK vkDestroyEvent_CallbackFunctionPointer; + int vkDestroyEvent_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyEvent_CallInstance; + char vkGetEventStatus_IgnoreBool; + VkResult vkGetEventStatus_FinalReturn; + char vkGetEventStatus_CallbackBool; + CMOCK_vkGetEventStatus_CALLBACK vkGetEventStatus_CallbackFunctionPointer; + int vkGetEventStatus_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetEventStatus_CallInstance; + char vkSetEvent_IgnoreBool; + VkResult vkSetEvent_FinalReturn; + char vkSetEvent_CallbackBool; + CMOCK_vkSetEvent_CALLBACK vkSetEvent_CallbackFunctionPointer; + int vkSetEvent_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkSetEvent_CallInstance; + char vkResetEvent_IgnoreBool; + VkResult vkResetEvent_FinalReturn; + char vkResetEvent_CallbackBool; + CMOCK_vkResetEvent_CALLBACK vkResetEvent_CallbackFunctionPointer; + int vkResetEvent_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkResetEvent_CallInstance; + char vkCreateQueryPool_IgnoreBool; + VkResult vkCreateQueryPool_FinalReturn; + char vkCreateQueryPool_CallbackBool; + CMOCK_vkCreateQueryPool_CALLBACK vkCreateQueryPool_CallbackFunctionPointer; + int vkCreateQueryPool_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateQueryPool_CallInstance; + char vkDestroyQueryPool_IgnoreBool; + char vkDestroyQueryPool_CallbackBool; + CMOCK_vkDestroyQueryPool_CALLBACK vkDestroyQueryPool_CallbackFunctionPointer; + int vkDestroyQueryPool_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyQueryPool_CallInstance; + char vkGetQueryPoolResults_IgnoreBool; + VkResult vkGetQueryPoolResults_FinalReturn; + char vkGetQueryPoolResults_CallbackBool; + CMOCK_vkGetQueryPoolResults_CALLBACK vkGetQueryPoolResults_CallbackFunctionPointer; + int vkGetQueryPoolResults_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetQueryPoolResults_CallInstance; + char vkCreateBuffer_IgnoreBool; + VkResult vkCreateBuffer_FinalReturn; + char vkCreateBuffer_CallbackBool; + CMOCK_vkCreateBuffer_CALLBACK vkCreateBuffer_CallbackFunctionPointer; + int vkCreateBuffer_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateBuffer_CallInstance; + char vkDestroyBuffer_IgnoreBool; + char vkDestroyBuffer_CallbackBool; + CMOCK_vkDestroyBuffer_CALLBACK vkDestroyBuffer_CallbackFunctionPointer; + int vkDestroyBuffer_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyBuffer_CallInstance; + char vkCreateBufferView_IgnoreBool; + VkResult vkCreateBufferView_FinalReturn; + char vkCreateBufferView_CallbackBool; + CMOCK_vkCreateBufferView_CALLBACK vkCreateBufferView_CallbackFunctionPointer; + int vkCreateBufferView_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateBufferView_CallInstance; + char vkDestroyBufferView_IgnoreBool; + char vkDestroyBufferView_CallbackBool; + CMOCK_vkDestroyBufferView_CALLBACK vkDestroyBufferView_CallbackFunctionPointer; + int vkDestroyBufferView_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyBufferView_CallInstance; + char vkCreateImage_IgnoreBool; + VkResult vkCreateImage_FinalReturn; + char vkCreateImage_CallbackBool; + CMOCK_vkCreateImage_CALLBACK vkCreateImage_CallbackFunctionPointer; + int vkCreateImage_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateImage_CallInstance; + char vkDestroyImage_IgnoreBool; + char vkDestroyImage_CallbackBool; + CMOCK_vkDestroyImage_CALLBACK vkDestroyImage_CallbackFunctionPointer; + int vkDestroyImage_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyImage_CallInstance; + char vkGetImageSubresourceLayout_IgnoreBool; + char vkGetImageSubresourceLayout_CallbackBool; + CMOCK_vkGetImageSubresourceLayout_CALLBACK vkGetImageSubresourceLayout_CallbackFunctionPointer; + int vkGetImageSubresourceLayout_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetImageSubresourceLayout_CallInstance; + char vkCreateImageView_IgnoreBool; + VkResult vkCreateImageView_FinalReturn; + char vkCreateImageView_CallbackBool; + CMOCK_vkCreateImageView_CALLBACK vkCreateImageView_CallbackFunctionPointer; + int vkCreateImageView_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateImageView_CallInstance; + char vkDestroyImageView_IgnoreBool; + char vkDestroyImageView_CallbackBool; + CMOCK_vkDestroyImageView_CALLBACK vkDestroyImageView_CallbackFunctionPointer; + int vkDestroyImageView_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyImageView_CallInstance; + char vkCreateShaderModule_IgnoreBool; + VkResult vkCreateShaderModule_FinalReturn; + char vkCreateShaderModule_CallbackBool; + CMOCK_vkCreateShaderModule_CALLBACK vkCreateShaderModule_CallbackFunctionPointer; + int vkCreateShaderModule_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateShaderModule_CallInstance; + char vkDestroyShaderModule_IgnoreBool; + char vkDestroyShaderModule_CallbackBool; + CMOCK_vkDestroyShaderModule_CALLBACK vkDestroyShaderModule_CallbackFunctionPointer; + int vkDestroyShaderModule_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyShaderModule_CallInstance; + char vkCreatePipelineCache_IgnoreBool; + VkResult vkCreatePipelineCache_FinalReturn; + char vkCreatePipelineCache_CallbackBool; + CMOCK_vkCreatePipelineCache_CALLBACK vkCreatePipelineCache_CallbackFunctionPointer; + int vkCreatePipelineCache_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreatePipelineCache_CallInstance; + char vkDestroyPipelineCache_IgnoreBool; + char vkDestroyPipelineCache_CallbackBool; + CMOCK_vkDestroyPipelineCache_CALLBACK vkDestroyPipelineCache_CallbackFunctionPointer; + int vkDestroyPipelineCache_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyPipelineCache_CallInstance; + char vkGetPipelineCacheData_IgnoreBool; + VkResult vkGetPipelineCacheData_FinalReturn; + char vkGetPipelineCacheData_CallbackBool; + CMOCK_vkGetPipelineCacheData_CALLBACK vkGetPipelineCacheData_CallbackFunctionPointer; + int vkGetPipelineCacheData_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPipelineCacheData_CallInstance; + char vkMergePipelineCaches_IgnoreBool; + VkResult vkMergePipelineCaches_FinalReturn; + char vkMergePipelineCaches_CallbackBool; + CMOCK_vkMergePipelineCaches_CALLBACK vkMergePipelineCaches_CallbackFunctionPointer; + int vkMergePipelineCaches_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkMergePipelineCaches_CallInstance; + char vkCreateGraphicsPipelines_IgnoreBool; + VkResult vkCreateGraphicsPipelines_FinalReturn; + char vkCreateGraphicsPipelines_CallbackBool; + CMOCK_vkCreateGraphicsPipelines_CALLBACK vkCreateGraphicsPipelines_CallbackFunctionPointer; + int vkCreateGraphicsPipelines_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateGraphicsPipelines_CallInstance; + char vkCreateComputePipelines_IgnoreBool; + VkResult vkCreateComputePipelines_FinalReturn; + char vkCreateComputePipelines_CallbackBool; + CMOCK_vkCreateComputePipelines_CALLBACK vkCreateComputePipelines_CallbackFunctionPointer; + int vkCreateComputePipelines_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateComputePipelines_CallInstance; + char vkDestroyPipeline_IgnoreBool; + char vkDestroyPipeline_CallbackBool; + CMOCK_vkDestroyPipeline_CALLBACK vkDestroyPipeline_CallbackFunctionPointer; + int vkDestroyPipeline_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyPipeline_CallInstance; + char vkCreatePipelineLayout_IgnoreBool; + VkResult vkCreatePipelineLayout_FinalReturn; + char vkCreatePipelineLayout_CallbackBool; + CMOCK_vkCreatePipelineLayout_CALLBACK vkCreatePipelineLayout_CallbackFunctionPointer; + int vkCreatePipelineLayout_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreatePipelineLayout_CallInstance; + char vkDestroyPipelineLayout_IgnoreBool; + char vkDestroyPipelineLayout_CallbackBool; + CMOCK_vkDestroyPipelineLayout_CALLBACK vkDestroyPipelineLayout_CallbackFunctionPointer; + int vkDestroyPipelineLayout_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyPipelineLayout_CallInstance; + char vkCreateSampler_IgnoreBool; + VkResult vkCreateSampler_FinalReturn; + char vkCreateSampler_CallbackBool; + CMOCK_vkCreateSampler_CALLBACK vkCreateSampler_CallbackFunctionPointer; + int vkCreateSampler_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateSampler_CallInstance; + char vkDestroySampler_IgnoreBool; + char vkDestroySampler_CallbackBool; + CMOCK_vkDestroySampler_CALLBACK vkDestroySampler_CallbackFunctionPointer; + int vkDestroySampler_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroySampler_CallInstance; + char vkCreateDescriptorSetLayout_IgnoreBool; + VkResult vkCreateDescriptorSetLayout_FinalReturn; + char vkCreateDescriptorSetLayout_CallbackBool; + CMOCK_vkCreateDescriptorSetLayout_CALLBACK vkCreateDescriptorSetLayout_CallbackFunctionPointer; + int vkCreateDescriptorSetLayout_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateDescriptorSetLayout_CallInstance; + char vkDestroyDescriptorSetLayout_IgnoreBool; + char vkDestroyDescriptorSetLayout_CallbackBool; + CMOCK_vkDestroyDescriptorSetLayout_CALLBACK vkDestroyDescriptorSetLayout_CallbackFunctionPointer; + int vkDestroyDescriptorSetLayout_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyDescriptorSetLayout_CallInstance; + char vkCreateDescriptorPool_IgnoreBool; + VkResult vkCreateDescriptorPool_FinalReturn; + char vkCreateDescriptorPool_CallbackBool; + CMOCK_vkCreateDescriptorPool_CALLBACK vkCreateDescriptorPool_CallbackFunctionPointer; + int vkCreateDescriptorPool_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateDescriptorPool_CallInstance; + char vkDestroyDescriptorPool_IgnoreBool; + char vkDestroyDescriptorPool_CallbackBool; + CMOCK_vkDestroyDescriptorPool_CALLBACK vkDestroyDescriptorPool_CallbackFunctionPointer; + int vkDestroyDescriptorPool_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyDescriptorPool_CallInstance; + char vkResetDescriptorPool_IgnoreBool; + VkResult vkResetDescriptorPool_FinalReturn; + char vkResetDescriptorPool_CallbackBool; + CMOCK_vkResetDescriptorPool_CALLBACK vkResetDescriptorPool_CallbackFunctionPointer; + int vkResetDescriptorPool_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkResetDescriptorPool_CallInstance; + char vkAllocateDescriptorSets_IgnoreBool; + VkResult vkAllocateDescriptorSets_FinalReturn; + char vkAllocateDescriptorSets_CallbackBool; + CMOCK_vkAllocateDescriptorSets_CALLBACK vkAllocateDescriptorSets_CallbackFunctionPointer; + int vkAllocateDescriptorSets_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkAllocateDescriptorSets_CallInstance; + char vkFreeDescriptorSets_IgnoreBool; + VkResult vkFreeDescriptorSets_FinalReturn; + char vkFreeDescriptorSets_CallbackBool; + CMOCK_vkFreeDescriptorSets_CALLBACK vkFreeDescriptorSets_CallbackFunctionPointer; + int vkFreeDescriptorSets_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkFreeDescriptorSets_CallInstance; + char vkUpdateDescriptorSets_IgnoreBool; + char vkUpdateDescriptorSets_CallbackBool; + CMOCK_vkUpdateDescriptorSets_CALLBACK vkUpdateDescriptorSets_CallbackFunctionPointer; + int vkUpdateDescriptorSets_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkUpdateDescriptorSets_CallInstance; + char vkCreateFramebuffer_IgnoreBool; + VkResult vkCreateFramebuffer_FinalReturn; + char vkCreateFramebuffer_CallbackBool; + CMOCK_vkCreateFramebuffer_CALLBACK vkCreateFramebuffer_CallbackFunctionPointer; + int vkCreateFramebuffer_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateFramebuffer_CallInstance; + char vkDestroyFramebuffer_IgnoreBool; + char vkDestroyFramebuffer_CallbackBool; + CMOCK_vkDestroyFramebuffer_CALLBACK vkDestroyFramebuffer_CallbackFunctionPointer; + int vkDestroyFramebuffer_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyFramebuffer_CallInstance; + char vkCreateRenderPass_IgnoreBool; + VkResult vkCreateRenderPass_FinalReturn; + char vkCreateRenderPass_CallbackBool; + CMOCK_vkCreateRenderPass_CALLBACK vkCreateRenderPass_CallbackFunctionPointer; + int vkCreateRenderPass_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateRenderPass_CallInstance; + char vkDestroyRenderPass_IgnoreBool; + char vkDestroyRenderPass_CallbackBool; + CMOCK_vkDestroyRenderPass_CALLBACK vkDestroyRenderPass_CallbackFunctionPointer; + int vkDestroyRenderPass_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyRenderPass_CallInstance; + char vkGetRenderAreaGranularity_IgnoreBool; + char vkGetRenderAreaGranularity_CallbackBool; + CMOCK_vkGetRenderAreaGranularity_CALLBACK vkGetRenderAreaGranularity_CallbackFunctionPointer; + int vkGetRenderAreaGranularity_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetRenderAreaGranularity_CallInstance; + char vkCreateCommandPool_IgnoreBool; + VkResult vkCreateCommandPool_FinalReturn; + char vkCreateCommandPool_CallbackBool; + CMOCK_vkCreateCommandPool_CALLBACK vkCreateCommandPool_CallbackFunctionPointer; + int vkCreateCommandPool_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateCommandPool_CallInstance; + char vkDestroyCommandPool_IgnoreBool; + char vkDestroyCommandPool_CallbackBool; + CMOCK_vkDestroyCommandPool_CALLBACK vkDestroyCommandPool_CallbackFunctionPointer; + int vkDestroyCommandPool_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyCommandPool_CallInstance; + char vkResetCommandPool_IgnoreBool; + VkResult vkResetCommandPool_FinalReturn; + char vkResetCommandPool_CallbackBool; + CMOCK_vkResetCommandPool_CALLBACK vkResetCommandPool_CallbackFunctionPointer; + int vkResetCommandPool_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkResetCommandPool_CallInstance; + char vkAllocateCommandBuffers_IgnoreBool; + VkResult vkAllocateCommandBuffers_FinalReturn; + char vkAllocateCommandBuffers_CallbackBool; + CMOCK_vkAllocateCommandBuffers_CALLBACK vkAllocateCommandBuffers_CallbackFunctionPointer; + int vkAllocateCommandBuffers_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkAllocateCommandBuffers_CallInstance; + char vkFreeCommandBuffers_IgnoreBool; + char vkFreeCommandBuffers_CallbackBool; + CMOCK_vkFreeCommandBuffers_CALLBACK vkFreeCommandBuffers_CallbackFunctionPointer; + int vkFreeCommandBuffers_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkFreeCommandBuffers_CallInstance; + char vkBeginCommandBuffer_IgnoreBool; + VkResult vkBeginCommandBuffer_FinalReturn; + char vkBeginCommandBuffer_CallbackBool; + CMOCK_vkBeginCommandBuffer_CALLBACK vkBeginCommandBuffer_CallbackFunctionPointer; + int vkBeginCommandBuffer_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkBeginCommandBuffer_CallInstance; + char vkEndCommandBuffer_IgnoreBool; + VkResult vkEndCommandBuffer_FinalReturn; + char vkEndCommandBuffer_CallbackBool; + CMOCK_vkEndCommandBuffer_CALLBACK vkEndCommandBuffer_CallbackFunctionPointer; + int vkEndCommandBuffer_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkEndCommandBuffer_CallInstance; + char vkResetCommandBuffer_IgnoreBool; + VkResult vkResetCommandBuffer_FinalReturn; + char vkResetCommandBuffer_CallbackBool; + CMOCK_vkResetCommandBuffer_CALLBACK vkResetCommandBuffer_CallbackFunctionPointer; + int vkResetCommandBuffer_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkResetCommandBuffer_CallInstance; + char vkCmdBindPipeline_IgnoreBool; + char vkCmdBindPipeline_CallbackBool; + CMOCK_vkCmdBindPipeline_CALLBACK vkCmdBindPipeline_CallbackFunctionPointer; + int vkCmdBindPipeline_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBindPipeline_CallInstance; + char vkCmdSetViewport_IgnoreBool; + char vkCmdSetViewport_CallbackBool; + CMOCK_vkCmdSetViewport_CALLBACK vkCmdSetViewport_CallbackFunctionPointer; + int vkCmdSetViewport_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetViewport_CallInstance; + char vkCmdSetScissor_IgnoreBool; + char vkCmdSetScissor_CallbackBool; + CMOCK_vkCmdSetScissor_CALLBACK vkCmdSetScissor_CallbackFunctionPointer; + int vkCmdSetScissor_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetScissor_CallInstance; + char vkCmdSetLineWidth_IgnoreBool; + char vkCmdSetLineWidth_CallbackBool; + CMOCK_vkCmdSetLineWidth_CALLBACK vkCmdSetLineWidth_CallbackFunctionPointer; + int vkCmdSetLineWidth_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetLineWidth_CallInstance; + char vkCmdSetDepthBias_IgnoreBool; + char vkCmdSetDepthBias_CallbackBool; + CMOCK_vkCmdSetDepthBias_CALLBACK vkCmdSetDepthBias_CallbackFunctionPointer; + int vkCmdSetDepthBias_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetDepthBias_CallInstance; + char vkCmdSetBlendConstants_IgnoreBool; + char vkCmdSetBlendConstants_CallbackBool; + CMOCK_vkCmdSetBlendConstants_CALLBACK vkCmdSetBlendConstants_CallbackFunctionPointer; + int vkCmdSetBlendConstants_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetBlendConstants_CallInstance; + char vkCmdSetDepthBounds_IgnoreBool; + char vkCmdSetDepthBounds_CallbackBool; + CMOCK_vkCmdSetDepthBounds_CALLBACK vkCmdSetDepthBounds_CallbackFunctionPointer; + int vkCmdSetDepthBounds_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetDepthBounds_CallInstance; + char vkCmdSetStencilCompareMask_IgnoreBool; + char vkCmdSetStencilCompareMask_CallbackBool; + CMOCK_vkCmdSetStencilCompareMask_CALLBACK vkCmdSetStencilCompareMask_CallbackFunctionPointer; + int vkCmdSetStencilCompareMask_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetStencilCompareMask_CallInstance; + char vkCmdSetStencilWriteMask_IgnoreBool; + char vkCmdSetStencilWriteMask_CallbackBool; + CMOCK_vkCmdSetStencilWriteMask_CALLBACK vkCmdSetStencilWriteMask_CallbackFunctionPointer; + int vkCmdSetStencilWriteMask_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetStencilWriteMask_CallInstance; + char vkCmdSetStencilReference_IgnoreBool; + char vkCmdSetStencilReference_CallbackBool; + CMOCK_vkCmdSetStencilReference_CALLBACK vkCmdSetStencilReference_CallbackFunctionPointer; + int vkCmdSetStencilReference_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetStencilReference_CallInstance; + char vkCmdBindDescriptorSets_IgnoreBool; + char vkCmdBindDescriptorSets_CallbackBool; + CMOCK_vkCmdBindDescriptorSets_CALLBACK vkCmdBindDescriptorSets_CallbackFunctionPointer; + int vkCmdBindDescriptorSets_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBindDescriptorSets_CallInstance; + char vkCmdBindIndexBuffer_IgnoreBool; + char vkCmdBindIndexBuffer_CallbackBool; + CMOCK_vkCmdBindIndexBuffer_CALLBACK vkCmdBindIndexBuffer_CallbackFunctionPointer; + int vkCmdBindIndexBuffer_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBindIndexBuffer_CallInstance; + char vkCmdBindVertexBuffers_IgnoreBool; + char vkCmdBindVertexBuffers_CallbackBool; + CMOCK_vkCmdBindVertexBuffers_CALLBACK vkCmdBindVertexBuffers_CallbackFunctionPointer; + int vkCmdBindVertexBuffers_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBindVertexBuffers_CallInstance; + char vkCmdDraw_IgnoreBool; + char vkCmdDraw_CallbackBool; + CMOCK_vkCmdDraw_CALLBACK vkCmdDraw_CallbackFunctionPointer; + int vkCmdDraw_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDraw_CallInstance; + char vkCmdDrawIndexed_IgnoreBool; + char vkCmdDrawIndexed_CallbackBool; + CMOCK_vkCmdDrawIndexed_CALLBACK vkCmdDrawIndexed_CallbackFunctionPointer; + int vkCmdDrawIndexed_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDrawIndexed_CallInstance; + char vkCmdDrawIndirect_IgnoreBool; + char vkCmdDrawIndirect_CallbackBool; + CMOCK_vkCmdDrawIndirect_CALLBACK vkCmdDrawIndirect_CallbackFunctionPointer; + int vkCmdDrawIndirect_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDrawIndirect_CallInstance; + char vkCmdDrawIndexedIndirect_IgnoreBool; + char vkCmdDrawIndexedIndirect_CallbackBool; + CMOCK_vkCmdDrawIndexedIndirect_CALLBACK vkCmdDrawIndexedIndirect_CallbackFunctionPointer; + int vkCmdDrawIndexedIndirect_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDrawIndexedIndirect_CallInstance; + char vkCmdDispatch_IgnoreBool; + char vkCmdDispatch_CallbackBool; + CMOCK_vkCmdDispatch_CALLBACK vkCmdDispatch_CallbackFunctionPointer; + int vkCmdDispatch_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDispatch_CallInstance; + char vkCmdDispatchIndirect_IgnoreBool; + char vkCmdDispatchIndirect_CallbackBool; + CMOCK_vkCmdDispatchIndirect_CALLBACK vkCmdDispatchIndirect_CallbackFunctionPointer; + int vkCmdDispatchIndirect_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDispatchIndirect_CallInstance; + char vkCmdCopyBuffer_IgnoreBool; + char vkCmdCopyBuffer_CallbackBool; + CMOCK_vkCmdCopyBuffer_CALLBACK vkCmdCopyBuffer_CallbackFunctionPointer; + int vkCmdCopyBuffer_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdCopyBuffer_CallInstance; + char vkCmdCopyImage_IgnoreBool; + char vkCmdCopyImage_CallbackBool; + CMOCK_vkCmdCopyImage_CALLBACK vkCmdCopyImage_CallbackFunctionPointer; + int vkCmdCopyImage_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdCopyImage_CallInstance; + char vkCmdBlitImage_IgnoreBool; + char vkCmdBlitImage_CallbackBool; + CMOCK_vkCmdBlitImage_CALLBACK vkCmdBlitImage_CallbackFunctionPointer; + int vkCmdBlitImage_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBlitImage_CallInstance; + char vkCmdCopyBufferToImage_IgnoreBool; + char vkCmdCopyBufferToImage_CallbackBool; + CMOCK_vkCmdCopyBufferToImage_CALLBACK vkCmdCopyBufferToImage_CallbackFunctionPointer; + int vkCmdCopyBufferToImage_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdCopyBufferToImage_CallInstance; + char vkCmdCopyImageToBuffer_IgnoreBool; + char vkCmdCopyImageToBuffer_CallbackBool; + CMOCK_vkCmdCopyImageToBuffer_CALLBACK vkCmdCopyImageToBuffer_CallbackFunctionPointer; + int vkCmdCopyImageToBuffer_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdCopyImageToBuffer_CallInstance; + char vkCmdUpdateBuffer_IgnoreBool; + char vkCmdUpdateBuffer_CallbackBool; + CMOCK_vkCmdUpdateBuffer_CALLBACK vkCmdUpdateBuffer_CallbackFunctionPointer; + int vkCmdUpdateBuffer_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdUpdateBuffer_CallInstance; + char vkCmdFillBuffer_IgnoreBool; + char vkCmdFillBuffer_CallbackBool; + CMOCK_vkCmdFillBuffer_CALLBACK vkCmdFillBuffer_CallbackFunctionPointer; + int vkCmdFillBuffer_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdFillBuffer_CallInstance; + char vkCmdClearColorImage_IgnoreBool; + char vkCmdClearColorImage_CallbackBool; + CMOCK_vkCmdClearColorImage_CALLBACK vkCmdClearColorImage_CallbackFunctionPointer; + int vkCmdClearColorImage_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdClearColorImage_CallInstance; + char vkCmdClearDepthStencilImage_IgnoreBool; + char vkCmdClearDepthStencilImage_CallbackBool; + CMOCK_vkCmdClearDepthStencilImage_CALLBACK vkCmdClearDepthStencilImage_CallbackFunctionPointer; + int vkCmdClearDepthStencilImage_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdClearDepthStencilImage_CallInstance; + char vkCmdClearAttachments_IgnoreBool; + char vkCmdClearAttachments_CallbackBool; + CMOCK_vkCmdClearAttachments_CALLBACK vkCmdClearAttachments_CallbackFunctionPointer; + int vkCmdClearAttachments_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdClearAttachments_CallInstance; + char vkCmdResolveImage_IgnoreBool; + char vkCmdResolveImage_CallbackBool; + CMOCK_vkCmdResolveImage_CALLBACK vkCmdResolveImage_CallbackFunctionPointer; + int vkCmdResolveImage_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdResolveImage_CallInstance; + char vkCmdSetEvent_IgnoreBool; + char vkCmdSetEvent_CallbackBool; + CMOCK_vkCmdSetEvent_CALLBACK vkCmdSetEvent_CallbackFunctionPointer; + int vkCmdSetEvent_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetEvent_CallInstance; + char vkCmdResetEvent_IgnoreBool; + char vkCmdResetEvent_CallbackBool; + CMOCK_vkCmdResetEvent_CALLBACK vkCmdResetEvent_CallbackFunctionPointer; + int vkCmdResetEvent_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdResetEvent_CallInstance; + char vkCmdWaitEvents_IgnoreBool; + char vkCmdWaitEvents_CallbackBool; + CMOCK_vkCmdWaitEvents_CALLBACK vkCmdWaitEvents_CallbackFunctionPointer; + int vkCmdWaitEvents_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdWaitEvents_CallInstance; + char vkCmdPipelineBarrier_IgnoreBool; + char vkCmdPipelineBarrier_CallbackBool; + CMOCK_vkCmdPipelineBarrier_CALLBACK vkCmdPipelineBarrier_CallbackFunctionPointer; + int vkCmdPipelineBarrier_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdPipelineBarrier_CallInstance; + char vkCmdBeginQuery_IgnoreBool; + char vkCmdBeginQuery_CallbackBool; + CMOCK_vkCmdBeginQuery_CALLBACK vkCmdBeginQuery_CallbackFunctionPointer; + int vkCmdBeginQuery_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBeginQuery_CallInstance; + char vkCmdEndQuery_IgnoreBool; + char vkCmdEndQuery_CallbackBool; + CMOCK_vkCmdEndQuery_CALLBACK vkCmdEndQuery_CallbackFunctionPointer; + int vkCmdEndQuery_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdEndQuery_CallInstance; + char vkCmdResetQueryPool_IgnoreBool; + char vkCmdResetQueryPool_CallbackBool; + CMOCK_vkCmdResetQueryPool_CALLBACK vkCmdResetQueryPool_CallbackFunctionPointer; + int vkCmdResetQueryPool_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdResetQueryPool_CallInstance; + char vkCmdWriteTimestamp_IgnoreBool; + char vkCmdWriteTimestamp_CallbackBool; + CMOCK_vkCmdWriteTimestamp_CALLBACK vkCmdWriteTimestamp_CallbackFunctionPointer; + int vkCmdWriteTimestamp_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdWriteTimestamp_CallInstance; + char vkCmdCopyQueryPoolResults_IgnoreBool; + char vkCmdCopyQueryPoolResults_CallbackBool; + CMOCK_vkCmdCopyQueryPoolResults_CALLBACK vkCmdCopyQueryPoolResults_CallbackFunctionPointer; + int vkCmdCopyQueryPoolResults_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdCopyQueryPoolResults_CallInstance; + char vkCmdPushConstants_IgnoreBool; + char vkCmdPushConstants_CallbackBool; + CMOCK_vkCmdPushConstants_CALLBACK vkCmdPushConstants_CallbackFunctionPointer; + int vkCmdPushConstants_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdPushConstants_CallInstance; + char vkCmdBeginRenderPass_IgnoreBool; + char vkCmdBeginRenderPass_CallbackBool; + CMOCK_vkCmdBeginRenderPass_CALLBACK vkCmdBeginRenderPass_CallbackFunctionPointer; + int vkCmdBeginRenderPass_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBeginRenderPass_CallInstance; + char vkCmdNextSubpass_IgnoreBool; + char vkCmdNextSubpass_CallbackBool; + CMOCK_vkCmdNextSubpass_CALLBACK vkCmdNextSubpass_CallbackFunctionPointer; + int vkCmdNextSubpass_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdNextSubpass_CallInstance; + char vkCmdEndRenderPass_IgnoreBool; + char vkCmdEndRenderPass_CallbackBool; + CMOCK_vkCmdEndRenderPass_CALLBACK vkCmdEndRenderPass_CallbackFunctionPointer; + int vkCmdEndRenderPass_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdEndRenderPass_CallInstance; + char vkCmdExecuteCommands_IgnoreBool; + char vkCmdExecuteCommands_CallbackBool; + CMOCK_vkCmdExecuteCommands_CALLBACK vkCmdExecuteCommands_CallbackFunctionPointer; + int vkCmdExecuteCommands_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdExecuteCommands_CallInstance; + char vkEnumerateInstanceVersion_IgnoreBool; + VkResult vkEnumerateInstanceVersion_FinalReturn; + char vkEnumerateInstanceVersion_CallbackBool; + CMOCK_vkEnumerateInstanceVersion_CALLBACK vkEnumerateInstanceVersion_CallbackFunctionPointer; + int vkEnumerateInstanceVersion_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkEnumerateInstanceVersion_CallInstance; + char vkBindBufferMemory2_IgnoreBool; + VkResult vkBindBufferMemory2_FinalReturn; + char vkBindBufferMemory2_CallbackBool; + CMOCK_vkBindBufferMemory2_CALLBACK vkBindBufferMemory2_CallbackFunctionPointer; + int vkBindBufferMemory2_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkBindBufferMemory2_CallInstance; + char vkBindImageMemory2_IgnoreBool; + VkResult vkBindImageMemory2_FinalReturn; + char vkBindImageMemory2_CallbackBool; + CMOCK_vkBindImageMemory2_CALLBACK vkBindImageMemory2_CallbackFunctionPointer; + int vkBindImageMemory2_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkBindImageMemory2_CallInstance; + char vkGetDeviceGroupPeerMemoryFeatures_IgnoreBool; + char vkGetDeviceGroupPeerMemoryFeatures_CallbackBool; + CMOCK_vkGetDeviceGroupPeerMemoryFeatures_CALLBACK vkGetDeviceGroupPeerMemoryFeatures_CallbackFunctionPointer; + int vkGetDeviceGroupPeerMemoryFeatures_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDeviceGroupPeerMemoryFeatures_CallInstance; + char vkCmdSetDeviceMask_IgnoreBool; + char vkCmdSetDeviceMask_CallbackBool; + CMOCK_vkCmdSetDeviceMask_CALLBACK vkCmdSetDeviceMask_CallbackFunctionPointer; + int vkCmdSetDeviceMask_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetDeviceMask_CallInstance; + char vkCmdDispatchBase_IgnoreBool; + char vkCmdDispatchBase_CallbackBool; + CMOCK_vkCmdDispatchBase_CALLBACK vkCmdDispatchBase_CallbackFunctionPointer; + int vkCmdDispatchBase_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDispatchBase_CallInstance; + char vkEnumeratePhysicalDeviceGroups_IgnoreBool; + VkResult vkEnumeratePhysicalDeviceGroups_FinalReturn; + char vkEnumeratePhysicalDeviceGroups_CallbackBool; + CMOCK_vkEnumeratePhysicalDeviceGroups_CALLBACK vkEnumeratePhysicalDeviceGroups_CallbackFunctionPointer; + int vkEnumeratePhysicalDeviceGroups_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkEnumeratePhysicalDeviceGroups_CallInstance; + char vkGetImageMemoryRequirements2_IgnoreBool; + char vkGetImageMemoryRequirements2_CallbackBool; + CMOCK_vkGetImageMemoryRequirements2_CALLBACK vkGetImageMemoryRequirements2_CallbackFunctionPointer; + int vkGetImageMemoryRequirements2_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetImageMemoryRequirements2_CallInstance; + char vkGetBufferMemoryRequirements2_IgnoreBool; + char vkGetBufferMemoryRequirements2_CallbackBool; + CMOCK_vkGetBufferMemoryRequirements2_CALLBACK vkGetBufferMemoryRequirements2_CallbackFunctionPointer; + int vkGetBufferMemoryRequirements2_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetBufferMemoryRequirements2_CallInstance; + char vkGetImageSparseMemoryRequirements2_IgnoreBool; + char vkGetImageSparseMemoryRequirements2_CallbackBool; + CMOCK_vkGetImageSparseMemoryRequirements2_CALLBACK vkGetImageSparseMemoryRequirements2_CallbackFunctionPointer; + int vkGetImageSparseMemoryRequirements2_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetImageSparseMemoryRequirements2_CallInstance; + char vkGetPhysicalDeviceFeatures2_IgnoreBool; + char vkGetPhysicalDeviceFeatures2_CallbackBool; + CMOCK_vkGetPhysicalDeviceFeatures2_CALLBACK vkGetPhysicalDeviceFeatures2_CallbackFunctionPointer; + int vkGetPhysicalDeviceFeatures2_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceFeatures2_CallInstance; + char vkGetPhysicalDeviceProperties2_IgnoreBool; + char vkGetPhysicalDeviceProperties2_CallbackBool; + CMOCK_vkGetPhysicalDeviceProperties2_CALLBACK vkGetPhysicalDeviceProperties2_CallbackFunctionPointer; + int vkGetPhysicalDeviceProperties2_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceProperties2_CallInstance; + char vkGetPhysicalDeviceFormatProperties2_IgnoreBool; + char vkGetPhysicalDeviceFormatProperties2_CallbackBool; + CMOCK_vkGetPhysicalDeviceFormatProperties2_CALLBACK vkGetPhysicalDeviceFormatProperties2_CallbackFunctionPointer; + int vkGetPhysicalDeviceFormatProperties2_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceFormatProperties2_CallInstance; + char vkGetPhysicalDeviceImageFormatProperties2_IgnoreBool; + VkResult vkGetPhysicalDeviceImageFormatProperties2_FinalReturn; + char vkGetPhysicalDeviceImageFormatProperties2_CallbackBool; + CMOCK_vkGetPhysicalDeviceImageFormatProperties2_CALLBACK vkGetPhysicalDeviceImageFormatProperties2_CallbackFunctionPointer; + int vkGetPhysicalDeviceImageFormatProperties2_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceImageFormatProperties2_CallInstance; + char vkGetPhysicalDeviceQueueFamilyProperties2_IgnoreBool; + char vkGetPhysicalDeviceQueueFamilyProperties2_CallbackBool; + CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2_CALLBACK vkGetPhysicalDeviceQueueFamilyProperties2_CallbackFunctionPointer; + int vkGetPhysicalDeviceQueueFamilyProperties2_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceQueueFamilyProperties2_CallInstance; + char vkGetPhysicalDeviceMemoryProperties2_IgnoreBool; + char vkGetPhysicalDeviceMemoryProperties2_CallbackBool; + CMOCK_vkGetPhysicalDeviceMemoryProperties2_CALLBACK vkGetPhysicalDeviceMemoryProperties2_CallbackFunctionPointer; + int vkGetPhysicalDeviceMemoryProperties2_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceMemoryProperties2_CallInstance; + char vkGetPhysicalDeviceSparseImageFormatProperties2_IgnoreBool; + char vkGetPhysicalDeviceSparseImageFormatProperties2_CallbackBool; + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2_CALLBACK vkGetPhysicalDeviceSparseImageFormatProperties2_CallbackFunctionPointer; + int vkGetPhysicalDeviceSparseImageFormatProperties2_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceSparseImageFormatProperties2_CallInstance; + char vkTrimCommandPool_IgnoreBool; + char vkTrimCommandPool_CallbackBool; + CMOCK_vkTrimCommandPool_CALLBACK vkTrimCommandPool_CallbackFunctionPointer; + int vkTrimCommandPool_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkTrimCommandPool_CallInstance; + char vkGetDeviceQueue2_IgnoreBool; + char vkGetDeviceQueue2_CallbackBool; + CMOCK_vkGetDeviceQueue2_CALLBACK vkGetDeviceQueue2_CallbackFunctionPointer; + int vkGetDeviceQueue2_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDeviceQueue2_CallInstance; + char vkCreateSamplerYcbcrConversion_IgnoreBool; + VkResult vkCreateSamplerYcbcrConversion_FinalReturn; + char vkCreateSamplerYcbcrConversion_CallbackBool; + CMOCK_vkCreateSamplerYcbcrConversion_CALLBACK vkCreateSamplerYcbcrConversion_CallbackFunctionPointer; + int vkCreateSamplerYcbcrConversion_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateSamplerYcbcrConversion_CallInstance; + char vkDestroySamplerYcbcrConversion_IgnoreBool; + char vkDestroySamplerYcbcrConversion_CallbackBool; + CMOCK_vkDestroySamplerYcbcrConversion_CALLBACK vkDestroySamplerYcbcrConversion_CallbackFunctionPointer; + int vkDestroySamplerYcbcrConversion_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroySamplerYcbcrConversion_CallInstance; + char vkCreateDescriptorUpdateTemplate_IgnoreBool; + VkResult vkCreateDescriptorUpdateTemplate_FinalReturn; + char vkCreateDescriptorUpdateTemplate_CallbackBool; + CMOCK_vkCreateDescriptorUpdateTemplate_CALLBACK vkCreateDescriptorUpdateTemplate_CallbackFunctionPointer; + int vkCreateDescriptorUpdateTemplate_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateDescriptorUpdateTemplate_CallInstance; + char vkDestroyDescriptorUpdateTemplate_IgnoreBool; + char vkDestroyDescriptorUpdateTemplate_CallbackBool; + CMOCK_vkDestroyDescriptorUpdateTemplate_CALLBACK vkDestroyDescriptorUpdateTemplate_CallbackFunctionPointer; + int vkDestroyDescriptorUpdateTemplate_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyDescriptorUpdateTemplate_CallInstance; + char vkUpdateDescriptorSetWithTemplate_IgnoreBool; + char vkUpdateDescriptorSetWithTemplate_CallbackBool; + CMOCK_vkUpdateDescriptorSetWithTemplate_CALLBACK vkUpdateDescriptorSetWithTemplate_CallbackFunctionPointer; + int vkUpdateDescriptorSetWithTemplate_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkUpdateDescriptorSetWithTemplate_CallInstance; + char vkGetPhysicalDeviceExternalBufferProperties_IgnoreBool; + char vkGetPhysicalDeviceExternalBufferProperties_CallbackBool; + CMOCK_vkGetPhysicalDeviceExternalBufferProperties_CALLBACK vkGetPhysicalDeviceExternalBufferProperties_CallbackFunctionPointer; + int vkGetPhysicalDeviceExternalBufferProperties_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceExternalBufferProperties_CallInstance; + char vkGetPhysicalDeviceExternalFenceProperties_IgnoreBool; + char vkGetPhysicalDeviceExternalFenceProperties_CallbackBool; + CMOCK_vkGetPhysicalDeviceExternalFenceProperties_CALLBACK vkGetPhysicalDeviceExternalFenceProperties_CallbackFunctionPointer; + int vkGetPhysicalDeviceExternalFenceProperties_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceExternalFenceProperties_CallInstance; + char vkGetPhysicalDeviceExternalSemaphoreProperties_IgnoreBool; + char vkGetPhysicalDeviceExternalSemaphoreProperties_CallbackBool; + CMOCK_vkGetPhysicalDeviceExternalSemaphoreProperties_CALLBACK vkGetPhysicalDeviceExternalSemaphoreProperties_CallbackFunctionPointer; + int vkGetPhysicalDeviceExternalSemaphoreProperties_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceExternalSemaphoreProperties_CallInstance; + char vkGetDescriptorSetLayoutSupport_IgnoreBool; + char vkGetDescriptorSetLayoutSupport_CallbackBool; + CMOCK_vkGetDescriptorSetLayoutSupport_CALLBACK vkGetDescriptorSetLayoutSupport_CallbackFunctionPointer; + int vkGetDescriptorSetLayoutSupport_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDescriptorSetLayoutSupport_CallInstance; + char vkCmdDrawIndirectCount_IgnoreBool; + char vkCmdDrawIndirectCount_CallbackBool; + CMOCK_vkCmdDrawIndirectCount_CALLBACK vkCmdDrawIndirectCount_CallbackFunctionPointer; + int vkCmdDrawIndirectCount_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDrawIndirectCount_CallInstance; + char vkCmdDrawIndexedIndirectCount_IgnoreBool; + char vkCmdDrawIndexedIndirectCount_CallbackBool; + CMOCK_vkCmdDrawIndexedIndirectCount_CALLBACK vkCmdDrawIndexedIndirectCount_CallbackFunctionPointer; + int vkCmdDrawIndexedIndirectCount_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDrawIndexedIndirectCount_CallInstance; + char vkCreateRenderPass2_IgnoreBool; + VkResult vkCreateRenderPass2_FinalReturn; + char vkCreateRenderPass2_CallbackBool; + CMOCK_vkCreateRenderPass2_CALLBACK vkCreateRenderPass2_CallbackFunctionPointer; + int vkCreateRenderPass2_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateRenderPass2_CallInstance; + char vkCmdBeginRenderPass2_IgnoreBool; + char vkCmdBeginRenderPass2_CallbackBool; + CMOCK_vkCmdBeginRenderPass2_CALLBACK vkCmdBeginRenderPass2_CallbackFunctionPointer; + int vkCmdBeginRenderPass2_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBeginRenderPass2_CallInstance; + char vkCmdNextSubpass2_IgnoreBool; + char vkCmdNextSubpass2_CallbackBool; + CMOCK_vkCmdNextSubpass2_CALLBACK vkCmdNextSubpass2_CallbackFunctionPointer; + int vkCmdNextSubpass2_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdNextSubpass2_CallInstance; + char vkCmdEndRenderPass2_IgnoreBool; + char vkCmdEndRenderPass2_CallbackBool; + CMOCK_vkCmdEndRenderPass2_CALLBACK vkCmdEndRenderPass2_CallbackFunctionPointer; + int vkCmdEndRenderPass2_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdEndRenderPass2_CallInstance; + char vkResetQueryPool_IgnoreBool; + char vkResetQueryPool_CallbackBool; + CMOCK_vkResetQueryPool_CALLBACK vkResetQueryPool_CallbackFunctionPointer; + int vkResetQueryPool_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkResetQueryPool_CallInstance; + char vkGetSemaphoreCounterValue_IgnoreBool; + VkResult vkGetSemaphoreCounterValue_FinalReturn; + char vkGetSemaphoreCounterValue_CallbackBool; + CMOCK_vkGetSemaphoreCounterValue_CALLBACK vkGetSemaphoreCounterValue_CallbackFunctionPointer; + int vkGetSemaphoreCounterValue_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetSemaphoreCounterValue_CallInstance; + char vkWaitSemaphores_IgnoreBool; + VkResult vkWaitSemaphores_FinalReturn; + char vkWaitSemaphores_CallbackBool; + CMOCK_vkWaitSemaphores_CALLBACK vkWaitSemaphores_CallbackFunctionPointer; + int vkWaitSemaphores_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkWaitSemaphores_CallInstance; + char vkSignalSemaphore_IgnoreBool; + VkResult vkSignalSemaphore_FinalReturn; + char vkSignalSemaphore_CallbackBool; + CMOCK_vkSignalSemaphore_CALLBACK vkSignalSemaphore_CallbackFunctionPointer; + int vkSignalSemaphore_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkSignalSemaphore_CallInstance; + char vkGetBufferDeviceAddress_IgnoreBool; + VkDeviceAddress vkGetBufferDeviceAddress_FinalReturn; + char vkGetBufferDeviceAddress_CallbackBool; + CMOCK_vkGetBufferDeviceAddress_CALLBACK vkGetBufferDeviceAddress_CallbackFunctionPointer; + int vkGetBufferDeviceAddress_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetBufferDeviceAddress_CallInstance; + char vkGetBufferOpaqueCaptureAddress_IgnoreBool; + uint64_t vkGetBufferOpaqueCaptureAddress_FinalReturn; + char vkGetBufferOpaqueCaptureAddress_CallbackBool; + CMOCK_vkGetBufferOpaqueCaptureAddress_CALLBACK vkGetBufferOpaqueCaptureAddress_CallbackFunctionPointer; + int vkGetBufferOpaqueCaptureAddress_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetBufferOpaqueCaptureAddress_CallInstance; + char vkGetDeviceMemoryOpaqueCaptureAddress_IgnoreBool; + uint64_t vkGetDeviceMemoryOpaqueCaptureAddress_FinalReturn; + char vkGetDeviceMemoryOpaqueCaptureAddress_CallbackBool; + CMOCK_vkGetDeviceMemoryOpaqueCaptureAddress_CALLBACK vkGetDeviceMemoryOpaqueCaptureAddress_CallbackFunctionPointer; + int vkGetDeviceMemoryOpaqueCaptureAddress_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDeviceMemoryOpaqueCaptureAddress_CallInstance; + char vkGetPhysicalDeviceToolProperties_IgnoreBool; + VkResult vkGetPhysicalDeviceToolProperties_FinalReturn; + char vkGetPhysicalDeviceToolProperties_CallbackBool; + CMOCK_vkGetPhysicalDeviceToolProperties_CALLBACK vkGetPhysicalDeviceToolProperties_CallbackFunctionPointer; + int vkGetPhysicalDeviceToolProperties_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceToolProperties_CallInstance; + char vkCreatePrivateDataSlot_IgnoreBool; + VkResult vkCreatePrivateDataSlot_FinalReturn; + char vkCreatePrivateDataSlot_CallbackBool; + CMOCK_vkCreatePrivateDataSlot_CALLBACK vkCreatePrivateDataSlot_CallbackFunctionPointer; + int vkCreatePrivateDataSlot_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreatePrivateDataSlot_CallInstance; + char vkDestroyPrivateDataSlot_IgnoreBool; + char vkDestroyPrivateDataSlot_CallbackBool; + CMOCK_vkDestroyPrivateDataSlot_CALLBACK vkDestroyPrivateDataSlot_CallbackFunctionPointer; + int vkDestroyPrivateDataSlot_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyPrivateDataSlot_CallInstance; + char vkSetPrivateData_IgnoreBool; + VkResult vkSetPrivateData_FinalReturn; + char vkSetPrivateData_CallbackBool; + CMOCK_vkSetPrivateData_CALLBACK vkSetPrivateData_CallbackFunctionPointer; + int vkSetPrivateData_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkSetPrivateData_CallInstance; + char vkGetPrivateData_IgnoreBool; + char vkGetPrivateData_CallbackBool; + CMOCK_vkGetPrivateData_CALLBACK vkGetPrivateData_CallbackFunctionPointer; + int vkGetPrivateData_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPrivateData_CallInstance; + char vkCmdSetEvent2_IgnoreBool; + char vkCmdSetEvent2_CallbackBool; + CMOCK_vkCmdSetEvent2_CALLBACK vkCmdSetEvent2_CallbackFunctionPointer; + int vkCmdSetEvent2_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetEvent2_CallInstance; + char vkCmdResetEvent2_IgnoreBool; + char vkCmdResetEvent2_CallbackBool; + CMOCK_vkCmdResetEvent2_CALLBACK vkCmdResetEvent2_CallbackFunctionPointer; + int vkCmdResetEvent2_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdResetEvent2_CallInstance; + char vkCmdWaitEvents2_IgnoreBool; + char vkCmdWaitEvents2_CallbackBool; + CMOCK_vkCmdWaitEvents2_CALLBACK vkCmdWaitEvents2_CallbackFunctionPointer; + int vkCmdWaitEvents2_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdWaitEvents2_CallInstance; + char vkCmdPipelineBarrier2_IgnoreBool; + char vkCmdPipelineBarrier2_CallbackBool; + CMOCK_vkCmdPipelineBarrier2_CALLBACK vkCmdPipelineBarrier2_CallbackFunctionPointer; + int vkCmdPipelineBarrier2_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdPipelineBarrier2_CallInstance; + char vkCmdWriteTimestamp2_IgnoreBool; + char vkCmdWriteTimestamp2_CallbackBool; + CMOCK_vkCmdWriteTimestamp2_CALLBACK vkCmdWriteTimestamp2_CallbackFunctionPointer; + int vkCmdWriteTimestamp2_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdWriteTimestamp2_CallInstance; + char vkQueueSubmit2_IgnoreBool; + VkResult vkQueueSubmit2_FinalReturn; + char vkQueueSubmit2_CallbackBool; + CMOCK_vkQueueSubmit2_CALLBACK vkQueueSubmit2_CallbackFunctionPointer; + int vkQueueSubmit2_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkQueueSubmit2_CallInstance; + char vkCmdCopyBuffer2_IgnoreBool; + char vkCmdCopyBuffer2_CallbackBool; + CMOCK_vkCmdCopyBuffer2_CALLBACK vkCmdCopyBuffer2_CallbackFunctionPointer; + int vkCmdCopyBuffer2_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdCopyBuffer2_CallInstance; + char vkCmdCopyImage2_IgnoreBool; + char vkCmdCopyImage2_CallbackBool; + CMOCK_vkCmdCopyImage2_CALLBACK vkCmdCopyImage2_CallbackFunctionPointer; + int vkCmdCopyImage2_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdCopyImage2_CallInstance; + char vkCmdCopyBufferToImage2_IgnoreBool; + char vkCmdCopyBufferToImage2_CallbackBool; + CMOCK_vkCmdCopyBufferToImage2_CALLBACK vkCmdCopyBufferToImage2_CallbackFunctionPointer; + int vkCmdCopyBufferToImage2_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdCopyBufferToImage2_CallInstance; + char vkCmdCopyImageToBuffer2_IgnoreBool; + char vkCmdCopyImageToBuffer2_CallbackBool; + CMOCK_vkCmdCopyImageToBuffer2_CALLBACK vkCmdCopyImageToBuffer2_CallbackFunctionPointer; + int vkCmdCopyImageToBuffer2_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdCopyImageToBuffer2_CallInstance; + char vkCmdBlitImage2_IgnoreBool; + char vkCmdBlitImage2_CallbackBool; + CMOCK_vkCmdBlitImage2_CALLBACK vkCmdBlitImage2_CallbackFunctionPointer; + int vkCmdBlitImage2_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBlitImage2_CallInstance; + char vkCmdResolveImage2_IgnoreBool; + char vkCmdResolveImage2_CallbackBool; + CMOCK_vkCmdResolveImage2_CALLBACK vkCmdResolveImage2_CallbackFunctionPointer; + int vkCmdResolveImage2_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdResolveImage2_CallInstance; + char vkCmdBeginRendering_IgnoreBool; + char vkCmdBeginRendering_CallbackBool; + CMOCK_vkCmdBeginRendering_CALLBACK vkCmdBeginRendering_CallbackFunctionPointer; + int vkCmdBeginRendering_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBeginRendering_CallInstance; + char vkCmdEndRendering_IgnoreBool; + char vkCmdEndRendering_CallbackBool; + CMOCK_vkCmdEndRendering_CALLBACK vkCmdEndRendering_CallbackFunctionPointer; + int vkCmdEndRendering_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdEndRendering_CallInstance; + char vkCmdSetCullMode_IgnoreBool; + char vkCmdSetCullMode_CallbackBool; + CMOCK_vkCmdSetCullMode_CALLBACK vkCmdSetCullMode_CallbackFunctionPointer; + int vkCmdSetCullMode_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetCullMode_CallInstance; + char vkCmdSetFrontFace_IgnoreBool; + char vkCmdSetFrontFace_CallbackBool; + CMOCK_vkCmdSetFrontFace_CALLBACK vkCmdSetFrontFace_CallbackFunctionPointer; + int vkCmdSetFrontFace_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetFrontFace_CallInstance; + char vkCmdSetPrimitiveTopology_IgnoreBool; + char vkCmdSetPrimitiveTopology_CallbackBool; + CMOCK_vkCmdSetPrimitiveTopology_CALLBACK vkCmdSetPrimitiveTopology_CallbackFunctionPointer; + int vkCmdSetPrimitiveTopology_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetPrimitiveTopology_CallInstance; + char vkCmdSetViewportWithCount_IgnoreBool; + char vkCmdSetViewportWithCount_CallbackBool; + CMOCK_vkCmdSetViewportWithCount_CALLBACK vkCmdSetViewportWithCount_CallbackFunctionPointer; + int vkCmdSetViewportWithCount_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetViewportWithCount_CallInstance; + char vkCmdSetScissorWithCount_IgnoreBool; + char vkCmdSetScissorWithCount_CallbackBool; + CMOCK_vkCmdSetScissorWithCount_CALLBACK vkCmdSetScissorWithCount_CallbackFunctionPointer; + int vkCmdSetScissorWithCount_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetScissorWithCount_CallInstance; + char vkCmdBindVertexBuffers2_IgnoreBool; + char vkCmdBindVertexBuffers2_CallbackBool; + CMOCK_vkCmdBindVertexBuffers2_CALLBACK vkCmdBindVertexBuffers2_CallbackFunctionPointer; + int vkCmdBindVertexBuffers2_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBindVertexBuffers2_CallInstance; + char vkCmdSetDepthTestEnable_IgnoreBool; + char vkCmdSetDepthTestEnable_CallbackBool; + CMOCK_vkCmdSetDepthTestEnable_CALLBACK vkCmdSetDepthTestEnable_CallbackFunctionPointer; + int vkCmdSetDepthTestEnable_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetDepthTestEnable_CallInstance; + char vkCmdSetDepthWriteEnable_IgnoreBool; + char vkCmdSetDepthWriteEnable_CallbackBool; + CMOCK_vkCmdSetDepthWriteEnable_CALLBACK vkCmdSetDepthWriteEnable_CallbackFunctionPointer; + int vkCmdSetDepthWriteEnable_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetDepthWriteEnable_CallInstance; + char vkCmdSetDepthCompareOp_IgnoreBool; + char vkCmdSetDepthCompareOp_CallbackBool; + CMOCK_vkCmdSetDepthCompareOp_CALLBACK vkCmdSetDepthCompareOp_CallbackFunctionPointer; + int vkCmdSetDepthCompareOp_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetDepthCompareOp_CallInstance; + char vkCmdSetDepthBoundsTestEnable_IgnoreBool; + char vkCmdSetDepthBoundsTestEnable_CallbackBool; + CMOCK_vkCmdSetDepthBoundsTestEnable_CALLBACK vkCmdSetDepthBoundsTestEnable_CallbackFunctionPointer; + int vkCmdSetDepthBoundsTestEnable_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetDepthBoundsTestEnable_CallInstance; + char vkCmdSetStencilTestEnable_IgnoreBool; + char vkCmdSetStencilTestEnable_CallbackBool; + CMOCK_vkCmdSetStencilTestEnable_CALLBACK vkCmdSetStencilTestEnable_CallbackFunctionPointer; + int vkCmdSetStencilTestEnable_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetStencilTestEnable_CallInstance; + char vkCmdSetStencilOp_IgnoreBool; + char vkCmdSetStencilOp_CallbackBool; + CMOCK_vkCmdSetStencilOp_CALLBACK vkCmdSetStencilOp_CallbackFunctionPointer; + int vkCmdSetStencilOp_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetStencilOp_CallInstance; + char vkCmdSetRasterizerDiscardEnable_IgnoreBool; + char vkCmdSetRasterizerDiscardEnable_CallbackBool; + CMOCK_vkCmdSetRasterizerDiscardEnable_CALLBACK vkCmdSetRasterizerDiscardEnable_CallbackFunctionPointer; + int vkCmdSetRasterizerDiscardEnable_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetRasterizerDiscardEnable_CallInstance; + char vkCmdSetDepthBiasEnable_IgnoreBool; + char vkCmdSetDepthBiasEnable_CallbackBool; + CMOCK_vkCmdSetDepthBiasEnable_CALLBACK vkCmdSetDepthBiasEnable_CallbackFunctionPointer; + int vkCmdSetDepthBiasEnable_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetDepthBiasEnable_CallInstance; + char vkCmdSetPrimitiveRestartEnable_IgnoreBool; + char vkCmdSetPrimitiveRestartEnable_CallbackBool; + CMOCK_vkCmdSetPrimitiveRestartEnable_CALLBACK vkCmdSetPrimitiveRestartEnable_CallbackFunctionPointer; + int vkCmdSetPrimitiveRestartEnable_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetPrimitiveRestartEnable_CallInstance; + char vkGetDeviceBufferMemoryRequirements_IgnoreBool; + char vkGetDeviceBufferMemoryRequirements_CallbackBool; + CMOCK_vkGetDeviceBufferMemoryRequirements_CALLBACK vkGetDeviceBufferMemoryRequirements_CallbackFunctionPointer; + int vkGetDeviceBufferMemoryRequirements_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDeviceBufferMemoryRequirements_CallInstance; + char vkGetDeviceImageMemoryRequirements_IgnoreBool; + char vkGetDeviceImageMemoryRequirements_CallbackBool; + CMOCK_vkGetDeviceImageMemoryRequirements_CALLBACK vkGetDeviceImageMemoryRequirements_CallbackFunctionPointer; + int vkGetDeviceImageMemoryRequirements_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDeviceImageMemoryRequirements_CallInstance; + char vkGetDeviceImageSparseMemoryRequirements_IgnoreBool; + char vkGetDeviceImageSparseMemoryRequirements_CallbackBool; + CMOCK_vkGetDeviceImageSparseMemoryRequirements_CALLBACK vkGetDeviceImageSparseMemoryRequirements_CallbackFunctionPointer; + int vkGetDeviceImageSparseMemoryRequirements_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDeviceImageSparseMemoryRequirements_CallInstance; + char vkDestroySurfaceKHR_IgnoreBool; + char vkDestroySurfaceKHR_CallbackBool; + CMOCK_vkDestroySurfaceKHR_CALLBACK vkDestroySurfaceKHR_CallbackFunctionPointer; + int vkDestroySurfaceKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroySurfaceKHR_CallInstance; + char vkGetPhysicalDeviceSurfaceSupportKHR_IgnoreBool; + VkResult vkGetPhysicalDeviceSurfaceSupportKHR_FinalReturn; + char vkGetPhysicalDeviceSurfaceSupportKHR_CallbackBool; + CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALLBACK vkGetPhysicalDeviceSurfaceSupportKHR_CallbackFunctionPointer; + int vkGetPhysicalDeviceSurfaceSupportKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceSurfaceSupportKHR_CallInstance; + char vkGetPhysicalDeviceSurfaceCapabilitiesKHR_IgnoreBool; + VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR_FinalReturn; + char vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallbackBool; + CMOCK_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CALLBACK vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallbackFunctionPointer; + int vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallInstance; + char vkGetPhysicalDeviceSurfaceFormatsKHR_IgnoreBool; + VkResult vkGetPhysicalDeviceSurfaceFormatsKHR_FinalReturn; + char vkGetPhysicalDeviceSurfaceFormatsKHR_CallbackBool; + CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALLBACK vkGetPhysicalDeviceSurfaceFormatsKHR_CallbackFunctionPointer; + int vkGetPhysicalDeviceSurfaceFormatsKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceSurfaceFormatsKHR_CallInstance; + char vkGetPhysicalDeviceSurfacePresentModesKHR_IgnoreBool; + VkResult vkGetPhysicalDeviceSurfacePresentModesKHR_FinalReturn; + char vkGetPhysicalDeviceSurfacePresentModesKHR_CallbackBool; + CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALLBACK vkGetPhysicalDeviceSurfacePresentModesKHR_CallbackFunctionPointer; + int vkGetPhysicalDeviceSurfacePresentModesKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceSurfacePresentModesKHR_CallInstance; + char vkCreateSwapchainKHR_IgnoreBool; + VkResult vkCreateSwapchainKHR_FinalReturn; + char vkCreateSwapchainKHR_CallbackBool; + CMOCK_vkCreateSwapchainKHR_CALLBACK vkCreateSwapchainKHR_CallbackFunctionPointer; + int vkCreateSwapchainKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateSwapchainKHR_CallInstance; + char vkDestroySwapchainKHR_IgnoreBool; + char vkDestroySwapchainKHR_CallbackBool; + CMOCK_vkDestroySwapchainKHR_CALLBACK vkDestroySwapchainKHR_CallbackFunctionPointer; + int vkDestroySwapchainKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroySwapchainKHR_CallInstance; + char vkGetSwapchainImagesKHR_IgnoreBool; + VkResult vkGetSwapchainImagesKHR_FinalReturn; + char vkGetSwapchainImagesKHR_CallbackBool; + CMOCK_vkGetSwapchainImagesKHR_CALLBACK vkGetSwapchainImagesKHR_CallbackFunctionPointer; + int vkGetSwapchainImagesKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetSwapchainImagesKHR_CallInstance; + char vkAcquireNextImageKHR_IgnoreBool; + VkResult vkAcquireNextImageKHR_FinalReturn; + char vkAcquireNextImageKHR_CallbackBool; + CMOCK_vkAcquireNextImageKHR_CALLBACK vkAcquireNextImageKHR_CallbackFunctionPointer; + int vkAcquireNextImageKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkAcquireNextImageKHR_CallInstance; + char vkQueuePresentKHR_IgnoreBool; + VkResult vkQueuePresentKHR_FinalReturn; + char vkQueuePresentKHR_CallbackBool; + CMOCK_vkQueuePresentKHR_CALLBACK vkQueuePresentKHR_CallbackFunctionPointer; + int vkQueuePresentKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkQueuePresentKHR_CallInstance; + char vkGetDeviceGroupPresentCapabilitiesKHR_IgnoreBool; + VkResult vkGetDeviceGroupPresentCapabilitiesKHR_FinalReturn; + char vkGetDeviceGroupPresentCapabilitiesKHR_CallbackBool; + CMOCK_vkGetDeviceGroupPresentCapabilitiesKHR_CALLBACK vkGetDeviceGroupPresentCapabilitiesKHR_CallbackFunctionPointer; + int vkGetDeviceGroupPresentCapabilitiesKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDeviceGroupPresentCapabilitiesKHR_CallInstance; + char vkGetDeviceGroupSurfacePresentModesKHR_IgnoreBool; + VkResult vkGetDeviceGroupSurfacePresentModesKHR_FinalReturn; + char vkGetDeviceGroupSurfacePresentModesKHR_CallbackBool; + CMOCK_vkGetDeviceGroupSurfacePresentModesKHR_CALLBACK vkGetDeviceGroupSurfacePresentModesKHR_CallbackFunctionPointer; + int vkGetDeviceGroupSurfacePresentModesKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDeviceGroupSurfacePresentModesKHR_CallInstance; + char vkGetPhysicalDevicePresentRectanglesKHR_IgnoreBool; + VkResult vkGetPhysicalDevicePresentRectanglesKHR_FinalReturn; + char vkGetPhysicalDevicePresentRectanglesKHR_CallbackBool; + CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALLBACK vkGetPhysicalDevicePresentRectanglesKHR_CallbackFunctionPointer; + int vkGetPhysicalDevicePresentRectanglesKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDevicePresentRectanglesKHR_CallInstance; + char vkAcquireNextImage2KHR_IgnoreBool; + VkResult vkAcquireNextImage2KHR_FinalReturn; + char vkAcquireNextImage2KHR_CallbackBool; + CMOCK_vkAcquireNextImage2KHR_CALLBACK vkAcquireNextImage2KHR_CallbackFunctionPointer; + int vkAcquireNextImage2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkAcquireNextImage2KHR_CallInstance; + char vkGetPhysicalDeviceDisplayPropertiesKHR_IgnoreBool; + VkResult vkGetPhysicalDeviceDisplayPropertiesKHR_FinalReturn; + char vkGetPhysicalDeviceDisplayPropertiesKHR_CallbackBool; + CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALLBACK vkGetPhysicalDeviceDisplayPropertiesKHR_CallbackFunctionPointer; + int vkGetPhysicalDeviceDisplayPropertiesKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceDisplayPropertiesKHR_CallInstance; + char vkGetPhysicalDeviceDisplayPlanePropertiesKHR_IgnoreBool; + VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR_FinalReturn; + char vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallbackBool; + CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALLBACK vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallbackFunctionPointer; + int vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallInstance; + char vkGetDisplayPlaneSupportedDisplaysKHR_IgnoreBool; + VkResult vkGetDisplayPlaneSupportedDisplaysKHR_FinalReturn; + char vkGetDisplayPlaneSupportedDisplaysKHR_CallbackBool; + CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALLBACK vkGetDisplayPlaneSupportedDisplaysKHR_CallbackFunctionPointer; + int vkGetDisplayPlaneSupportedDisplaysKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDisplayPlaneSupportedDisplaysKHR_CallInstance; + char vkGetDisplayModePropertiesKHR_IgnoreBool; + VkResult vkGetDisplayModePropertiesKHR_FinalReturn; + char vkGetDisplayModePropertiesKHR_CallbackBool; + CMOCK_vkGetDisplayModePropertiesKHR_CALLBACK vkGetDisplayModePropertiesKHR_CallbackFunctionPointer; + int vkGetDisplayModePropertiesKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDisplayModePropertiesKHR_CallInstance; + char vkCreateDisplayModeKHR_IgnoreBool; + VkResult vkCreateDisplayModeKHR_FinalReturn; + char vkCreateDisplayModeKHR_CallbackBool; + CMOCK_vkCreateDisplayModeKHR_CALLBACK vkCreateDisplayModeKHR_CallbackFunctionPointer; + int vkCreateDisplayModeKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateDisplayModeKHR_CallInstance; + char vkGetDisplayPlaneCapabilitiesKHR_IgnoreBool; + VkResult vkGetDisplayPlaneCapabilitiesKHR_FinalReturn; + char vkGetDisplayPlaneCapabilitiesKHR_CallbackBool; + CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALLBACK vkGetDisplayPlaneCapabilitiesKHR_CallbackFunctionPointer; + int vkGetDisplayPlaneCapabilitiesKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDisplayPlaneCapabilitiesKHR_CallInstance; + char vkCreateDisplayPlaneSurfaceKHR_IgnoreBool; + VkResult vkCreateDisplayPlaneSurfaceKHR_FinalReturn; + char vkCreateDisplayPlaneSurfaceKHR_CallbackBool; + CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALLBACK vkCreateDisplayPlaneSurfaceKHR_CallbackFunctionPointer; + int vkCreateDisplayPlaneSurfaceKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateDisplayPlaneSurfaceKHR_CallInstance; + char vkCreateSharedSwapchainsKHR_IgnoreBool; + VkResult vkCreateSharedSwapchainsKHR_FinalReturn; + char vkCreateSharedSwapchainsKHR_CallbackBool; + CMOCK_vkCreateSharedSwapchainsKHR_CALLBACK vkCreateSharedSwapchainsKHR_CallbackFunctionPointer; + int vkCreateSharedSwapchainsKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateSharedSwapchainsKHR_CallInstance; + char vkGetPhysicalDeviceVideoCapabilitiesKHR_IgnoreBool; + VkResult vkGetPhysicalDeviceVideoCapabilitiesKHR_FinalReturn; + char vkGetPhysicalDeviceVideoCapabilitiesKHR_CallbackBool; + CMOCK_vkGetPhysicalDeviceVideoCapabilitiesKHR_CALLBACK vkGetPhysicalDeviceVideoCapabilitiesKHR_CallbackFunctionPointer; + int vkGetPhysicalDeviceVideoCapabilitiesKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceVideoCapabilitiesKHR_CallInstance; + char vkGetPhysicalDeviceVideoFormatPropertiesKHR_IgnoreBool; + VkResult vkGetPhysicalDeviceVideoFormatPropertiesKHR_FinalReturn; + char vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallbackBool; + CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALLBACK vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallbackFunctionPointer; + int vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallInstance; + char vkCreateVideoSessionKHR_IgnoreBool; + VkResult vkCreateVideoSessionKHR_FinalReturn; + char vkCreateVideoSessionKHR_CallbackBool; + CMOCK_vkCreateVideoSessionKHR_CALLBACK vkCreateVideoSessionKHR_CallbackFunctionPointer; + int vkCreateVideoSessionKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateVideoSessionKHR_CallInstance; + char vkDestroyVideoSessionKHR_IgnoreBool; + char vkDestroyVideoSessionKHR_CallbackBool; + CMOCK_vkDestroyVideoSessionKHR_CALLBACK vkDestroyVideoSessionKHR_CallbackFunctionPointer; + int vkDestroyVideoSessionKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyVideoSessionKHR_CallInstance; + char vkGetVideoSessionMemoryRequirementsKHR_IgnoreBool; + VkResult vkGetVideoSessionMemoryRequirementsKHR_FinalReturn; + char vkGetVideoSessionMemoryRequirementsKHR_CallbackBool; + CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALLBACK vkGetVideoSessionMemoryRequirementsKHR_CallbackFunctionPointer; + int vkGetVideoSessionMemoryRequirementsKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetVideoSessionMemoryRequirementsKHR_CallInstance; + char vkBindVideoSessionMemoryKHR_IgnoreBool; + VkResult vkBindVideoSessionMemoryKHR_FinalReturn; + char vkBindVideoSessionMemoryKHR_CallbackBool; + CMOCK_vkBindVideoSessionMemoryKHR_CALLBACK vkBindVideoSessionMemoryKHR_CallbackFunctionPointer; + int vkBindVideoSessionMemoryKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkBindVideoSessionMemoryKHR_CallInstance; + char vkCreateVideoSessionParametersKHR_IgnoreBool; + VkResult vkCreateVideoSessionParametersKHR_FinalReturn; + char vkCreateVideoSessionParametersKHR_CallbackBool; + CMOCK_vkCreateVideoSessionParametersKHR_CALLBACK vkCreateVideoSessionParametersKHR_CallbackFunctionPointer; + int vkCreateVideoSessionParametersKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateVideoSessionParametersKHR_CallInstance; + char vkUpdateVideoSessionParametersKHR_IgnoreBool; + VkResult vkUpdateVideoSessionParametersKHR_FinalReturn; + char vkUpdateVideoSessionParametersKHR_CallbackBool; + CMOCK_vkUpdateVideoSessionParametersKHR_CALLBACK vkUpdateVideoSessionParametersKHR_CallbackFunctionPointer; + int vkUpdateVideoSessionParametersKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkUpdateVideoSessionParametersKHR_CallInstance; + char vkDestroyVideoSessionParametersKHR_IgnoreBool; + char vkDestroyVideoSessionParametersKHR_CallbackBool; + CMOCK_vkDestroyVideoSessionParametersKHR_CALLBACK vkDestroyVideoSessionParametersKHR_CallbackFunctionPointer; + int vkDestroyVideoSessionParametersKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyVideoSessionParametersKHR_CallInstance; + char vkCmdBeginVideoCodingKHR_IgnoreBool; + char vkCmdBeginVideoCodingKHR_CallbackBool; + CMOCK_vkCmdBeginVideoCodingKHR_CALLBACK vkCmdBeginVideoCodingKHR_CallbackFunctionPointer; + int vkCmdBeginVideoCodingKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBeginVideoCodingKHR_CallInstance; + char vkCmdEndVideoCodingKHR_IgnoreBool; + char vkCmdEndVideoCodingKHR_CallbackBool; + CMOCK_vkCmdEndVideoCodingKHR_CALLBACK vkCmdEndVideoCodingKHR_CallbackFunctionPointer; + int vkCmdEndVideoCodingKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdEndVideoCodingKHR_CallInstance; + char vkCmdControlVideoCodingKHR_IgnoreBool; + char vkCmdControlVideoCodingKHR_CallbackBool; + CMOCK_vkCmdControlVideoCodingKHR_CALLBACK vkCmdControlVideoCodingKHR_CallbackFunctionPointer; + int vkCmdControlVideoCodingKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdControlVideoCodingKHR_CallInstance; + char vkCmdDecodeVideoKHR_IgnoreBool; + char vkCmdDecodeVideoKHR_CallbackBool; + CMOCK_vkCmdDecodeVideoKHR_CALLBACK vkCmdDecodeVideoKHR_CallbackFunctionPointer; + int vkCmdDecodeVideoKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDecodeVideoKHR_CallInstance; + char vkCmdBeginRenderingKHR_IgnoreBool; + char vkCmdBeginRenderingKHR_CallbackBool; + CMOCK_vkCmdBeginRenderingKHR_CALLBACK vkCmdBeginRenderingKHR_CallbackFunctionPointer; + int vkCmdBeginRenderingKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBeginRenderingKHR_CallInstance; + char vkCmdEndRenderingKHR_IgnoreBool; + char vkCmdEndRenderingKHR_CallbackBool; + CMOCK_vkCmdEndRenderingKHR_CALLBACK vkCmdEndRenderingKHR_CallbackFunctionPointer; + int vkCmdEndRenderingKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdEndRenderingKHR_CallInstance; + char vkGetPhysicalDeviceFeatures2KHR_IgnoreBool; + char vkGetPhysicalDeviceFeatures2KHR_CallbackBool; + CMOCK_vkGetPhysicalDeviceFeatures2KHR_CALLBACK vkGetPhysicalDeviceFeatures2KHR_CallbackFunctionPointer; + int vkGetPhysicalDeviceFeatures2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceFeatures2KHR_CallInstance; + char vkGetPhysicalDeviceProperties2KHR_IgnoreBool; + char vkGetPhysicalDeviceProperties2KHR_CallbackBool; + CMOCK_vkGetPhysicalDeviceProperties2KHR_CALLBACK vkGetPhysicalDeviceProperties2KHR_CallbackFunctionPointer; + int vkGetPhysicalDeviceProperties2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceProperties2KHR_CallInstance; + char vkGetPhysicalDeviceFormatProperties2KHR_IgnoreBool; + char vkGetPhysicalDeviceFormatProperties2KHR_CallbackBool; + CMOCK_vkGetPhysicalDeviceFormatProperties2KHR_CALLBACK vkGetPhysicalDeviceFormatProperties2KHR_CallbackFunctionPointer; + int vkGetPhysicalDeviceFormatProperties2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceFormatProperties2KHR_CallInstance; + char vkGetPhysicalDeviceImageFormatProperties2KHR_IgnoreBool; + VkResult vkGetPhysicalDeviceImageFormatProperties2KHR_FinalReturn; + char vkGetPhysicalDeviceImageFormatProperties2KHR_CallbackBool; + CMOCK_vkGetPhysicalDeviceImageFormatProperties2KHR_CALLBACK vkGetPhysicalDeviceImageFormatProperties2KHR_CallbackFunctionPointer; + int vkGetPhysicalDeviceImageFormatProperties2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceImageFormatProperties2KHR_CallInstance; + char vkGetPhysicalDeviceQueueFamilyProperties2KHR_IgnoreBool; + char vkGetPhysicalDeviceQueueFamilyProperties2KHR_CallbackBool; + CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2KHR_CALLBACK vkGetPhysicalDeviceQueueFamilyProperties2KHR_CallbackFunctionPointer; + int vkGetPhysicalDeviceQueueFamilyProperties2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceQueueFamilyProperties2KHR_CallInstance; + char vkGetPhysicalDeviceMemoryProperties2KHR_IgnoreBool; + char vkGetPhysicalDeviceMemoryProperties2KHR_CallbackBool; + CMOCK_vkGetPhysicalDeviceMemoryProperties2KHR_CALLBACK vkGetPhysicalDeviceMemoryProperties2KHR_CallbackFunctionPointer; + int vkGetPhysicalDeviceMemoryProperties2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceMemoryProperties2KHR_CallInstance; + char vkGetPhysicalDeviceSparseImageFormatProperties2KHR_IgnoreBool; + char vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CallbackBool; + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CALLBACK vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CallbackFunctionPointer; + int vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CallInstance; + char vkGetDeviceGroupPeerMemoryFeaturesKHR_IgnoreBool; + char vkGetDeviceGroupPeerMemoryFeaturesKHR_CallbackBool; + CMOCK_vkGetDeviceGroupPeerMemoryFeaturesKHR_CALLBACK vkGetDeviceGroupPeerMemoryFeaturesKHR_CallbackFunctionPointer; + int vkGetDeviceGroupPeerMemoryFeaturesKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDeviceGroupPeerMemoryFeaturesKHR_CallInstance; + char vkCmdSetDeviceMaskKHR_IgnoreBool; + char vkCmdSetDeviceMaskKHR_CallbackBool; + CMOCK_vkCmdSetDeviceMaskKHR_CALLBACK vkCmdSetDeviceMaskKHR_CallbackFunctionPointer; + int vkCmdSetDeviceMaskKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetDeviceMaskKHR_CallInstance; + char vkCmdDispatchBaseKHR_IgnoreBool; + char vkCmdDispatchBaseKHR_CallbackBool; + CMOCK_vkCmdDispatchBaseKHR_CALLBACK vkCmdDispatchBaseKHR_CallbackFunctionPointer; + int vkCmdDispatchBaseKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDispatchBaseKHR_CallInstance; + char vkTrimCommandPoolKHR_IgnoreBool; + char vkTrimCommandPoolKHR_CallbackBool; + CMOCK_vkTrimCommandPoolKHR_CALLBACK vkTrimCommandPoolKHR_CallbackFunctionPointer; + int vkTrimCommandPoolKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkTrimCommandPoolKHR_CallInstance; + char vkEnumeratePhysicalDeviceGroupsKHR_IgnoreBool; + VkResult vkEnumeratePhysicalDeviceGroupsKHR_FinalReturn; + char vkEnumeratePhysicalDeviceGroupsKHR_CallbackBool; + CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALLBACK vkEnumeratePhysicalDeviceGroupsKHR_CallbackFunctionPointer; + int vkEnumeratePhysicalDeviceGroupsKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkEnumeratePhysicalDeviceGroupsKHR_CallInstance; + char vkGetPhysicalDeviceExternalBufferPropertiesKHR_IgnoreBool; + char vkGetPhysicalDeviceExternalBufferPropertiesKHR_CallbackBool; + CMOCK_vkGetPhysicalDeviceExternalBufferPropertiesKHR_CALLBACK vkGetPhysicalDeviceExternalBufferPropertiesKHR_CallbackFunctionPointer; + int vkGetPhysicalDeviceExternalBufferPropertiesKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceExternalBufferPropertiesKHR_CallInstance; + char vkGetMemoryFdKHR_IgnoreBool; + VkResult vkGetMemoryFdKHR_FinalReturn; + char vkGetMemoryFdKHR_CallbackBool; + CMOCK_vkGetMemoryFdKHR_CALLBACK vkGetMemoryFdKHR_CallbackFunctionPointer; + int vkGetMemoryFdKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetMemoryFdKHR_CallInstance; + char vkGetMemoryFdPropertiesKHR_IgnoreBool; + VkResult vkGetMemoryFdPropertiesKHR_FinalReturn; + char vkGetMemoryFdPropertiesKHR_CallbackBool; + CMOCK_vkGetMemoryFdPropertiesKHR_CALLBACK vkGetMemoryFdPropertiesKHR_CallbackFunctionPointer; + int vkGetMemoryFdPropertiesKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetMemoryFdPropertiesKHR_CallInstance; + char vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_IgnoreBool; + char vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CallbackBool; + CMOCK_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CALLBACK vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CallbackFunctionPointer; + int vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CallInstance; + char vkImportSemaphoreFdKHR_IgnoreBool; + VkResult vkImportSemaphoreFdKHR_FinalReturn; + char vkImportSemaphoreFdKHR_CallbackBool; + CMOCK_vkImportSemaphoreFdKHR_CALLBACK vkImportSemaphoreFdKHR_CallbackFunctionPointer; + int vkImportSemaphoreFdKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkImportSemaphoreFdKHR_CallInstance; + char vkGetSemaphoreFdKHR_IgnoreBool; + VkResult vkGetSemaphoreFdKHR_FinalReturn; + char vkGetSemaphoreFdKHR_CallbackBool; + CMOCK_vkGetSemaphoreFdKHR_CALLBACK vkGetSemaphoreFdKHR_CallbackFunctionPointer; + int vkGetSemaphoreFdKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetSemaphoreFdKHR_CallInstance; + char vkCmdPushDescriptorSetKHR_IgnoreBool; + char vkCmdPushDescriptorSetKHR_CallbackBool; + CMOCK_vkCmdPushDescriptorSetKHR_CALLBACK vkCmdPushDescriptorSetKHR_CallbackFunctionPointer; + int vkCmdPushDescriptorSetKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdPushDescriptorSetKHR_CallInstance; + char vkCmdPushDescriptorSetWithTemplateKHR_IgnoreBool; + char vkCmdPushDescriptorSetWithTemplateKHR_CallbackBool; + CMOCK_vkCmdPushDescriptorSetWithTemplateKHR_CALLBACK vkCmdPushDescriptorSetWithTemplateKHR_CallbackFunctionPointer; + int vkCmdPushDescriptorSetWithTemplateKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdPushDescriptorSetWithTemplateKHR_CallInstance; + char vkCreateDescriptorUpdateTemplateKHR_IgnoreBool; + VkResult vkCreateDescriptorUpdateTemplateKHR_FinalReturn; + char vkCreateDescriptorUpdateTemplateKHR_CallbackBool; + CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALLBACK vkCreateDescriptorUpdateTemplateKHR_CallbackFunctionPointer; + int vkCreateDescriptorUpdateTemplateKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateDescriptorUpdateTemplateKHR_CallInstance; + char vkDestroyDescriptorUpdateTemplateKHR_IgnoreBool; + char vkDestroyDescriptorUpdateTemplateKHR_CallbackBool; + CMOCK_vkDestroyDescriptorUpdateTemplateKHR_CALLBACK vkDestroyDescriptorUpdateTemplateKHR_CallbackFunctionPointer; + int vkDestroyDescriptorUpdateTemplateKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyDescriptorUpdateTemplateKHR_CallInstance; + char vkUpdateDescriptorSetWithTemplateKHR_IgnoreBool; + char vkUpdateDescriptorSetWithTemplateKHR_CallbackBool; + CMOCK_vkUpdateDescriptorSetWithTemplateKHR_CALLBACK vkUpdateDescriptorSetWithTemplateKHR_CallbackFunctionPointer; + int vkUpdateDescriptorSetWithTemplateKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkUpdateDescriptorSetWithTemplateKHR_CallInstance; + char vkCreateRenderPass2KHR_IgnoreBool; + VkResult vkCreateRenderPass2KHR_FinalReturn; + char vkCreateRenderPass2KHR_CallbackBool; + CMOCK_vkCreateRenderPass2KHR_CALLBACK vkCreateRenderPass2KHR_CallbackFunctionPointer; + int vkCreateRenderPass2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateRenderPass2KHR_CallInstance; + char vkCmdBeginRenderPass2KHR_IgnoreBool; + char vkCmdBeginRenderPass2KHR_CallbackBool; + CMOCK_vkCmdBeginRenderPass2KHR_CALLBACK vkCmdBeginRenderPass2KHR_CallbackFunctionPointer; + int vkCmdBeginRenderPass2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBeginRenderPass2KHR_CallInstance; + char vkCmdNextSubpass2KHR_IgnoreBool; + char vkCmdNextSubpass2KHR_CallbackBool; + CMOCK_vkCmdNextSubpass2KHR_CALLBACK vkCmdNextSubpass2KHR_CallbackFunctionPointer; + int vkCmdNextSubpass2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdNextSubpass2KHR_CallInstance; + char vkCmdEndRenderPass2KHR_IgnoreBool; + char vkCmdEndRenderPass2KHR_CallbackBool; + CMOCK_vkCmdEndRenderPass2KHR_CALLBACK vkCmdEndRenderPass2KHR_CallbackFunctionPointer; + int vkCmdEndRenderPass2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdEndRenderPass2KHR_CallInstance; + char vkGetSwapchainStatusKHR_IgnoreBool; + VkResult vkGetSwapchainStatusKHR_FinalReturn; + char vkGetSwapchainStatusKHR_CallbackBool; + CMOCK_vkGetSwapchainStatusKHR_CALLBACK vkGetSwapchainStatusKHR_CallbackFunctionPointer; + int vkGetSwapchainStatusKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetSwapchainStatusKHR_CallInstance; + char vkGetPhysicalDeviceExternalFencePropertiesKHR_IgnoreBool; + char vkGetPhysicalDeviceExternalFencePropertiesKHR_CallbackBool; + CMOCK_vkGetPhysicalDeviceExternalFencePropertiesKHR_CALLBACK vkGetPhysicalDeviceExternalFencePropertiesKHR_CallbackFunctionPointer; + int vkGetPhysicalDeviceExternalFencePropertiesKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceExternalFencePropertiesKHR_CallInstance; + char vkImportFenceFdKHR_IgnoreBool; + VkResult vkImportFenceFdKHR_FinalReturn; + char vkImportFenceFdKHR_CallbackBool; + CMOCK_vkImportFenceFdKHR_CALLBACK vkImportFenceFdKHR_CallbackFunctionPointer; + int vkImportFenceFdKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkImportFenceFdKHR_CallInstance; + char vkGetFenceFdKHR_IgnoreBool; + VkResult vkGetFenceFdKHR_FinalReturn; + char vkGetFenceFdKHR_CallbackBool; + CMOCK_vkGetFenceFdKHR_CALLBACK vkGetFenceFdKHR_CallbackFunctionPointer; + int vkGetFenceFdKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetFenceFdKHR_CallInstance; + char vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_IgnoreBool; + VkResult vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_FinalReturn; + char vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallbackBool; + CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALLBACK vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallbackFunctionPointer; + int vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallInstance; + char vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_IgnoreBool; + char vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CallbackBool; + CMOCK_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CALLBACK vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CallbackFunctionPointer; + int vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CallInstance; + char vkAcquireProfilingLockKHR_IgnoreBool; + VkResult vkAcquireProfilingLockKHR_FinalReturn; + char vkAcquireProfilingLockKHR_CallbackBool; + CMOCK_vkAcquireProfilingLockKHR_CALLBACK vkAcquireProfilingLockKHR_CallbackFunctionPointer; + int vkAcquireProfilingLockKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkAcquireProfilingLockKHR_CallInstance; + char vkReleaseProfilingLockKHR_IgnoreBool; + char vkReleaseProfilingLockKHR_CallbackBool; + CMOCK_vkReleaseProfilingLockKHR_CALLBACK vkReleaseProfilingLockKHR_CallbackFunctionPointer; + int vkReleaseProfilingLockKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkReleaseProfilingLockKHR_CallInstance; + char vkGetPhysicalDeviceSurfaceCapabilities2KHR_IgnoreBool; + VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR_FinalReturn; + char vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallbackBool; + CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2KHR_CALLBACK vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallbackFunctionPointer; + int vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallInstance; + char vkGetPhysicalDeviceSurfaceFormats2KHR_IgnoreBool; + VkResult vkGetPhysicalDeviceSurfaceFormats2KHR_FinalReturn; + char vkGetPhysicalDeviceSurfaceFormats2KHR_CallbackBool; + CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALLBACK vkGetPhysicalDeviceSurfaceFormats2KHR_CallbackFunctionPointer; + int vkGetPhysicalDeviceSurfaceFormats2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceSurfaceFormats2KHR_CallInstance; + char vkGetPhysicalDeviceDisplayProperties2KHR_IgnoreBool; + VkResult vkGetPhysicalDeviceDisplayProperties2KHR_FinalReturn; + char vkGetPhysicalDeviceDisplayProperties2KHR_CallbackBool; + CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALLBACK vkGetPhysicalDeviceDisplayProperties2KHR_CallbackFunctionPointer; + int vkGetPhysicalDeviceDisplayProperties2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceDisplayProperties2KHR_CallInstance; + char vkGetPhysicalDeviceDisplayPlaneProperties2KHR_IgnoreBool; + VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR_FinalReturn; + char vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallbackBool; + CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALLBACK vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallbackFunctionPointer; + int vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallInstance; + char vkGetDisplayModeProperties2KHR_IgnoreBool; + VkResult vkGetDisplayModeProperties2KHR_FinalReturn; + char vkGetDisplayModeProperties2KHR_CallbackBool; + CMOCK_vkGetDisplayModeProperties2KHR_CALLBACK vkGetDisplayModeProperties2KHR_CallbackFunctionPointer; + int vkGetDisplayModeProperties2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDisplayModeProperties2KHR_CallInstance; + char vkGetDisplayPlaneCapabilities2KHR_IgnoreBool; + VkResult vkGetDisplayPlaneCapabilities2KHR_FinalReturn; + char vkGetDisplayPlaneCapabilities2KHR_CallbackBool; + CMOCK_vkGetDisplayPlaneCapabilities2KHR_CALLBACK vkGetDisplayPlaneCapabilities2KHR_CallbackFunctionPointer; + int vkGetDisplayPlaneCapabilities2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDisplayPlaneCapabilities2KHR_CallInstance; + char vkGetImageMemoryRequirements2KHR_IgnoreBool; + char vkGetImageMemoryRequirements2KHR_CallbackBool; + CMOCK_vkGetImageMemoryRequirements2KHR_CALLBACK vkGetImageMemoryRequirements2KHR_CallbackFunctionPointer; + int vkGetImageMemoryRequirements2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetImageMemoryRequirements2KHR_CallInstance; + char vkGetBufferMemoryRequirements2KHR_IgnoreBool; + char vkGetBufferMemoryRequirements2KHR_CallbackBool; + CMOCK_vkGetBufferMemoryRequirements2KHR_CALLBACK vkGetBufferMemoryRequirements2KHR_CallbackFunctionPointer; + int vkGetBufferMemoryRequirements2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetBufferMemoryRequirements2KHR_CallInstance; + char vkGetImageSparseMemoryRequirements2KHR_IgnoreBool; + char vkGetImageSparseMemoryRequirements2KHR_CallbackBool; + CMOCK_vkGetImageSparseMemoryRequirements2KHR_CALLBACK vkGetImageSparseMemoryRequirements2KHR_CallbackFunctionPointer; + int vkGetImageSparseMemoryRequirements2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetImageSparseMemoryRequirements2KHR_CallInstance; + char vkCreateSamplerYcbcrConversionKHR_IgnoreBool; + VkResult vkCreateSamplerYcbcrConversionKHR_FinalReturn; + char vkCreateSamplerYcbcrConversionKHR_CallbackBool; + CMOCK_vkCreateSamplerYcbcrConversionKHR_CALLBACK vkCreateSamplerYcbcrConversionKHR_CallbackFunctionPointer; + int vkCreateSamplerYcbcrConversionKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateSamplerYcbcrConversionKHR_CallInstance; + char vkDestroySamplerYcbcrConversionKHR_IgnoreBool; + char vkDestroySamplerYcbcrConversionKHR_CallbackBool; + CMOCK_vkDestroySamplerYcbcrConversionKHR_CALLBACK vkDestroySamplerYcbcrConversionKHR_CallbackFunctionPointer; + int vkDestroySamplerYcbcrConversionKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroySamplerYcbcrConversionKHR_CallInstance; + char vkBindBufferMemory2KHR_IgnoreBool; + VkResult vkBindBufferMemory2KHR_FinalReturn; + char vkBindBufferMemory2KHR_CallbackBool; + CMOCK_vkBindBufferMemory2KHR_CALLBACK vkBindBufferMemory2KHR_CallbackFunctionPointer; + int vkBindBufferMemory2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkBindBufferMemory2KHR_CallInstance; + char vkBindImageMemory2KHR_IgnoreBool; + VkResult vkBindImageMemory2KHR_FinalReturn; + char vkBindImageMemory2KHR_CallbackBool; + CMOCK_vkBindImageMemory2KHR_CALLBACK vkBindImageMemory2KHR_CallbackFunctionPointer; + int vkBindImageMemory2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkBindImageMemory2KHR_CallInstance; + char vkGetDescriptorSetLayoutSupportKHR_IgnoreBool; + char vkGetDescriptorSetLayoutSupportKHR_CallbackBool; + CMOCK_vkGetDescriptorSetLayoutSupportKHR_CALLBACK vkGetDescriptorSetLayoutSupportKHR_CallbackFunctionPointer; + int vkGetDescriptorSetLayoutSupportKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDescriptorSetLayoutSupportKHR_CallInstance; + char vkCmdDrawIndirectCountKHR_IgnoreBool; + char vkCmdDrawIndirectCountKHR_CallbackBool; + CMOCK_vkCmdDrawIndirectCountKHR_CALLBACK vkCmdDrawIndirectCountKHR_CallbackFunctionPointer; + int vkCmdDrawIndirectCountKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDrawIndirectCountKHR_CallInstance; + char vkCmdDrawIndexedIndirectCountKHR_IgnoreBool; + char vkCmdDrawIndexedIndirectCountKHR_CallbackBool; + CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALLBACK vkCmdDrawIndexedIndirectCountKHR_CallbackFunctionPointer; + int vkCmdDrawIndexedIndirectCountKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDrawIndexedIndirectCountKHR_CallInstance; + char vkGetSemaphoreCounterValueKHR_IgnoreBool; + VkResult vkGetSemaphoreCounterValueKHR_FinalReturn; + char vkGetSemaphoreCounterValueKHR_CallbackBool; + CMOCK_vkGetSemaphoreCounterValueKHR_CALLBACK vkGetSemaphoreCounterValueKHR_CallbackFunctionPointer; + int vkGetSemaphoreCounterValueKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetSemaphoreCounterValueKHR_CallInstance; + char vkWaitSemaphoresKHR_IgnoreBool; + VkResult vkWaitSemaphoresKHR_FinalReturn; + char vkWaitSemaphoresKHR_CallbackBool; + CMOCK_vkWaitSemaphoresKHR_CALLBACK vkWaitSemaphoresKHR_CallbackFunctionPointer; + int vkWaitSemaphoresKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkWaitSemaphoresKHR_CallInstance; + char vkSignalSemaphoreKHR_IgnoreBool; + VkResult vkSignalSemaphoreKHR_FinalReturn; + char vkSignalSemaphoreKHR_CallbackBool; + CMOCK_vkSignalSemaphoreKHR_CALLBACK vkSignalSemaphoreKHR_CallbackFunctionPointer; + int vkSignalSemaphoreKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkSignalSemaphoreKHR_CallInstance; + char vkGetPhysicalDeviceFragmentShadingRatesKHR_IgnoreBool; + VkResult vkGetPhysicalDeviceFragmentShadingRatesKHR_FinalReturn; + char vkGetPhysicalDeviceFragmentShadingRatesKHR_CallbackBool; + CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALLBACK vkGetPhysicalDeviceFragmentShadingRatesKHR_CallbackFunctionPointer; + int vkGetPhysicalDeviceFragmentShadingRatesKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceFragmentShadingRatesKHR_CallInstance; + char vkCmdSetFragmentShadingRateKHR_IgnoreBool; + char vkCmdSetFragmentShadingRateKHR_CallbackBool; + CMOCK_vkCmdSetFragmentShadingRateKHR_CALLBACK vkCmdSetFragmentShadingRateKHR_CallbackFunctionPointer; + int vkCmdSetFragmentShadingRateKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetFragmentShadingRateKHR_CallInstance; + char vkWaitForPresentKHR_IgnoreBool; + VkResult vkWaitForPresentKHR_FinalReturn; + char vkWaitForPresentKHR_CallbackBool; + CMOCK_vkWaitForPresentKHR_CALLBACK vkWaitForPresentKHR_CallbackFunctionPointer; + int vkWaitForPresentKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkWaitForPresentKHR_CallInstance; + char vkGetBufferDeviceAddressKHR_IgnoreBool; + VkDeviceAddress vkGetBufferDeviceAddressKHR_FinalReturn; + char vkGetBufferDeviceAddressKHR_CallbackBool; + CMOCK_vkGetBufferDeviceAddressKHR_CALLBACK vkGetBufferDeviceAddressKHR_CallbackFunctionPointer; + int vkGetBufferDeviceAddressKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetBufferDeviceAddressKHR_CallInstance; + char vkGetBufferOpaqueCaptureAddressKHR_IgnoreBool; + uint64_t vkGetBufferOpaqueCaptureAddressKHR_FinalReturn; + char vkGetBufferOpaqueCaptureAddressKHR_CallbackBool; + CMOCK_vkGetBufferOpaqueCaptureAddressKHR_CALLBACK vkGetBufferOpaqueCaptureAddressKHR_CallbackFunctionPointer; + int vkGetBufferOpaqueCaptureAddressKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetBufferOpaqueCaptureAddressKHR_CallInstance; + char vkGetDeviceMemoryOpaqueCaptureAddressKHR_IgnoreBool; + uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR_FinalReturn; + char vkGetDeviceMemoryOpaqueCaptureAddressKHR_CallbackBool; + CMOCK_vkGetDeviceMemoryOpaqueCaptureAddressKHR_CALLBACK vkGetDeviceMemoryOpaqueCaptureAddressKHR_CallbackFunctionPointer; + int vkGetDeviceMemoryOpaqueCaptureAddressKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDeviceMemoryOpaqueCaptureAddressKHR_CallInstance; + char vkCreateDeferredOperationKHR_IgnoreBool; + VkResult vkCreateDeferredOperationKHR_FinalReturn; + char vkCreateDeferredOperationKHR_CallbackBool; + CMOCK_vkCreateDeferredOperationKHR_CALLBACK vkCreateDeferredOperationKHR_CallbackFunctionPointer; + int vkCreateDeferredOperationKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateDeferredOperationKHR_CallInstance; + char vkDestroyDeferredOperationKHR_IgnoreBool; + char vkDestroyDeferredOperationKHR_CallbackBool; + CMOCK_vkDestroyDeferredOperationKHR_CALLBACK vkDestroyDeferredOperationKHR_CallbackFunctionPointer; + int vkDestroyDeferredOperationKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyDeferredOperationKHR_CallInstance; + char vkGetDeferredOperationMaxConcurrencyKHR_IgnoreBool; + uint32_t vkGetDeferredOperationMaxConcurrencyKHR_FinalReturn; + char vkGetDeferredOperationMaxConcurrencyKHR_CallbackBool; + CMOCK_vkGetDeferredOperationMaxConcurrencyKHR_CALLBACK vkGetDeferredOperationMaxConcurrencyKHR_CallbackFunctionPointer; + int vkGetDeferredOperationMaxConcurrencyKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDeferredOperationMaxConcurrencyKHR_CallInstance; + char vkGetDeferredOperationResultKHR_IgnoreBool; + VkResult vkGetDeferredOperationResultKHR_FinalReturn; + char vkGetDeferredOperationResultKHR_CallbackBool; + CMOCK_vkGetDeferredOperationResultKHR_CALLBACK vkGetDeferredOperationResultKHR_CallbackFunctionPointer; + int vkGetDeferredOperationResultKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDeferredOperationResultKHR_CallInstance; + char vkDeferredOperationJoinKHR_IgnoreBool; + VkResult vkDeferredOperationJoinKHR_FinalReturn; + char vkDeferredOperationJoinKHR_CallbackBool; + CMOCK_vkDeferredOperationJoinKHR_CALLBACK vkDeferredOperationJoinKHR_CallbackFunctionPointer; + int vkDeferredOperationJoinKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDeferredOperationJoinKHR_CallInstance; + char vkGetPipelineExecutablePropertiesKHR_IgnoreBool; + VkResult vkGetPipelineExecutablePropertiesKHR_FinalReturn; + char vkGetPipelineExecutablePropertiesKHR_CallbackBool; + CMOCK_vkGetPipelineExecutablePropertiesKHR_CALLBACK vkGetPipelineExecutablePropertiesKHR_CallbackFunctionPointer; + int vkGetPipelineExecutablePropertiesKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPipelineExecutablePropertiesKHR_CallInstance; + char vkGetPipelineExecutableStatisticsKHR_IgnoreBool; + VkResult vkGetPipelineExecutableStatisticsKHR_FinalReturn; + char vkGetPipelineExecutableStatisticsKHR_CallbackBool; + CMOCK_vkGetPipelineExecutableStatisticsKHR_CALLBACK vkGetPipelineExecutableStatisticsKHR_CallbackFunctionPointer; + int vkGetPipelineExecutableStatisticsKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPipelineExecutableStatisticsKHR_CallInstance; + char vkGetPipelineExecutableInternalRepresentationsKHR_IgnoreBool; + VkResult vkGetPipelineExecutableInternalRepresentationsKHR_FinalReturn; + char vkGetPipelineExecutableInternalRepresentationsKHR_CallbackBool; + CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALLBACK vkGetPipelineExecutableInternalRepresentationsKHR_CallbackFunctionPointer; + int vkGetPipelineExecutableInternalRepresentationsKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPipelineExecutableInternalRepresentationsKHR_CallInstance; + char vkMapMemory2KHR_IgnoreBool; + VkResult vkMapMemory2KHR_FinalReturn; + char vkMapMemory2KHR_CallbackBool; + CMOCK_vkMapMemory2KHR_CALLBACK vkMapMemory2KHR_CallbackFunctionPointer; + int vkMapMemory2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkMapMemory2KHR_CallInstance; + char vkUnmapMemory2KHR_IgnoreBool; + VkResult vkUnmapMemory2KHR_FinalReturn; + char vkUnmapMemory2KHR_CallbackBool; + CMOCK_vkUnmapMemory2KHR_CALLBACK vkUnmapMemory2KHR_CallbackFunctionPointer; + int vkUnmapMemory2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkUnmapMemory2KHR_CallInstance; + char vkCmdSetEvent2KHR_IgnoreBool; + char vkCmdSetEvent2KHR_CallbackBool; + CMOCK_vkCmdSetEvent2KHR_CALLBACK vkCmdSetEvent2KHR_CallbackFunctionPointer; + int vkCmdSetEvent2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetEvent2KHR_CallInstance; + char vkCmdResetEvent2KHR_IgnoreBool; + char vkCmdResetEvent2KHR_CallbackBool; + CMOCK_vkCmdResetEvent2KHR_CALLBACK vkCmdResetEvent2KHR_CallbackFunctionPointer; + int vkCmdResetEvent2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdResetEvent2KHR_CallInstance; + char vkCmdWaitEvents2KHR_IgnoreBool; + char vkCmdWaitEvents2KHR_CallbackBool; + CMOCK_vkCmdWaitEvents2KHR_CALLBACK vkCmdWaitEvents2KHR_CallbackFunctionPointer; + int vkCmdWaitEvents2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdWaitEvents2KHR_CallInstance; + char vkCmdPipelineBarrier2KHR_IgnoreBool; + char vkCmdPipelineBarrier2KHR_CallbackBool; + CMOCK_vkCmdPipelineBarrier2KHR_CALLBACK vkCmdPipelineBarrier2KHR_CallbackFunctionPointer; + int vkCmdPipelineBarrier2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdPipelineBarrier2KHR_CallInstance; + char vkCmdWriteTimestamp2KHR_IgnoreBool; + char vkCmdWriteTimestamp2KHR_CallbackBool; + CMOCK_vkCmdWriteTimestamp2KHR_CALLBACK vkCmdWriteTimestamp2KHR_CallbackFunctionPointer; + int vkCmdWriteTimestamp2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdWriteTimestamp2KHR_CallInstance; + char vkQueueSubmit2KHR_IgnoreBool; + VkResult vkQueueSubmit2KHR_FinalReturn; + char vkQueueSubmit2KHR_CallbackBool; + CMOCK_vkQueueSubmit2KHR_CALLBACK vkQueueSubmit2KHR_CallbackFunctionPointer; + int vkQueueSubmit2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkQueueSubmit2KHR_CallInstance; + char vkCmdWriteBufferMarker2AMD_IgnoreBool; + char vkCmdWriteBufferMarker2AMD_CallbackBool; + CMOCK_vkCmdWriteBufferMarker2AMD_CALLBACK vkCmdWriteBufferMarker2AMD_CallbackFunctionPointer; + int vkCmdWriteBufferMarker2AMD_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdWriteBufferMarker2AMD_CallInstance; + char vkGetQueueCheckpointData2NV_IgnoreBool; + char vkGetQueueCheckpointData2NV_CallbackBool; + CMOCK_vkGetQueueCheckpointData2NV_CALLBACK vkGetQueueCheckpointData2NV_CallbackFunctionPointer; + int vkGetQueueCheckpointData2NV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetQueueCheckpointData2NV_CallInstance; + char vkCmdCopyBuffer2KHR_IgnoreBool; + char vkCmdCopyBuffer2KHR_CallbackBool; + CMOCK_vkCmdCopyBuffer2KHR_CALLBACK vkCmdCopyBuffer2KHR_CallbackFunctionPointer; + int vkCmdCopyBuffer2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdCopyBuffer2KHR_CallInstance; + char vkCmdCopyImage2KHR_IgnoreBool; + char vkCmdCopyImage2KHR_CallbackBool; + CMOCK_vkCmdCopyImage2KHR_CALLBACK vkCmdCopyImage2KHR_CallbackFunctionPointer; + int vkCmdCopyImage2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdCopyImage2KHR_CallInstance; + char vkCmdCopyBufferToImage2KHR_IgnoreBool; + char vkCmdCopyBufferToImage2KHR_CallbackBool; + CMOCK_vkCmdCopyBufferToImage2KHR_CALLBACK vkCmdCopyBufferToImage2KHR_CallbackFunctionPointer; + int vkCmdCopyBufferToImage2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdCopyBufferToImage2KHR_CallInstance; + char vkCmdCopyImageToBuffer2KHR_IgnoreBool; + char vkCmdCopyImageToBuffer2KHR_CallbackBool; + CMOCK_vkCmdCopyImageToBuffer2KHR_CALLBACK vkCmdCopyImageToBuffer2KHR_CallbackFunctionPointer; + int vkCmdCopyImageToBuffer2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdCopyImageToBuffer2KHR_CallInstance; + char vkCmdBlitImage2KHR_IgnoreBool; + char vkCmdBlitImage2KHR_CallbackBool; + CMOCK_vkCmdBlitImage2KHR_CALLBACK vkCmdBlitImage2KHR_CallbackFunctionPointer; + int vkCmdBlitImage2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBlitImage2KHR_CallInstance; + char vkCmdResolveImage2KHR_IgnoreBool; + char vkCmdResolveImage2KHR_CallbackBool; + CMOCK_vkCmdResolveImage2KHR_CALLBACK vkCmdResolveImage2KHR_CallbackFunctionPointer; + int vkCmdResolveImage2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdResolveImage2KHR_CallInstance; + char vkCmdTraceRaysIndirect2KHR_IgnoreBool; + char vkCmdTraceRaysIndirect2KHR_CallbackBool; + CMOCK_vkCmdTraceRaysIndirect2KHR_CALLBACK vkCmdTraceRaysIndirect2KHR_CallbackFunctionPointer; + int vkCmdTraceRaysIndirect2KHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdTraceRaysIndirect2KHR_CallInstance; + char vkGetDeviceBufferMemoryRequirementsKHR_IgnoreBool; + char vkGetDeviceBufferMemoryRequirementsKHR_CallbackBool; + CMOCK_vkGetDeviceBufferMemoryRequirementsKHR_CALLBACK vkGetDeviceBufferMemoryRequirementsKHR_CallbackFunctionPointer; + int vkGetDeviceBufferMemoryRequirementsKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDeviceBufferMemoryRequirementsKHR_CallInstance; + char vkGetDeviceImageMemoryRequirementsKHR_IgnoreBool; + char vkGetDeviceImageMemoryRequirementsKHR_CallbackBool; + CMOCK_vkGetDeviceImageMemoryRequirementsKHR_CALLBACK vkGetDeviceImageMemoryRequirementsKHR_CallbackFunctionPointer; + int vkGetDeviceImageMemoryRequirementsKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDeviceImageMemoryRequirementsKHR_CallInstance; + char vkGetDeviceImageSparseMemoryRequirementsKHR_IgnoreBool; + char vkGetDeviceImageSparseMemoryRequirementsKHR_CallbackBool; + CMOCK_vkGetDeviceImageSparseMemoryRequirementsKHR_CALLBACK vkGetDeviceImageSparseMemoryRequirementsKHR_CallbackFunctionPointer; + int vkGetDeviceImageSparseMemoryRequirementsKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDeviceImageSparseMemoryRequirementsKHR_CallInstance; + char vkCreateDebugReportCallbackEXT_IgnoreBool; + VkResult vkCreateDebugReportCallbackEXT_FinalReturn; + char vkCreateDebugReportCallbackEXT_CallbackBool; + CMOCK_vkCreateDebugReportCallbackEXT_CALLBACK vkCreateDebugReportCallbackEXT_CallbackFunctionPointer; + int vkCreateDebugReportCallbackEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateDebugReportCallbackEXT_CallInstance; + char vkDestroyDebugReportCallbackEXT_IgnoreBool; + char vkDestroyDebugReportCallbackEXT_CallbackBool; + CMOCK_vkDestroyDebugReportCallbackEXT_CALLBACK vkDestroyDebugReportCallbackEXT_CallbackFunctionPointer; + int vkDestroyDebugReportCallbackEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyDebugReportCallbackEXT_CallInstance; + char vkDebugReportMessageEXT_IgnoreBool; + char vkDebugReportMessageEXT_CallbackBool; + CMOCK_vkDebugReportMessageEXT_CALLBACK vkDebugReportMessageEXT_CallbackFunctionPointer; + int vkDebugReportMessageEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDebugReportMessageEXT_CallInstance; + char vkDebugMarkerSetObjectTagEXT_IgnoreBool; + VkResult vkDebugMarkerSetObjectTagEXT_FinalReturn; + char vkDebugMarkerSetObjectTagEXT_CallbackBool; + CMOCK_vkDebugMarkerSetObjectTagEXT_CALLBACK vkDebugMarkerSetObjectTagEXT_CallbackFunctionPointer; + int vkDebugMarkerSetObjectTagEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDebugMarkerSetObjectTagEXT_CallInstance; + char vkDebugMarkerSetObjectNameEXT_IgnoreBool; + VkResult vkDebugMarkerSetObjectNameEXT_FinalReturn; + char vkDebugMarkerSetObjectNameEXT_CallbackBool; + CMOCK_vkDebugMarkerSetObjectNameEXT_CALLBACK vkDebugMarkerSetObjectNameEXT_CallbackFunctionPointer; + int vkDebugMarkerSetObjectNameEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDebugMarkerSetObjectNameEXT_CallInstance; + char vkCmdDebugMarkerBeginEXT_IgnoreBool; + char vkCmdDebugMarkerBeginEXT_CallbackBool; + CMOCK_vkCmdDebugMarkerBeginEXT_CALLBACK vkCmdDebugMarkerBeginEXT_CallbackFunctionPointer; + int vkCmdDebugMarkerBeginEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDebugMarkerBeginEXT_CallInstance; + char vkCmdDebugMarkerEndEXT_IgnoreBool; + char vkCmdDebugMarkerEndEXT_CallbackBool; + CMOCK_vkCmdDebugMarkerEndEXT_CALLBACK vkCmdDebugMarkerEndEXT_CallbackFunctionPointer; + int vkCmdDebugMarkerEndEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDebugMarkerEndEXT_CallInstance; + char vkCmdDebugMarkerInsertEXT_IgnoreBool; + char vkCmdDebugMarkerInsertEXT_CallbackBool; + CMOCK_vkCmdDebugMarkerInsertEXT_CALLBACK vkCmdDebugMarkerInsertEXT_CallbackFunctionPointer; + int vkCmdDebugMarkerInsertEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDebugMarkerInsertEXT_CallInstance; + char vkCmdBindTransformFeedbackBuffersEXT_IgnoreBool; + char vkCmdBindTransformFeedbackBuffersEXT_CallbackBool; + CMOCK_vkCmdBindTransformFeedbackBuffersEXT_CALLBACK vkCmdBindTransformFeedbackBuffersEXT_CallbackFunctionPointer; + int vkCmdBindTransformFeedbackBuffersEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBindTransformFeedbackBuffersEXT_CallInstance; + char vkCmdBeginTransformFeedbackEXT_IgnoreBool; + char vkCmdBeginTransformFeedbackEXT_CallbackBool; + CMOCK_vkCmdBeginTransformFeedbackEXT_CALLBACK vkCmdBeginTransformFeedbackEXT_CallbackFunctionPointer; + int vkCmdBeginTransformFeedbackEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBeginTransformFeedbackEXT_CallInstance; + char vkCmdEndTransformFeedbackEXT_IgnoreBool; + char vkCmdEndTransformFeedbackEXT_CallbackBool; + CMOCK_vkCmdEndTransformFeedbackEXT_CALLBACK vkCmdEndTransformFeedbackEXT_CallbackFunctionPointer; + int vkCmdEndTransformFeedbackEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdEndTransformFeedbackEXT_CallInstance; + char vkCmdBeginQueryIndexedEXT_IgnoreBool; + char vkCmdBeginQueryIndexedEXT_CallbackBool; + CMOCK_vkCmdBeginQueryIndexedEXT_CALLBACK vkCmdBeginQueryIndexedEXT_CallbackFunctionPointer; + int vkCmdBeginQueryIndexedEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBeginQueryIndexedEXT_CallInstance; + char vkCmdEndQueryIndexedEXT_IgnoreBool; + char vkCmdEndQueryIndexedEXT_CallbackBool; + CMOCK_vkCmdEndQueryIndexedEXT_CALLBACK vkCmdEndQueryIndexedEXT_CallbackFunctionPointer; + int vkCmdEndQueryIndexedEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdEndQueryIndexedEXT_CallInstance; + char vkCmdDrawIndirectByteCountEXT_IgnoreBool; + char vkCmdDrawIndirectByteCountEXT_CallbackBool; + CMOCK_vkCmdDrawIndirectByteCountEXT_CALLBACK vkCmdDrawIndirectByteCountEXT_CallbackFunctionPointer; + int vkCmdDrawIndirectByteCountEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDrawIndirectByteCountEXT_CallInstance; + char vkCreateCuModuleNVX_IgnoreBool; + VkResult vkCreateCuModuleNVX_FinalReturn; + char vkCreateCuModuleNVX_CallbackBool; + CMOCK_vkCreateCuModuleNVX_CALLBACK vkCreateCuModuleNVX_CallbackFunctionPointer; + int vkCreateCuModuleNVX_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateCuModuleNVX_CallInstance; + char vkCreateCuFunctionNVX_IgnoreBool; + VkResult vkCreateCuFunctionNVX_FinalReturn; + char vkCreateCuFunctionNVX_CallbackBool; + CMOCK_vkCreateCuFunctionNVX_CALLBACK vkCreateCuFunctionNVX_CallbackFunctionPointer; + int vkCreateCuFunctionNVX_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateCuFunctionNVX_CallInstance; + char vkDestroyCuModuleNVX_IgnoreBool; + char vkDestroyCuModuleNVX_CallbackBool; + CMOCK_vkDestroyCuModuleNVX_CALLBACK vkDestroyCuModuleNVX_CallbackFunctionPointer; + int vkDestroyCuModuleNVX_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyCuModuleNVX_CallInstance; + char vkDestroyCuFunctionNVX_IgnoreBool; + char vkDestroyCuFunctionNVX_CallbackBool; + CMOCK_vkDestroyCuFunctionNVX_CALLBACK vkDestroyCuFunctionNVX_CallbackFunctionPointer; + int vkDestroyCuFunctionNVX_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyCuFunctionNVX_CallInstance; + char vkCmdCuLaunchKernelNVX_IgnoreBool; + char vkCmdCuLaunchKernelNVX_CallbackBool; + CMOCK_vkCmdCuLaunchKernelNVX_CALLBACK vkCmdCuLaunchKernelNVX_CallbackFunctionPointer; + int vkCmdCuLaunchKernelNVX_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdCuLaunchKernelNVX_CallInstance; + char vkGetImageViewHandleNVX_IgnoreBool; + uint32_t vkGetImageViewHandleNVX_FinalReturn; + char vkGetImageViewHandleNVX_CallbackBool; + CMOCK_vkGetImageViewHandleNVX_CALLBACK vkGetImageViewHandleNVX_CallbackFunctionPointer; + int vkGetImageViewHandleNVX_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetImageViewHandleNVX_CallInstance; + char vkGetImageViewAddressNVX_IgnoreBool; + VkResult vkGetImageViewAddressNVX_FinalReturn; + char vkGetImageViewAddressNVX_CallbackBool; + CMOCK_vkGetImageViewAddressNVX_CALLBACK vkGetImageViewAddressNVX_CallbackFunctionPointer; + int vkGetImageViewAddressNVX_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetImageViewAddressNVX_CallInstance; + char vkCmdDrawIndirectCountAMD_IgnoreBool; + char vkCmdDrawIndirectCountAMD_CallbackBool; + CMOCK_vkCmdDrawIndirectCountAMD_CALLBACK vkCmdDrawIndirectCountAMD_CallbackFunctionPointer; + int vkCmdDrawIndirectCountAMD_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDrawIndirectCountAMD_CallInstance; + char vkCmdDrawIndexedIndirectCountAMD_IgnoreBool; + char vkCmdDrawIndexedIndirectCountAMD_CallbackBool; + CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALLBACK vkCmdDrawIndexedIndirectCountAMD_CallbackFunctionPointer; + int vkCmdDrawIndexedIndirectCountAMD_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDrawIndexedIndirectCountAMD_CallInstance; + char vkGetShaderInfoAMD_IgnoreBool; + VkResult vkGetShaderInfoAMD_FinalReturn; + char vkGetShaderInfoAMD_CallbackBool; + CMOCK_vkGetShaderInfoAMD_CALLBACK vkGetShaderInfoAMD_CallbackFunctionPointer; + int vkGetShaderInfoAMD_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetShaderInfoAMD_CallInstance; + char vkGetPhysicalDeviceExternalImageFormatPropertiesNV_IgnoreBool; + VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV_FinalReturn; + char vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallbackBool; + CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALLBACK vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallbackFunctionPointer; + int vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallInstance; + char vkCmdBeginConditionalRenderingEXT_IgnoreBool; + char vkCmdBeginConditionalRenderingEXT_CallbackBool; + CMOCK_vkCmdBeginConditionalRenderingEXT_CALLBACK vkCmdBeginConditionalRenderingEXT_CallbackFunctionPointer; + int vkCmdBeginConditionalRenderingEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBeginConditionalRenderingEXT_CallInstance; + char vkCmdEndConditionalRenderingEXT_IgnoreBool; + char vkCmdEndConditionalRenderingEXT_CallbackBool; + CMOCK_vkCmdEndConditionalRenderingEXT_CALLBACK vkCmdEndConditionalRenderingEXT_CallbackFunctionPointer; + int vkCmdEndConditionalRenderingEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdEndConditionalRenderingEXT_CallInstance; + char vkCmdSetViewportWScalingNV_IgnoreBool; + char vkCmdSetViewportWScalingNV_CallbackBool; + CMOCK_vkCmdSetViewportWScalingNV_CALLBACK vkCmdSetViewportWScalingNV_CallbackFunctionPointer; + int vkCmdSetViewportWScalingNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetViewportWScalingNV_CallInstance; + char vkReleaseDisplayEXT_IgnoreBool; + VkResult vkReleaseDisplayEXT_FinalReturn; + char vkReleaseDisplayEXT_CallbackBool; + CMOCK_vkReleaseDisplayEXT_CALLBACK vkReleaseDisplayEXT_CallbackFunctionPointer; + int vkReleaseDisplayEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkReleaseDisplayEXT_CallInstance; + char vkGetPhysicalDeviceSurfaceCapabilities2EXT_IgnoreBool; + VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT_FinalReturn; + char vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallbackBool; + CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2EXT_CALLBACK vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallbackFunctionPointer; + int vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallInstance; + char vkDisplayPowerControlEXT_IgnoreBool; + VkResult vkDisplayPowerControlEXT_FinalReturn; + char vkDisplayPowerControlEXT_CallbackBool; + CMOCK_vkDisplayPowerControlEXT_CALLBACK vkDisplayPowerControlEXT_CallbackFunctionPointer; + int vkDisplayPowerControlEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDisplayPowerControlEXT_CallInstance; + char vkRegisterDeviceEventEXT_IgnoreBool; + VkResult vkRegisterDeviceEventEXT_FinalReturn; + char vkRegisterDeviceEventEXT_CallbackBool; + CMOCK_vkRegisterDeviceEventEXT_CALLBACK vkRegisterDeviceEventEXT_CallbackFunctionPointer; + int vkRegisterDeviceEventEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkRegisterDeviceEventEXT_CallInstance; + char vkRegisterDisplayEventEXT_IgnoreBool; + VkResult vkRegisterDisplayEventEXT_FinalReturn; + char vkRegisterDisplayEventEXT_CallbackBool; + CMOCK_vkRegisterDisplayEventEXT_CALLBACK vkRegisterDisplayEventEXT_CallbackFunctionPointer; + int vkRegisterDisplayEventEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkRegisterDisplayEventEXT_CallInstance; + char vkGetSwapchainCounterEXT_IgnoreBool; + VkResult vkGetSwapchainCounterEXT_FinalReturn; + char vkGetSwapchainCounterEXT_CallbackBool; + CMOCK_vkGetSwapchainCounterEXT_CALLBACK vkGetSwapchainCounterEXT_CallbackFunctionPointer; + int vkGetSwapchainCounterEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetSwapchainCounterEXT_CallInstance; + char vkGetRefreshCycleDurationGOOGLE_IgnoreBool; + VkResult vkGetRefreshCycleDurationGOOGLE_FinalReturn; + char vkGetRefreshCycleDurationGOOGLE_CallbackBool; + CMOCK_vkGetRefreshCycleDurationGOOGLE_CALLBACK vkGetRefreshCycleDurationGOOGLE_CallbackFunctionPointer; + int vkGetRefreshCycleDurationGOOGLE_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetRefreshCycleDurationGOOGLE_CallInstance; + char vkGetPastPresentationTimingGOOGLE_IgnoreBool; + VkResult vkGetPastPresentationTimingGOOGLE_FinalReturn; + char vkGetPastPresentationTimingGOOGLE_CallbackBool; + CMOCK_vkGetPastPresentationTimingGOOGLE_CALLBACK vkGetPastPresentationTimingGOOGLE_CallbackFunctionPointer; + int vkGetPastPresentationTimingGOOGLE_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPastPresentationTimingGOOGLE_CallInstance; + char vkCmdSetDiscardRectangleEXT_IgnoreBool; + char vkCmdSetDiscardRectangleEXT_CallbackBool; + CMOCK_vkCmdSetDiscardRectangleEXT_CALLBACK vkCmdSetDiscardRectangleEXT_CallbackFunctionPointer; + int vkCmdSetDiscardRectangleEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetDiscardRectangleEXT_CallInstance; + char vkCmdSetDiscardRectangleEnableEXT_IgnoreBool; + char vkCmdSetDiscardRectangleEnableEXT_CallbackBool; + CMOCK_vkCmdSetDiscardRectangleEnableEXT_CALLBACK vkCmdSetDiscardRectangleEnableEXT_CallbackFunctionPointer; + int vkCmdSetDiscardRectangleEnableEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetDiscardRectangleEnableEXT_CallInstance; + char vkCmdSetDiscardRectangleModeEXT_IgnoreBool; + char vkCmdSetDiscardRectangleModeEXT_CallbackBool; + CMOCK_vkCmdSetDiscardRectangleModeEXT_CALLBACK vkCmdSetDiscardRectangleModeEXT_CallbackFunctionPointer; + int vkCmdSetDiscardRectangleModeEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetDiscardRectangleModeEXT_CallInstance; + char vkSetHdrMetadataEXT_IgnoreBool; + char vkSetHdrMetadataEXT_CallbackBool; + CMOCK_vkSetHdrMetadataEXT_CALLBACK vkSetHdrMetadataEXT_CallbackFunctionPointer; + int vkSetHdrMetadataEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkSetHdrMetadataEXT_CallInstance; + char vkSetDebugUtilsObjectNameEXT_IgnoreBool; + VkResult vkSetDebugUtilsObjectNameEXT_FinalReturn; + char vkSetDebugUtilsObjectNameEXT_CallbackBool; + CMOCK_vkSetDebugUtilsObjectNameEXT_CALLBACK vkSetDebugUtilsObjectNameEXT_CallbackFunctionPointer; + int vkSetDebugUtilsObjectNameEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkSetDebugUtilsObjectNameEXT_CallInstance; + char vkSetDebugUtilsObjectTagEXT_IgnoreBool; + VkResult vkSetDebugUtilsObjectTagEXT_FinalReturn; + char vkSetDebugUtilsObjectTagEXT_CallbackBool; + CMOCK_vkSetDebugUtilsObjectTagEXT_CALLBACK vkSetDebugUtilsObjectTagEXT_CallbackFunctionPointer; + int vkSetDebugUtilsObjectTagEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkSetDebugUtilsObjectTagEXT_CallInstance; + char vkQueueBeginDebugUtilsLabelEXT_IgnoreBool; + char vkQueueBeginDebugUtilsLabelEXT_CallbackBool; + CMOCK_vkQueueBeginDebugUtilsLabelEXT_CALLBACK vkQueueBeginDebugUtilsLabelEXT_CallbackFunctionPointer; + int vkQueueBeginDebugUtilsLabelEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkQueueBeginDebugUtilsLabelEXT_CallInstance; + char vkQueueEndDebugUtilsLabelEXT_IgnoreBool; + char vkQueueEndDebugUtilsLabelEXT_CallbackBool; + CMOCK_vkQueueEndDebugUtilsLabelEXT_CALLBACK vkQueueEndDebugUtilsLabelEXT_CallbackFunctionPointer; + int vkQueueEndDebugUtilsLabelEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkQueueEndDebugUtilsLabelEXT_CallInstance; + char vkQueueInsertDebugUtilsLabelEXT_IgnoreBool; + char vkQueueInsertDebugUtilsLabelEXT_CallbackBool; + CMOCK_vkQueueInsertDebugUtilsLabelEXT_CALLBACK vkQueueInsertDebugUtilsLabelEXT_CallbackFunctionPointer; + int vkQueueInsertDebugUtilsLabelEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkQueueInsertDebugUtilsLabelEXT_CallInstance; + char vkCmdBeginDebugUtilsLabelEXT_IgnoreBool; + char vkCmdBeginDebugUtilsLabelEXT_CallbackBool; + CMOCK_vkCmdBeginDebugUtilsLabelEXT_CALLBACK vkCmdBeginDebugUtilsLabelEXT_CallbackFunctionPointer; + int vkCmdBeginDebugUtilsLabelEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBeginDebugUtilsLabelEXT_CallInstance; + char vkCmdEndDebugUtilsLabelEXT_IgnoreBool; + char vkCmdEndDebugUtilsLabelEXT_CallbackBool; + CMOCK_vkCmdEndDebugUtilsLabelEXT_CALLBACK vkCmdEndDebugUtilsLabelEXT_CallbackFunctionPointer; + int vkCmdEndDebugUtilsLabelEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdEndDebugUtilsLabelEXT_CallInstance; + char vkCmdInsertDebugUtilsLabelEXT_IgnoreBool; + char vkCmdInsertDebugUtilsLabelEXT_CallbackBool; + CMOCK_vkCmdInsertDebugUtilsLabelEXT_CALLBACK vkCmdInsertDebugUtilsLabelEXT_CallbackFunctionPointer; + int vkCmdInsertDebugUtilsLabelEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdInsertDebugUtilsLabelEXT_CallInstance; + char vkCreateDebugUtilsMessengerEXT_IgnoreBool; + VkResult vkCreateDebugUtilsMessengerEXT_FinalReturn; + char vkCreateDebugUtilsMessengerEXT_CallbackBool; + CMOCK_vkCreateDebugUtilsMessengerEXT_CALLBACK vkCreateDebugUtilsMessengerEXT_CallbackFunctionPointer; + int vkCreateDebugUtilsMessengerEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateDebugUtilsMessengerEXT_CallInstance; + char vkDestroyDebugUtilsMessengerEXT_IgnoreBool; + char vkDestroyDebugUtilsMessengerEXT_CallbackBool; + CMOCK_vkDestroyDebugUtilsMessengerEXT_CALLBACK vkDestroyDebugUtilsMessengerEXT_CallbackFunctionPointer; + int vkDestroyDebugUtilsMessengerEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyDebugUtilsMessengerEXT_CallInstance; + char vkSubmitDebugUtilsMessageEXT_IgnoreBool; + char vkSubmitDebugUtilsMessageEXT_CallbackBool; + CMOCK_vkSubmitDebugUtilsMessageEXT_CALLBACK vkSubmitDebugUtilsMessageEXT_CallbackFunctionPointer; + int vkSubmitDebugUtilsMessageEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkSubmitDebugUtilsMessageEXT_CallInstance; + char vkCmdSetSampleLocationsEXT_IgnoreBool; + char vkCmdSetSampleLocationsEXT_CallbackBool; + CMOCK_vkCmdSetSampleLocationsEXT_CALLBACK vkCmdSetSampleLocationsEXT_CallbackFunctionPointer; + int vkCmdSetSampleLocationsEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetSampleLocationsEXT_CallInstance; + char vkGetPhysicalDeviceMultisamplePropertiesEXT_IgnoreBool; + char vkGetPhysicalDeviceMultisamplePropertiesEXT_CallbackBool; + CMOCK_vkGetPhysicalDeviceMultisamplePropertiesEXT_CALLBACK vkGetPhysicalDeviceMultisamplePropertiesEXT_CallbackFunctionPointer; + int vkGetPhysicalDeviceMultisamplePropertiesEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceMultisamplePropertiesEXT_CallInstance; + char vkGetImageDrmFormatModifierPropertiesEXT_IgnoreBool; + VkResult vkGetImageDrmFormatModifierPropertiesEXT_FinalReturn; + char vkGetImageDrmFormatModifierPropertiesEXT_CallbackBool; + CMOCK_vkGetImageDrmFormatModifierPropertiesEXT_CALLBACK vkGetImageDrmFormatModifierPropertiesEXT_CallbackFunctionPointer; + int vkGetImageDrmFormatModifierPropertiesEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetImageDrmFormatModifierPropertiesEXT_CallInstance; + char vkCreateValidationCacheEXT_IgnoreBool; + VkResult vkCreateValidationCacheEXT_FinalReturn; + char vkCreateValidationCacheEXT_CallbackBool; + CMOCK_vkCreateValidationCacheEXT_CALLBACK vkCreateValidationCacheEXT_CallbackFunctionPointer; + int vkCreateValidationCacheEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateValidationCacheEXT_CallInstance; + char vkDestroyValidationCacheEXT_IgnoreBool; + char vkDestroyValidationCacheEXT_CallbackBool; + CMOCK_vkDestroyValidationCacheEXT_CALLBACK vkDestroyValidationCacheEXT_CallbackFunctionPointer; + int vkDestroyValidationCacheEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyValidationCacheEXT_CallInstance; + char vkMergeValidationCachesEXT_IgnoreBool; + VkResult vkMergeValidationCachesEXT_FinalReturn; + char vkMergeValidationCachesEXT_CallbackBool; + CMOCK_vkMergeValidationCachesEXT_CALLBACK vkMergeValidationCachesEXT_CallbackFunctionPointer; + int vkMergeValidationCachesEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkMergeValidationCachesEXT_CallInstance; + char vkGetValidationCacheDataEXT_IgnoreBool; + VkResult vkGetValidationCacheDataEXT_FinalReturn; + char vkGetValidationCacheDataEXT_CallbackBool; + CMOCK_vkGetValidationCacheDataEXT_CALLBACK vkGetValidationCacheDataEXT_CallbackFunctionPointer; + int vkGetValidationCacheDataEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetValidationCacheDataEXT_CallInstance; + char vkCmdBindShadingRateImageNV_IgnoreBool; + char vkCmdBindShadingRateImageNV_CallbackBool; + CMOCK_vkCmdBindShadingRateImageNV_CALLBACK vkCmdBindShadingRateImageNV_CallbackFunctionPointer; + int vkCmdBindShadingRateImageNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBindShadingRateImageNV_CallInstance; + char vkCmdSetViewportShadingRatePaletteNV_IgnoreBool; + char vkCmdSetViewportShadingRatePaletteNV_CallbackBool; + CMOCK_vkCmdSetViewportShadingRatePaletteNV_CALLBACK vkCmdSetViewportShadingRatePaletteNV_CallbackFunctionPointer; + int vkCmdSetViewportShadingRatePaletteNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetViewportShadingRatePaletteNV_CallInstance; + char vkCmdSetCoarseSampleOrderNV_IgnoreBool; + char vkCmdSetCoarseSampleOrderNV_CallbackBool; + CMOCK_vkCmdSetCoarseSampleOrderNV_CALLBACK vkCmdSetCoarseSampleOrderNV_CallbackFunctionPointer; + int vkCmdSetCoarseSampleOrderNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetCoarseSampleOrderNV_CallInstance; + char vkCreateAccelerationStructureNV_IgnoreBool; + VkResult vkCreateAccelerationStructureNV_FinalReturn; + char vkCreateAccelerationStructureNV_CallbackBool; + CMOCK_vkCreateAccelerationStructureNV_CALLBACK vkCreateAccelerationStructureNV_CallbackFunctionPointer; + int vkCreateAccelerationStructureNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateAccelerationStructureNV_CallInstance; + char vkDestroyAccelerationStructureNV_IgnoreBool; + char vkDestroyAccelerationStructureNV_CallbackBool; + CMOCK_vkDestroyAccelerationStructureNV_CALLBACK vkDestroyAccelerationStructureNV_CallbackFunctionPointer; + int vkDestroyAccelerationStructureNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyAccelerationStructureNV_CallInstance; + char vkGetAccelerationStructureMemoryRequirementsNV_IgnoreBool; + char vkGetAccelerationStructureMemoryRequirementsNV_CallbackBool; + CMOCK_vkGetAccelerationStructureMemoryRequirementsNV_CALLBACK vkGetAccelerationStructureMemoryRequirementsNV_CallbackFunctionPointer; + int vkGetAccelerationStructureMemoryRequirementsNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetAccelerationStructureMemoryRequirementsNV_CallInstance; + char vkBindAccelerationStructureMemoryNV_IgnoreBool; + VkResult vkBindAccelerationStructureMemoryNV_FinalReturn; + char vkBindAccelerationStructureMemoryNV_CallbackBool; + CMOCK_vkBindAccelerationStructureMemoryNV_CALLBACK vkBindAccelerationStructureMemoryNV_CallbackFunctionPointer; + int vkBindAccelerationStructureMemoryNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkBindAccelerationStructureMemoryNV_CallInstance; + char vkCmdBuildAccelerationStructureNV_IgnoreBool; + char vkCmdBuildAccelerationStructureNV_CallbackBool; + CMOCK_vkCmdBuildAccelerationStructureNV_CALLBACK vkCmdBuildAccelerationStructureNV_CallbackFunctionPointer; + int vkCmdBuildAccelerationStructureNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBuildAccelerationStructureNV_CallInstance; + char vkCmdCopyAccelerationStructureNV_IgnoreBool; + char vkCmdCopyAccelerationStructureNV_CallbackBool; + CMOCK_vkCmdCopyAccelerationStructureNV_CALLBACK vkCmdCopyAccelerationStructureNV_CallbackFunctionPointer; + int vkCmdCopyAccelerationStructureNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdCopyAccelerationStructureNV_CallInstance; + char vkCmdTraceRaysNV_IgnoreBool; + char vkCmdTraceRaysNV_CallbackBool; + CMOCK_vkCmdTraceRaysNV_CALLBACK vkCmdTraceRaysNV_CallbackFunctionPointer; + int vkCmdTraceRaysNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdTraceRaysNV_CallInstance; + char vkCreateRayTracingPipelinesNV_IgnoreBool; + VkResult vkCreateRayTracingPipelinesNV_FinalReturn; + char vkCreateRayTracingPipelinesNV_CallbackBool; + CMOCK_vkCreateRayTracingPipelinesNV_CALLBACK vkCreateRayTracingPipelinesNV_CallbackFunctionPointer; + int vkCreateRayTracingPipelinesNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateRayTracingPipelinesNV_CallInstance; + char vkGetRayTracingShaderGroupHandlesKHR_IgnoreBool; + VkResult vkGetRayTracingShaderGroupHandlesKHR_FinalReturn; + char vkGetRayTracingShaderGroupHandlesKHR_CallbackBool; + CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALLBACK vkGetRayTracingShaderGroupHandlesKHR_CallbackFunctionPointer; + int vkGetRayTracingShaderGroupHandlesKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetRayTracingShaderGroupHandlesKHR_CallInstance; + char vkGetRayTracingShaderGroupHandlesNV_IgnoreBool; + VkResult vkGetRayTracingShaderGroupHandlesNV_FinalReturn; + char vkGetRayTracingShaderGroupHandlesNV_CallbackBool; + CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALLBACK vkGetRayTracingShaderGroupHandlesNV_CallbackFunctionPointer; + int vkGetRayTracingShaderGroupHandlesNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetRayTracingShaderGroupHandlesNV_CallInstance; + char vkGetAccelerationStructureHandleNV_IgnoreBool; + VkResult vkGetAccelerationStructureHandleNV_FinalReturn; + char vkGetAccelerationStructureHandleNV_CallbackBool; + CMOCK_vkGetAccelerationStructureHandleNV_CALLBACK vkGetAccelerationStructureHandleNV_CallbackFunctionPointer; + int vkGetAccelerationStructureHandleNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetAccelerationStructureHandleNV_CallInstance; + char vkCmdWriteAccelerationStructuresPropertiesNV_IgnoreBool; + char vkCmdWriteAccelerationStructuresPropertiesNV_CallbackBool; + CMOCK_vkCmdWriteAccelerationStructuresPropertiesNV_CALLBACK vkCmdWriteAccelerationStructuresPropertiesNV_CallbackFunctionPointer; + int vkCmdWriteAccelerationStructuresPropertiesNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdWriteAccelerationStructuresPropertiesNV_CallInstance; + char vkCompileDeferredNV_IgnoreBool; + VkResult vkCompileDeferredNV_FinalReturn; + char vkCompileDeferredNV_CallbackBool; + CMOCK_vkCompileDeferredNV_CALLBACK vkCompileDeferredNV_CallbackFunctionPointer; + int vkCompileDeferredNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCompileDeferredNV_CallInstance; + char vkGetMemoryHostPointerPropertiesEXT_IgnoreBool; + VkResult vkGetMemoryHostPointerPropertiesEXT_FinalReturn; + char vkGetMemoryHostPointerPropertiesEXT_CallbackBool; + CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALLBACK vkGetMemoryHostPointerPropertiesEXT_CallbackFunctionPointer; + int vkGetMemoryHostPointerPropertiesEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetMemoryHostPointerPropertiesEXT_CallInstance; + char vkCmdWriteBufferMarkerAMD_IgnoreBool; + char vkCmdWriteBufferMarkerAMD_CallbackBool; + CMOCK_vkCmdWriteBufferMarkerAMD_CALLBACK vkCmdWriteBufferMarkerAMD_CallbackFunctionPointer; + int vkCmdWriteBufferMarkerAMD_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdWriteBufferMarkerAMD_CallInstance; + char vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_IgnoreBool; + VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_FinalReturn; + char vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallbackBool; + CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALLBACK vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallbackFunctionPointer; + int vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallInstance; + char vkGetCalibratedTimestampsEXT_IgnoreBool; + VkResult vkGetCalibratedTimestampsEXT_FinalReturn; + char vkGetCalibratedTimestampsEXT_CallbackBool; + CMOCK_vkGetCalibratedTimestampsEXT_CALLBACK vkGetCalibratedTimestampsEXT_CallbackFunctionPointer; + int vkGetCalibratedTimestampsEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetCalibratedTimestampsEXT_CallInstance; + char vkCmdDrawMeshTasksNV_IgnoreBool; + char vkCmdDrawMeshTasksNV_CallbackBool; + CMOCK_vkCmdDrawMeshTasksNV_CALLBACK vkCmdDrawMeshTasksNV_CallbackFunctionPointer; + int vkCmdDrawMeshTasksNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDrawMeshTasksNV_CallInstance; + char vkCmdDrawMeshTasksIndirectNV_IgnoreBool; + char vkCmdDrawMeshTasksIndirectNV_CallbackBool; + CMOCK_vkCmdDrawMeshTasksIndirectNV_CALLBACK vkCmdDrawMeshTasksIndirectNV_CallbackFunctionPointer; + int vkCmdDrawMeshTasksIndirectNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDrawMeshTasksIndirectNV_CallInstance; + char vkCmdDrawMeshTasksIndirectCountNV_IgnoreBool; + char vkCmdDrawMeshTasksIndirectCountNV_CallbackBool; + CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALLBACK vkCmdDrawMeshTasksIndirectCountNV_CallbackFunctionPointer; + int vkCmdDrawMeshTasksIndirectCountNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDrawMeshTasksIndirectCountNV_CallInstance; + char vkCmdSetExclusiveScissorEnableNV_IgnoreBool; + char vkCmdSetExclusiveScissorEnableNV_CallbackBool; + CMOCK_vkCmdSetExclusiveScissorEnableNV_CALLBACK vkCmdSetExclusiveScissorEnableNV_CallbackFunctionPointer; + int vkCmdSetExclusiveScissorEnableNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetExclusiveScissorEnableNV_CallInstance; + char vkCmdSetExclusiveScissorNV_IgnoreBool; + char vkCmdSetExclusiveScissorNV_CallbackBool; + CMOCK_vkCmdSetExclusiveScissorNV_CALLBACK vkCmdSetExclusiveScissorNV_CallbackFunctionPointer; + int vkCmdSetExclusiveScissorNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetExclusiveScissorNV_CallInstance; + char vkCmdSetCheckpointNV_IgnoreBool; + char vkCmdSetCheckpointNV_CallbackBool; + CMOCK_vkCmdSetCheckpointNV_CALLBACK vkCmdSetCheckpointNV_CallbackFunctionPointer; + int vkCmdSetCheckpointNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetCheckpointNV_CallInstance; + char vkGetQueueCheckpointDataNV_IgnoreBool; + char vkGetQueueCheckpointDataNV_CallbackBool; + CMOCK_vkGetQueueCheckpointDataNV_CALLBACK vkGetQueueCheckpointDataNV_CallbackFunctionPointer; + int vkGetQueueCheckpointDataNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetQueueCheckpointDataNV_CallInstance; + char vkInitializePerformanceApiINTEL_IgnoreBool; + VkResult vkInitializePerformanceApiINTEL_FinalReturn; + char vkInitializePerformanceApiINTEL_CallbackBool; + CMOCK_vkInitializePerformanceApiINTEL_CALLBACK vkInitializePerformanceApiINTEL_CallbackFunctionPointer; + int vkInitializePerformanceApiINTEL_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkInitializePerformanceApiINTEL_CallInstance; + char vkUninitializePerformanceApiINTEL_IgnoreBool; + char vkUninitializePerformanceApiINTEL_CallbackBool; + CMOCK_vkUninitializePerformanceApiINTEL_CALLBACK vkUninitializePerformanceApiINTEL_CallbackFunctionPointer; + int vkUninitializePerformanceApiINTEL_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkUninitializePerformanceApiINTEL_CallInstance; + char vkCmdSetPerformanceMarkerINTEL_IgnoreBool; + VkResult vkCmdSetPerformanceMarkerINTEL_FinalReturn; + char vkCmdSetPerformanceMarkerINTEL_CallbackBool; + CMOCK_vkCmdSetPerformanceMarkerINTEL_CALLBACK vkCmdSetPerformanceMarkerINTEL_CallbackFunctionPointer; + int vkCmdSetPerformanceMarkerINTEL_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetPerformanceMarkerINTEL_CallInstance; + char vkCmdSetPerformanceStreamMarkerINTEL_IgnoreBool; + VkResult vkCmdSetPerformanceStreamMarkerINTEL_FinalReturn; + char vkCmdSetPerformanceStreamMarkerINTEL_CallbackBool; + CMOCK_vkCmdSetPerformanceStreamMarkerINTEL_CALLBACK vkCmdSetPerformanceStreamMarkerINTEL_CallbackFunctionPointer; + int vkCmdSetPerformanceStreamMarkerINTEL_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetPerformanceStreamMarkerINTEL_CallInstance; + char vkCmdSetPerformanceOverrideINTEL_IgnoreBool; + VkResult vkCmdSetPerformanceOverrideINTEL_FinalReturn; + char vkCmdSetPerformanceOverrideINTEL_CallbackBool; + CMOCK_vkCmdSetPerformanceOverrideINTEL_CALLBACK vkCmdSetPerformanceOverrideINTEL_CallbackFunctionPointer; + int vkCmdSetPerformanceOverrideINTEL_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetPerformanceOverrideINTEL_CallInstance; + char vkAcquirePerformanceConfigurationINTEL_IgnoreBool; + VkResult vkAcquirePerformanceConfigurationINTEL_FinalReturn; + char vkAcquirePerformanceConfigurationINTEL_CallbackBool; + CMOCK_vkAcquirePerformanceConfigurationINTEL_CALLBACK vkAcquirePerformanceConfigurationINTEL_CallbackFunctionPointer; + int vkAcquirePerformanceConfigurationINTEL_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkAcquirePerformanceConfigurationINTEL_CallInstance; + char vkReleasePerformanceConfigurationINTEL_IgnoreBool; + VkResult vkReleasePerformanceConfigurationINTEL_FinalReturn; + char vkReleasePerformanceConfigurationINTEL_CallbackBool; + CMOCK_vkReleasePerformanceConfigurationINTEL_CALLBACK vkReleasePerformanceConfigurationINTEL_CallbackFunctionPointer; + int vkReleasePerformanceConfigurationINTEL_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkReleasePerformanceConfigurationINTEL_CallInstance; + char vkQueueSetPerformanceConfigurationINTEL_IgnoreBool; + VkResult vkQueueSetPerformanceConfigurationINTEL_FinalReturn; + char vkQueueSetPerformanceConfigurationINTEL_CallbackBool; + CMOCK_vkQueueSetPerformanceConfigurationINTEL_CALLBACK vkQueueSetPerformanceConfigurationINTEL_CallbackFunctionPointer; + int vkQueueSetPerformanceConfigurationINTEL_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkQueueSetPerformanceConfigurationINTEL_CallInstance; + char vkGetPerformanceParameterINTEL_IgnoreBool; + VkResult vkGetPerformanceParameterINTEL_FinalReturn; + char vkGetPerformanceParameterINTEL_CallbackBool; + CMOCK_vkGetPerformanceParameterINTEL_CALLBACK vkGetPerformanceParameterINTEL_CallbackFunctionPointer; + int vkGetPerformanceParameterINTEL_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPerformanceParameterINTEL_CallInstance; + char vkSetLocalDimmingAMD_IgnoreBool; + char vkSetLocalDimmingAMD_CallbackBool; + CMOCK_vkSetLocalDimmingAMD_CALLBACK vkSetLocalDimmingAMD_CallbackFunctionPointer; + int vkSetLocalDimmingAMD_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkSetLocalDimmingAMD_CallInstance; + char vkGetBufferDeviceAddressEXT_IgnoreBool; + VkDeviceAddress vkGetBufferDeviceAddressEXT_FinalReturn; + char vkGetBufferDeviceAddressEXT_CallbackBool; + CMOCK_vkGetBufferDeviceAddressEXT_CALLBACK vkGetBufferDeviceAddressEXT_CallbackFunctionPointer; + int vkGetBufferDeviceAddressEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetBufferDeviceAddressEXT_CallInstance; + char vkGetPhysicalDeviceToolPropertiesEXT_IgnoreBool; + VkResult vkGetPhysicalDeviceToolPropertiesEXT_FinalReturn; + char vkGetPhysicalDeviceToolPropertiesEXT_CallbackBool; + CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALLBACK vkGetPhysicalDeviceToolPropertiesEXT_CallbackFunctionPointer; + int vkGetPhysicalDeviceToolPropertiesEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceToolPropertiesEXT_CallInstance; + char vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_IgnoreBool; + VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_FinalReturn; + char vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallbackBool; + CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALLBACK vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallbackFunctionPointer; + int vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallInstance; + char vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_IgnoreBool; + VkResult vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_FinalReturn; + char vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallbackBool; + CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALLBACK vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallbackFunctionPointer; + int vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallInstance; + char vkCreateHeadlessSurfaceEXT_IgnoreBool; + VkResult vkCreateHeadlessSurfaceEXT_FinalReturn; + char vkCreateHeadlessSurfaceEXT_CallbackBool; + CMOCK_vkCreateHeadlessSurfaceEXT_CALLBACK vkCreateHeadlessSurfaceEXT_CallbackFunctionPointer; + int vkCreateHeadlessSurfaceEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateHeadlessSurfaceEXT_CallInstance; + char vkCmdSetLineStippleEXT_IgnoreBool; + char vkCmdSetLineStippleEXT_CallbackBool; + CMOCK_vkCmdSetLineStippleEXT_CALLBACK vkCmdSetLineStippleEXT_CallbackFunctionPointer; + int vkCmdSetLineStippleEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetLineStippleEXT_CallInstance; + char vkResetQueryPoolEXT_IgnoreBool; + char vkResetQueryPoolEXT_CallbackBool; + CMOCK_vkResetQueryPoolEXT_CALLBACK vkResetQueryPoolEXT_CallbackFunctionPointer; + int vkResetQueryPoolEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkResetQueryPoolEXT_CallInstance; + char vkCmdSetCullModeEXT_IgnoreBool; + char vkCmdSetCullModeEXT_CallbackBool; + CMOCK_vkCmdSetCullModeEXT_CALLBACK vkCmdSetCullModeEXT_CallbackFunctionPointer; + int vkCmdSetCullModeEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetCullModeEXT_CallInstance; + char vkCmdSetFrontFaceEXT_IgnoreBool; + char vkCmdSetFrontFaceEXT_CallbackBool; + CMOCK_vkCmdSetFrontFaceEXT_CALLBACK vkCmdSetFrontFaceEXT_CallbackFunctionPointer; + int vkCmdSetFrontFaceEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetFrontFaceEXT_CallInstance; + char vkCmdSetPrimitiveTopologyEXT_IgnoreBool; + char vkCmdSetPrimitiveTopologyEXT_CallbackBool; + CMOCK_vkCmdSetPrimitiveTopologyEXT_CALLBACK vkCmdSetPrimitiveTopologyEXT_CallbackFunctionPointer; + int vkCmdSetPrimitiveTopologyEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetPrimitiveTopologyEXT_CallInstance; + char vkCmdSetViewportWithCountEXT_IgnoreBool; + char vkCmdSetViewportWithCountEXT_CallbackBool; + CMOCK_vkCmdSetViewportWithCountEXT_CALLBACK vkCmdSetViewportWithCountEXT_CallbackFunctionPointer; + int vkCmdSetViewportWithCountEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetViewportWithCountEXT_CallInstance; + char vkCmdSetScissorWithCountEXT_IgnoreBool; + char vkCmdSetScissorWithCountEXT_CallbackBool; + CMOCK_vkCmdSetScissorWithCountEXT_CALLBACK vkCmdSetScissorWithCountEXT_CallbackFunctionPointer; + int vkCmdSetScissorWithCountEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetScissorWithCountEXT_CallInstance; + char vkCmdBindVertexBuffers2EXT_IgnoreBool; + char vkCmdBindVertexBuffers2EXT_CallbackBool; + CMOCK_vkCmdBindVertexBuffers2EXT_CALLBACK vkCmdBindVertexBuffers2EXT_CallbackFunctionPointer; + int vkCmdBindVertexBuffers2EXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBindVertexBuffers2EXT_CallInstance; + char vkCmdSetDepthTestEnableEXT_IgnoreBool; + char vkCmdSetDepthTestEnableEXT_CallbackBool; + CMOCK_vkCmdSetDepthTestEnableEXT_CALLBACK vkCmdSetDepthTestEnableEXT_CallbackFunctionPointer; + int vkCmdSetDepthTestEnableEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetDepthTestEnableEXT_CallInstance; + char vkCmdSetDepthWriteEnableEXT_IgnoreBool; + char vkCmdSetDepthWriteEnableEXT_CallbackBool; + CMOCK_vkCmdSetDepthWriteEnableEXT_CALLBACK vkCmdSetDepthWriteEnableEXT_CallbackFunctionPointer; + int vkCmdSetDepthWriteEnableEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetDepthWriteEnableEXT_CallInstance; + char vkCmdSetDepthCompareOpEXT_IgnoreBool; + char vkCmdSetDepthCompareOpEXT_CallbackBool; + CMOCK_vkCmdSetDepthCompareOpEXT_CALLBACK vkCmdSetDepthCompareOpEXT_CallbackFunctionPointer; + int vkCmdSetDepthCompareOpEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetDepthCompareOpEXT_CallInstance; + char vkCmdSetDepthBoundsTestEnableEXT_IgnoreBool; + char vkCmdSetDepthBoundsTestEnableEXT_CallbackBool; + CMOCK_vkCmdSetDepthBoundsTestEnableEXT_CALLBACK vkCmdSetDepthBoundsTestEnableEXT_CallbackFunctionPointer; + int vkCmdSetDepthBoundsTestEnableEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetDepthBoundsTestEnableEXT_CallInstance; + char vkCmdSetStencilTestEnableEXT_IgnoreBool; + char vkCmdSetStencilTestEnableEXT_CallbackBool; + CMOCK_vkCmdSetStencilTestEnableEXT_CALLBACK vkCmdSetStencilTestEnableEXT_CallbackFunctionPointer; + int vkCmdSetStencilTestEnableEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetStencilTestEnableEXT_CallInstance; + char vkCmdSetStencilOpEXT_IgnoreBool; + char vkCmdSetStencilOpEXT_CallbackBool; + CMOCK_vkCmdSetStencilOpEXT_CALLBACK vkCmdSetStencilOpEXT_CallbackFunctionPointer; + int vkCmdSetStencilOpEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetStencilOpEXT_CallInstance; + char vkReleaseSwapchainImagesEXT_IgnoreBool; + VkResult vkReleaseSwapchainImagesEXT_FinalReturn; + char vkReleaseSwapchainImagesEXT_CallbackBool; + CMOCK_vkReleaseSwapchainImagesEXT_CALLBACK vkReleaseSwapchainImagesEXT_CallbackFunctionPointer; + int vkReleaseSwapchainImagesEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkReleaseSwapchainImagesEXT_CallInstance; + char vkGetGeneratedCommandsMemoryRequirementsNV_IgnoreBool; + char vkGetGeneratedCommandsMemoryRequirementsNV_CallbackBool; + CMOCK_vkGetGeneratedCommandsMemoryRequirementsNV_CALLBACK vkGetGeneratedCommandsMemoryRequirementsNV_CallbackFunctionPointer; + int vkGetGeneratedCommandsMemoryRequirementsNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetGeneratedCommandsMemoryRequirementsNV_CallInstance; + char vkCmdPreprocessGeneratedCommandsNV_IgnoreBool; + char vkCmdPreprocessGeneratedCommandsNV_CallbackBool; + CMOCK_vkCmdPreprocessGeneratedCommandsNV_CALLBACK vkCmdPreprocessGeneratedCommandsNV_CallbackFunctionPointer; + int vkCmdPreprocessGeneratedCommandsNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdPreprocessGeneratedCommandsNV_CallInstance; + char vkCmdExecuteGeneratedCommandsNV_IgnoreBool; + char vkCmdExecuteGeneratedCommandsNV_CallbackBool; + CMOCK_vkCmdExecuteGeneratedCommandsNV_CALLBACK vkCmdExecuteGeneratedCommandsNV_CallbackFunctionPointer; + int vkCmdExecuteGeneratedCommandsNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdExecuteGeneratedCommandsNV_CallInstance; + char vkCmdBindPipelineShaderGroupNV_IgnoreBool; + char vkCmdBindPipelineShaderGroupNV_CallbackBool; + CMOCK_vkCmdBindPipelineShaderGroupNV_CALLBACK vkCmdBindPipelineShaderGroupNV_CallbackFunctionPointer; + int vkCmdBindPipelineShaderGroupNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBindPipelineShaderGroupNV_CallInstance; + char vkCreateIndirectCommandsLayoutNV_IgnoreBool; + VkResult vkCreateIndirectCommandsLayoutNV_FinalReturn; + char vkCreateIndirectCommandsLayoutNV_CallbackBool; + CMOCK_vkCreateIndirectCommandsLayoutNV_CALLBACK vkCreateIndirectCommandsLayoutNV_CallbackFunctionPointer; + int vkCreateIndirectCommandsLayoutNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateIndirectCommandsLayoutNV_CallInstance; + char vkDestroyIndirectCommandsLayoutNV_IgnoreBool; + char vkDestroyIndirectCommandsLayoutNV_CallbackBool; + CMOCK_vkDestroyIndirectCommandsLayoutNV_CALLBACK vkDestroyIndirectCommandsLayoutNV_CallbackFunctionPointer; + int vkDestroyIndirectCommandsLayoutNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyIndirectCommandsLayoutNV_CallInstance; + char vkAcquireDrmDisplayEXT_IgnoreBool; + VkResult vkAcquireDrmDisplayEXT_FinalReturn; + char vkAcquireDrmDisplayEXT_CallbackBool; + CMOCK_vkAcquireDrmDisplayEXT_CALLBACK vkAcquireDrmDisplayEXT_CallbackFunctionPointer; + int vkAcquireDrmDisplayEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkAcquireDrmDisplayEXT_CallInstance; + char vkGetDrmDisplayEXT_IgnoreBool; + VkResult vkGetDrmDisplayEXT_FinalReturn; + char vkGetDrmDisplayEXT_CallbackBool; + CMOCK_vkGetDrmDisplayEXT_CALLBACK vkGetDrmDisplayEXT_CallbackFunctionPointer; + int vkGetDrmDisplayEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDrmDisplayEXT_CallInstance; + char vkCreatePrivateDataSlotEXT_IgnoreBool; + VkResult vkCreatePrivateDataSlotEXT_FinalReturn; + char vkCreatePrivateDataSlotEXT_CallbackBool; + CMOCK_vkCreatePrivateDataSlotEXT_CALLBACK vkCreatePrivateDataSlotEXT_CallbackFunctionPointer; + int vkCreatePrivateDataSlotEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreatePrivateDataSlotEXT_CallInstance; + char vkDestroyPrivateDataSlotEXT_IgnoreBool; + char vkDestroyPrivateDataSlotEXT_CallbackBool; + CMOCK_vkDestroyPrivateDataSlotEXT_CALLBACK vkDestroyPrivateDataSlotEXT_CallbackFunctionPointer; + int vkDestroyPrivateDataSlotEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyPrivateDataSlotEXT_CallInstance; + char vkSetPrivateDataEXT_IgnoreBool; + VkResult vkSetPrivateDataEXT_FinalReturn; + char vkSetPrivateDataEXT_CallbackBool; + CMOCK_vkSetPrivateDataEXT_CALLBACK vkSetPrivateDataEXT_CallbackFunctionPointer; + int vkSetPrivateDataEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkSetPrivateDataEXT_CallInstance; + char vkGetPrivateDataEXT_IgnoreBool; + char vkGetPrivateDataEXT_CallbackBool; + CMOCK_vkGetPrivateDataEXT_CALLBACK vkGetPrivateDataEXT_CallbackFunctionPointer; + int vkGetPrivateDataEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPrivateDataEXT_CallInstance; + char vkGetDescriptorSetLayoutSizeEXT_IgnoreBool; + char vkGetDescriptorSetLayoutSizeEXT_CallbackBool; + CMOCK_vkGetDescriptorSetLayoutSizeEXT_CALLBACK vkGetDescriptorSetLayoutSizeEXT_CallbackFunctionPointer; + int vkGetDescriptorSetLayoutSizeEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDescriptorSetLayoutSizeEXT_CallInstance; + char vkGetDescriptorSetLayoutBindingOffsetEXT_IgnoreBool; + char vkGetDescriptorSetLayoutBindingOffsetEXT_CallbackBool; + CMOCK_vkGetDescriptorSetLayoutBindingOffsetEXT_CALLBACK vkGetDescriptorSetLayoutBindingOffsetEXT_CallbackFunctionPointer; + int vkGetDescriptorSetLayoutBindingOffsetEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDescriptorSetLayoutBindingOffsetEXT_CallInstance; + char vkGetDescriptorEXT_IgnoreBool; + char vkGetDescriptorEXT_CallbackBool; + CMOCK_vkGetDescriptorEXT_CALLBACK vkGetDescriptorEXT_CallbackFunctionPointer; + int vkGetDescriptorEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDescriptorEXT_CallInstance; + char vkCmdBindDescriptorBuffersEXT_IgnoreBool; + char vkCmdBindDescriptorBuffersEXT_CallbackBool; + CMOCK_vkCmdBindDescriptorBuffersEXT_CALLBACK vkCmdBindDescriptorBuffersEXT_CallbackFunctionPointer; + int vkCmdBindDescriptorBuffersEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBindDescriptorBuffersEXT_CallInstance; + char vkCmdSetDescriptorBufferOffsetsEXT_IgnoreBool; + char vkCmdSetDescriptorBufferOffsetsEXT_CallbackBool; + CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALLBACK vkCmdSetDescriptorBufferOffsetsEXT_CallbackFunctionPointer; + int vkCmdSetDescriptorBufferOffsetsEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetDescriptorBufferOffsetsEXT_CallInstance; + char vkCmdBindDescriptorBufferEmbeddedSamplersEXT_IgnoreBool; + char vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CallbackBool; + CMOCK_vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CALLBACK vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CallbackFunctionPointer; + int vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CallInstance; + char vkGetBufferOpaqueCaptureDescriptorDataEXT_IgnoreBool; + VkResult vkGetBufferOpaqueCaptureDescriptorDataEXT_FinalReturn; + char vkGetBufferOpaqueCaptureDescriptorDataEXT_CallbackBool; + CMOCK_vkGetBufferOpaqueCaptureDescriptorDataEXT_CALLBACK vkGetBufferOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer; + int vkGetBufferOpaqueCaptureDescriptorDataEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetBufferOpaqueCaptureDescriptorDataEXT_CallInstance; + char vkGetImageOpaqueCaptureDescriptorDataEXT_IgnoreBool; + VkResult vkGetImageOpaqueCaptureDescriptorDataEXT_FinalReturn; + char vkGetImageOpaqueCaptureDescriptorDataEXT_CallbackBool; + CMOCK_vkGetImageOpaqueCaptureDescriptorDataEXT_CALLBACK vkGetImageOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer; + int vkGetImageOpaqueCaptureDescriptorDataEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetImageOpaqueCaptureDescriptorDataEXT_CallInstance; + char vkGetImageViewOpaqueCaptureDescriptorDataEXT_IgnoreBool; + VkResult vkGetImageViewOpaqueCaptureDescriptorDataEXT_FinalReturn; + char vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallbackBool; + CMOCK_vkGetImageViewOpaqueCaptureDescriptorDataEXT_CALLBACK vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer; + int vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallInstance; + char vkGetSamplerOpaqueCaptureDescriptorDataEXT_IgnoreBool; + VkResult vkGetSamplerOpaqueCaptureDescriptorDataEXT_FinalReturn; + char vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallbackBool; + CMOCK_vkGetSamplerOpaqueCaptureDescriptorDataEXT_CALLBACK vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer; + int vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallInstance; + char vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_IgnoreBool; + VkResult vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_FinalReturn; + char vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallbackBool; + CMOCK_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CALLBACK vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer; + int vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallInstance; + char vkCmdSetFragmentShadingRateEnumNV_IgnoreBool; + char vkCmdSetFragmentShadingRateEnumNV_CallbackBool; + CMOCK_vkCmdSetFragmentShadingRateEnumNV_CALLBACK vkCmdSetFragmentShadingRateEnumNV_CallbackFunctionPointer; + int vkCmdSetFragmentShadingRateEnumNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetFragmentShadingRateEnumNV_CallInstance; + char vkGetImageSubresourceLayout2EXT_IgnoreBool; + char vkGetImageSubresourceLayout2EXT_CallbackBool; + CMOCK_vkGetImageSubresourceLayout2EXT_CALLBACK vkGetImageSubresourceLayout2EXT_CallbackFunctionPointer; + int vkGetImageSubresourceLayout2EXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetImageSubresourceLayout2EXT_CallInstance; + char vkGetDeviceFaultInfoEXT_IgnoreBool; + VkResult vkGetDeviceFaultInfoEXT_FinalReturn; + char vkGetDeviceFaultInfoEXT_CallbackBool; + CMOCK_vkGetDeviceFaultInfoEXT_CALLBACK vkGetDeviceFaultInfoEXT_CallbackFunctionPointer; + int vkGetDeviceFaultInfoEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDeviceFaultInfoEXT_CallInstance; + char vkCmdSetVertexInputEXT_IgnoreBool; + char vkCmdSetVertexInputEXT_CallbackBool; + CMOCK_vkCmdSetVertexInputEXT_CALLBACK vkCmdSetVertexInputEXT_CallbackFunctionPointer; + int vkCmdSetVertexInputEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetVertexInputEXT_CallInstance; + char vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_IgnoreBool; + VkResult vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_FinalReturn; + char vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallbackBool; + CMOCK_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CALLBACK vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallbackFunctionPointer; + int vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallInstance; + char vkCmdSubpassShadingHUAWEI_IgnoreBool; + char vkCmdSubpassShadingHUAWEI_CallbackBool; + CMOCK_vkCmdSubpassShadingHUAWEI_CALLBACK vkCmdSubpassShadingHUAWEI_CallbackFunctionPointer; + int vkCmdSubpassShadingHUAWEI_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSubpassShadingHUAWEI_CallInstance; + char vkCmdBindInvocationMaskHUAWEI_IgnoreBool; + char vkCmdBindInvocationMaskHUAWEI_CallbackBool; + CMOCK_vkCmdBindInvocationMaskHUAWEI_CALLBACK vkCmdBindInvocationMaskHUAWEI_CallbackFunctionPointer; + int vkCmdBindInvocationMaskHUAWEI_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBindInvocationMaskHUAWEI_CallInstance; + char vkGetMemoryRemoteAddressNV_IgnoreBool; + VkResult vkGetMemoryRemoteAddressNV_FinalReturn; + char vkGetMemoryRemoteAddressNV_CallbackBool; + CMOCK_vkGetMemoryRemoteAddressNV_CALLBACK vkGetMemoryRemoteAddressNV_CallbackFunctionPointer; + int vkGetMemoryRemoteAddressNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetMemoryRemoteAddressNV_CallInstance; + char vkGetPipelinePropertiesEXT_IgnoreBool; + VkResult vkGetPipelinePropertiesEXT_FinalReturn; + char vkGetPipelinePropertiesEXT_CallbackBool; + CMOCK_vkGetPipelinePropertiesEXT_CALLBACK vkGetPipelinePropertiesEXT_CallbackFunctionPointer; + int vkGetPipelinePropertiesEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPipelinePropertiesEXT_CallInstance; + char vkCmdSetPatchControlPointsEXT_IgnoreBool; + char vkCmdSetPatchControlPointsEXT_CallbackBool; + CMOCK_vkCmdSetPatchControlPointsEXT_CALLBACK vkCmdSetPatchControlPointsEXT_CallbackFunctionPointer; + int vkCmdSetPatchControlPointsEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetPatchControlPointsEXT_CallInstance; + char vkCmdSetRasterizerDiscardEnableEXT_IgnoreBool; + char vkCmdSetRasterizerDiscardEnableEXT_CallbackBool; + CMOCK_vkCmdSetRasterizerDiscardEnableEXT_CALLBACK vkCmdSetRasterizerDiscardEnableEXT_CallbackFunctionPointer; + int vkCmdSetRasterizerDiscardEnableEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetRasterizerDiscardEnableEXT_CallInstance; + char vkCmdSetDepthBiasEnableEXT_IgnoreBool; + char vkCmdSetDepthBiasEnableEXT_CallbackBool; + CMOCK_vkCmdSetDepthBiasEnableEXT_CALLBACK vkCmdSetDepthBiasEnableEXT_CallbackFunctionPointer; + int vkCmdSetDepthBiasEnableEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetDepthBiasEnableEXT_CallInstance; + char vkCmdSetLogicOpEXT_IgnoreBool; + char vkCmdSetLogicOpEXT_CallbackBool; + CMOCK_vkCmdSetLogicOpEXT_CALLBACK vkCmdSetLogicOpEXT_CallbackFunctionPointer; + int vkCmdSetLogicOpEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetLogicOpEXT_CallInstance; + char vkCmdSetPrimitiveRestartEnableEXT_IgnoreBool; + char vkCmdSetPrimitiveRestartEnableEXT_CallbackBool; + CMOCK_vkCmdSetPrimitiveRestartEnableEXT_CALLBACK vkCmdSetPrimitiveRestartEnableEXT_CallbackFunctionPointer; + int vkCmdSetPrimitiveRestartEnableEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetPrimitiveRestartEnableEXT_CallInstance; + char vkCmdSetColorWriteEnableEXT_IgnoreBool; + char vkCmdSetColorWriteEnableEXT_CallbackBool; + CMOCK_vkCmdSetColorWriteEnableEXT_CALLBACK vkCmdSetColorWriteEnableEXT_CallbackFunctionPointer; + int vkCmdSetColorWriteEnableEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetColorWriteEnableEXT_CallInstance; + char vkCmdDrawMultiEXT_IgnoreBool; + char vkCmdDrawMultiEXT_CallbackBool; + CMOCK_vkCmdDrawMultiEXT_CALLBACK vkCmdDrawMultiEXT_CallbackFunctionPointer; + int vkCmdDrawMultiEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDrawMultiEXT_CallInstance; + char vkCmdDrawMultiIndexedEXT_IgnoreBool; + char vkCmdDrawMultiIndexedEXT_CallbackBool; + CMOCK_vkCmdDrawMultiIndexedEXT_CALLBACK vkCmdDrawMultiIndexedEXT_CallbackFunctionPointer; + int vkCmdDrawMultiIndexedEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDrawMultiIndexedEXT_CallInstance; + char vkCreateMicromapEXT_IgnoreBool; + VkResult vkCreateMicromapEXT_FinalReturn; + char vkCreateMicromapEXT_CallbackBool; + CMOCK_vkCreateMicromapEXT_CALLBACK vkCreateMicromapEXT_CallbackFunctionPointer; + int vkCreateMicromapEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateMicromapEXT_CallInstance; + char vkDestroyMicromapEXT_IgnoreBool; + char vkDestroyMicromapEXT_CallbackBool; + CMOCK_vkDestroyMicromapEXT_CALLBACK vkDestroyMicromapEXT_CallbackFunctionPointer; + int vkDestroyMicromapEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyMicromapEXT_CallInstance; + char vkCmdBuildMicromapsEXT_IgnoreBool; + char vkCmdBuildMicromapsEXT_CallbackBool; + CMOCK_vkCmdBuildMicromapsEXT_CALLBACK vkCmdBuildMicromapsEXT_CallbackFunctionPointer; + int vkCmdBuildMicromapsEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBuildMicromapsEXT_CallInstance; + char vkBuildMicromapsEXT_IgnoreBool; + VkResult vkBuildMicromapsEXT_FinalReturn; + char vkBuildMicromapsEXT_CallbackBool; + CMOCK_vkBuildMicromapsEXT_CALLBACK vkBuildMicromapsEXT_CallbackFunctionPointer; + int vkBuildMicromapsEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkBuildMicromapsEXT_CallInstance; + char vkCopyMicromapEXT_IgnoreBool; + VkResult vkCopyMicromapEXT_FinalReturn; + char vkCopyMicromapEXT_CallbackBool; + CMOCK_vkCopyMicromapEXT_CALLBACK vkCopyMicromapEXT_CallbackFunctionPointer; + int vkCopyMicromapEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCopyMicromapEXT_CallInstance; + char vkCopyMicromapToMemoryEXT_IgnoreBool; + VkResult vkCopyMicromapToMemoryEXT_FinalReturn; + char vkCopyMicromapToMemoryEXT_CallbackBool; + CMOCK_vkCopyMicromapToMemoryEXT_CALLBACK vkCopyMicromapToMemoryEXT_CallbackFunctionPointer; + int vkCopyMicromapToMemoryEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCopyMicromapToMemoryEXT_CallInstance; + char vkCopyMemoryToMicromapEXT_IgnoreBool; + VkResult vkCopyMemoryToMicromapEXT_FinalReturn; + char vkCopyMemoryToMicromapEXT_CallbackBool; + CMOCK_vkCopyMemoryToMicromapEXT_CALLBACK vkCopyMemoryToMicromapEXT_CallbackFunctionPointer; + int vkCopyMemoryToMicromapEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCopyMemoryToMicromapEXT_CallInstance; + char vkWriteMicromapsPropertiesEXT_IgnoreBool; + VkResult vkWriteMicromapsPropertiesEXT_FinalReturn; + char vkWriteMicromapsPropertiesEXT_CallbackBool; + CMOCK_vkWriteMicromapsPropertiesEXT_CALLBACK vkWriteMicromapsPropertiesEXT_CallbackFunctionPointer; + int vkWriteMicromapsPropertiesEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkWriteMicromapsPropertiesEXT_CallInstance; + char vkCmdCopyMicromapEXT_IgnoreBool; + char vkCmdCopyMicromapEXT_CallbackBool; + CMOCK_vkCmdCopyMicromapEXT_CALLBACK vkCmdCopyMicromapEXT_CallbackFunctionPointer; + int vkCmdCopyMicromapEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdCopyMicromapEXT_CallInstance; + char vkCmdCopyMicromapToMemoryEXT_IgnoreBool; + char vkCmdCopyMicromapToMemoryEXT_CallbackBool; + CMOCK_vkCmdCopyMicromapToMemoryEXT_CALLBACK vkCmdCopyMicromapToMemoryEXT_CallbackFunctionPointer; + int vkCmdCopyMicromapToMemoryEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdCopyMicromapToMemoryEXT_CallInstance; + char vkCmdCopyMemoryToMicromapEXT_IgnoreBool; + char vkCmdCopyMemoryToMicromapEXT_CallbackBool; + CMOCK_vkCmdCopyMemoryToMicromapEXT_CALLBACK vkCmdCopyMemoryToMicromapEXT_CallbackFunctionPointer; + int vkCmdCopyMemoryToMicromapEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdCopyMemoryToMicromapEXT_CallInstance; + char vkCmdWriteMicromapsPropertiesEXT_IgnoreBool; + char vkCmdWriteMicromapsPropertiesEXT_CallbackBool; + CMOCK_vkCmdWriteMicromapsPropertiesEXT_CALLBACK vkCmdWriteMicromapsPropertiesEXT_CallbackFunctionPointer; + int vkCmdWriteMicromapsPropertiesEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdWriteMicromapsPropertiesEXT_CallInstance; + char vkGetDeviceMicromapCompatibilityEXT_IgnoreBool; + char vkGetDeviceMicromapCompatibilityEXT_CallbackBool; + CMOCK_vkGetDeviceMicromapCompatibilityEXT_CALLBACK vkGetDeviceMicromapCompatibilityEXT_CallbackFunctionPointer; + int vkGetDeviceMicromapCompatibilityEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDeviceMicromapCompatibilityEXT_CallInstance; + char vkGetMicromapBuildSizesEXT_IgnoreBool; + char vkGetMicromapBuildSizesEXT_CallbackBool; + CMOCK_vkGetMicromapBuildSizesEXT_CALLBACK vkGetMicromapBuildSizesEXT_CallbackFunctionPointer; + int vkGetMicromapBuildSizesEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetMicromapBuildSizesEXT_CallInstance; + char vkCmdDrawClusterHUAWEI_IgnoreBool; + char vkCmdDrawClusterHUAWEI_CallbackBool; + CMOCK_vkCmdDrawClusterHUAWEI_CALLBACK vkCmdDrawClusterHUAWEI_CallbackFunctionPointer; + int vkCmdDrawClusterHUAWEI_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDrawClusterHUAWEI_CallInstance; + char vkCmdDrawClusterIndirectHUAWEI_IgnoreBool; + char vkCmdDrawClusterIndirectHUAWEI_CallbackBool; + CMOCK_vkCmdDrawClusterIndirectHUAWEI_CALLBACK vkCmdDrawClusterIndirectHUAWEI_CallbackFunctionPointer; + int vkCmdDrawClusterIndirectHUAWEI_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDrawClusterIndirectHUAWEI_CallInstance; + char vkSetDeviceMemoryPriorityEXT_IgnoreBool; + char vkSetDeviceMemoryPriorityEXT_CallbackBool; + CMOCK_vkSetDeviceMemoryPriorityEXT_CALLBACK vkSetDeviceMemoryPriorityEXT_CallbackFunctionPointer; + int vkSetDeviceMemoryPriorityEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkSetDeviceMemoryPriorityEXT_CallInstance; + char vkGetDescriptorSetLayoutHostMappingInfoVALVE_IgnoreBool; + char vkGetDescriptorSetLayoutHostMappingInfoVALVE_CallbackBool; + CMOCK_vkGetDescriptorSetLayoutHostMappingInfoVALVE_CALLBACK vkGetDescriptorSetLayoutHostMappingInfoVALVE_CallbackFunctionPointer; + int vkGetDescriptorSetLayoutHostMappingInfoVALVE_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDescriptorSetLayoutHostMappingInfoVALVE_CallInstance; + char vkGetDescriptorSetHostMappingVALVE_IgnoreBool; + char vkGetDescriptorSetHostMappingVALVE_CallbackBool; + CMOCK_vkGetDescriptorSetHostMappingVALVE_CALLBACK vkGetDescriptorSetHostMappingVALVE_CallbackFunctionPointer; + int vkGetDescriptorSetHostMappingVALVE_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDescriptorSetHostMappingVALVE_CallInstance; + char vkCmdCopyMemoryIndirectNV_IgnoreBool; + char vkCmdCopyMemoryIndirectNV_CallbackBool; + CMOCK_vkCmdCopyMemoryIndirectNV_CALLBACK vkCmdCopyMemoryIndirectNV_CallbackFunctionPointer; + int vkCmdCopyMemoryIndirectNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdCopyMemoryIndirectNV_CallInstance; + char vkCmdCopyMemoryToImageIndirectNV_IgnoreBool; + char vkCmdCopyMemoryToImageIndirectNV_CallbackBool; + CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALLBACK vkCmdCopyMemoryToImageIndirectNV_CallbackFunctionPointer; + int vkCmdCopyMemoryToImageIndirectNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdCopyMemoryToImageIndirectNV_CallInstance; + char vkCmdDecompressMemoryNV_IgnoreBool; + char vkCmdDecompressMemoryNV_CallbackBool; + CMOCK_vkCmdDecompressMemoryNV_CALLBACK vkCmdDecompressMemoryNV_CallbackFunctionPointer; + int vkCmdDecompressMemoryNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDecompressMemoryNV_CallInstance; + char vkCmdDecompressMemoryIndirectCountNV_IgnoreBool; + char vkCmdDecompressMemoryIndirectCountNV_CallbackBool; + CMOCK_vkCmdDecompressMemoryIndirectCountNV_CALLBACK vkCmdDecompressMemoryIndirectCountNV_CallbackFunctionPointer; + int vkCmdDecompressMemoryIndirectCountNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDecompressMemoryIndirectCountNV_CallInstance; + char vkCmdSetTessellationDomainOriginEXT_IgnoreBool; + char vkCmdSetTessellationDomainOriginEXT_CallbackBool; + CMOCK_vkCmdSetTessellationDomainOriginEXT_CALLBACK vkCmdSetTessellationDomainOriginEXT_CallbackFunctionPointer; + int vkCmdSetTessellationDomainOriginEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetTessellationDomainOriginEXT_CallInstance; + char vkCmdSetDepthClampEnableEXT_IgnoreBool; + char vkCmdSetDepthClampEnableEXT_CallbackBool; + CMOCK_vkCmdSetDepthClampEnableEXT_CALLBACK vkCmdSetDepthClampEnableEXT_CallbackFunctionPointer; + int vkCmdSetDepthClampEnableEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetDepthClampEnableEXT_CallInstance; + char vkCmdSetPolygonModeEXT_IgnoreBool; + char vkCmdSetPolygonModeEXT_CallbackBool; + CMOCK_vkCmdSetPolygonModeEXT_CALLBACK vkCmdSetPolygonModeEXT_CallbackFunctionPointer; + int vkCmdSetPolygonModeEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetPolygonModeEXT_CallInstance; + char vkCmdSetRasterizationSamplesEXT_IgnoreBool; + char vkCmdSetRasterizationSamplesEXT_CallbackBool; + CMOCK_vkCmdSetRasterizationSamplesEXT_CALLBACK vkCmdSetRasterizationSamplesEXT_CallbackFunctionPointer; + int vkCmdSetRasterizationSamplesEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetRasterizationSamplesEXT_CallInstance; + char vkCmdSetSampleMaskEXT_IgnoreBool; + char vkCmdSetSampleMaskEXT_CallbackBool; + CMOCK_vkCmdSetSampleMaskEXT_CALLBACK vkCmdSetSampleMaskEXT_CallbackFunctionPointer; + int vkCmdSetSampleMaskEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetSampleMaskEXT_CallInstance; + char vkCmdSetAlphaToCoverageEnableEXT_IgnoreBool; + char vkCmdSetAlphaToCoverageEnableEXT_CallbackBool; + CMOCK_vkCmdSetAlphaToCoverageEnableEXT_CALLBACK vkCmdSetAlphaToCoverageEnableEXT_CallbackFunctionPointer; + int vkCmdSetAlphaToCoverageEnableEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetAlphaToCoverageEnableEXT_CallInstance; + char vkCmdSetAlphaToOneEnableEXT_IgnoreBool; + char vkCmdSetAlphaToOneEnableEXT_CallbackBool; + CMOCK_vkCmdSetAlphaToOneEnableEXT_CALLBACK vkCmdSetAlphaToOneEnableEXT_CallbackFunctionPointer; + int vkCmdSetAlphaToOneEnableEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetAlphaToOneEnableEXT_CallInstance; + char vkCmdSetLogicOpEnableEXT_IgnoreBool; + char vkCmdSetLogicOpEnableEXT_CallbackBool; + CMOCK_vkCmdSetLogicOpEnableEXT_CALLBACK vkCmdSetLogicOpEnableEXT_CallbackFunctionPointer; + int vkCmdSetLogicOpEnableEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetLogicOpEnableEXT_CallInstance; + char vkCmdSetColorBlendEnableEXT_IgnoreBool; + char vkCmdSetColorBlendEnableEXT_CallbackBool; + CMOCK_vkCmdSetColorBlendEnableEXT_CALLBACK vkCmdSetColorBlendEnableEXT_CallbackFunctionPointer; + int vkCmdSetColorBlendEnableEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetColorBlendEnableEXT_CallInstance; + char vkCmdSetColorBlendEquationEXT_IgnoreBool; + char vkCmdSetColorBlendEquationEXT_CallbackBool; + CMOCK_vkCmdSetColorBlendEquationEXT_CALLBACK vkCmdSetColorBlendEquationEXT_CallbackFunctionPointer; + int vkCmdSetColorBlendEquationEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetColorBlendEquationEXT_CallInstance; + char vkCmdSetColorWriteMaskEXT_IgnoreBool; + char vkCmdSetColorWriteMaskEXT_CallbackBool; + CMOCK_vkCmdSetColorWriteMaskEXT_CALLBACK vkCmdSetColorWriteMaskEXT_CallbackFunctionPointer; + int vkCmdSetColorWriteMaskEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetColorWriteMaskEXT_CallInstance; + char vkCmdSetRasterizationStreamEXT_IgnoreBool; + char vkCmdSetRasterizationStreamEXT_CallbackBool; + CMOCK_vkCmdSetRasterizationStreamEXT_CALLBACK vkCmdSetRasterizationStreamEXT_CallbackFunctionPointer; + int vkCmdSetRasterizationStreamEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetRasterizationStreamEXT_CallInstance; + char vkCmdSetConservativeRasterizationModeEXT_IgnoreBool; + char vkCmdSetConservativeRasterizationModeEXT_CallbackBool; + CMOCK_vkCmdSetConservativeRasterizationModeEXT_CALLBACK vkCmdSetConservativeRasterizationModeEXT_CallbackFunctionPointer; + int vkCmdSetConservativeRasterizationModeEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetConservativeRasterizationModeEXT_CallInstance; + char vkCmdSetExtraPrimitiveOverestimationSizeEXT_IgnoreBool; + char vkCmdSetExtraPrimitiveOverestimationSizeEXT_CallbackBool; + CMOCK_vkCmdSetExtraPrimitiveOverestimationSizeEXT_CALLBACK vkCmdSetExtraPrimitiveOverestimationSizeEXT_CallbackFunctionPointer; + int vkCmdSetExtraPrimitiveOverestimationSizeEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetExtraPrimitiveOverestimationSizeEXT_CallInstance; + char vkCmdSetDepthClipEnableEXT_IgnoreBool; + char vkCmdSetDepthClipEnableEXT_CallbackBool; + CMOCK_vkCmdSetDepthClipEnableEXT_CALLBACK vkCmdSetDepthClipEnableEXT_CallbackFunctionPointer; + int vkCmdSetDepthClipEnableEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetDepthClipEnableEXT_CallInstance; + char vkCmdSetSampleLocationsEnableEXT_IgnoreBool; + char vkCmdSetSampleLocationsEnableEXT_CallbackBool; + CMOCK_vkCmdSetSampleLocationsEnableEXT_CALLBACK vkCmdSetSampleLocationsEnableEXT_CallbackFunctionPointer; + int vkCmdSetSampleLocationsEnableEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetSampleLocationsEnableEXT_CallInstance; + char vkCmdSetColorBlendAdvancedEXT_IgnoreBool; + char vkCmdSetColorBlendAdvancedEXT_CallbackBool; + CMOCK_vkCmdSetColorBlendAdvancedEXT_CALLBACK vkCmdSetColorBlendAdvancedEXT_CallbackFunctionPointer; + int vkCmdSetColorBlendAdvancedEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetColorBlendAdvancedEXT_CallInstance; + char vkCmdSetProvokingVertexModeEXT_IgnoreBool; + char vkCmdSetProvokingVertexModeEXT_CallbackBool; + CMOCK_vkCmdSetProvokingVertexModeEXT_CALLBACK vkCmdSetProvokingVertexModeEXT_CallbackFunctionPointer; + int vkCmdSetProvokingVertexModeEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetProvokingVertexModeEXT_CallInstance; + char vkCmdSetLineRasterizationModeEXT_IgnoreBool; + char vkCmdSetLineRasterizationModeEXT_CallbackBool; + CMOCK_vkCmdSetLineRasterizationModeEXT_CALLBACK vkCmdSetLineRasterizationModeEXT_CallbackFunctionPointer; + int vkCmdSetLineRasterizationModeEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetLineRasterizationModeEXT_CallInstance; + char vkCmdSetLineStippleEnableEXT_IgnoreBool; + char vkCmdSetLineStippleEnableEXT_CallbackBool; + CMOCK_vkCmdSetLineStippleEnableEXT_CALLBACK vkCmdSetLineStippleEnableEXT_CallbackFunctionPointer; + int vkCmdSetLineStippleEnableEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetLineStippleEnableEXT_CallInstance; + char vkCmdSetDepthClipNegativeOneToOneEXT_IgnoreBool; + char vkCmdSetDepthClipNegativeOneToOneEXT_CallbackBool; + CMOCK_vkCmdSetDepthClipNegativeOneToOneEXT_CALLBACK vkCmdSetDepthClipNegativeOneToOneEXT_CallbackFunctionPointer; + int vkCmdSetDepthClipNegativeOneToOneEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetDepthClipNegativeOneToOneEXT_CallInstance; + char vkCmdSetViewportWScalingEnableNV_IgnoreBool; + char vkCmdSetViewportWScalingEnableNV_CallbackBool; + CMOCK_vkCmdSetViewportWScalingEnableNV_CALLBACK vkCmdSetViewportWScalingEnableNV_CallbackFunctionPointer; + int vkCmdSetViewportWScalingEnableNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetViewportWScalingEnableNV_CallInstance; + char vkCmdSetViewportSwizzleNV_IgnoreBool; + char vkCmdSetViewportSwizzleNV_CallbackBool; + CMOCK_vkCmdSetViewportSwizzleNV_CALLBACK vkCmdSetViewportSwizzleNV_CallbackFunctionPointer; + int vkCmdSetViewportSwizzleNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetViewportSwizzleNV_CallInstance; + char vkCmdSetCoverageToColorEnableNV_IgnoreBool; + char vkCmdSetCoverageToColorEnableNV_CallbackBool; + CMOCK_vkCmdSetCoverageToColorEnableNV_CALLBACK vkCmdSetCoverageToColorEnableNV_CallbackFunctionPointer; + int vkCmdSetCoverageToColorEnableNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetCoverageToColorEnableNV_CallInstance; + char vkCmdSetCoverageToColorLocationNV_IgnoreBool; + char vkCmdSetCoverageToColorLocationNV_CallbackBool; + CMOCK_vkCmdSetCoverageToColorLocationNV_CALLBACK vkCmdSetCoverageToColorLocationNV_CallbackFunctionPointer; + int vkCmdSetCoverageToColorLocationNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetCoverageToColorLocationNV_CallInstance; + char vkCmdSetCoverageModulationModeNV_IgnoreBool; + char vkCmdSetCoverageModulationModeNV_CallbackBool; + CMOCK_vkCmdSetCoverageModulationModeNV_CALLBACK vkCmdSetCoverageModulationModeNV_CallbackFunctionPointer; + int vkCmdSetCoverageModulationModeNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetCoverageModulationModeNV_CallInstance; + char vkCmdSetCoverageModulationTableEnableNV_IgnoreBool; + char vkCmdSetCoverageModulationTableEnableNV_CallbackBool; + CMOCK_vkCmdSetCoverageModulationTableEnableNV_CALLBACK vkCmdSetCoverageModulationTableEnableNV_CallbackFunctionPointer; + int vkCmdSetCoverageModulationTableEnableNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetCoverageModulationTableEnableNV_CallInstance; + char vkCmdSetCoverageModulationTableNV_IgnoreBool; + char vkCmdSetCoverageModulationTableNV_CallbackBool; + CMOCK_vkCmdSetCoverageModulationTableNV_CALLBACK vkCmdSetCoverageModulationTableNV_CallbackFunctionPointer; + int vkCmdSetCoverageModulationTableNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetCoverageModulationTableNV_CallInstance; + char vkCmdSetShadingRateImageEnableNV_IgnoreBool; + char vkCmdSetShadingRateImageEnableNV_CallbackBool; + CMOCK_vkCmdSetShadingRateImageEnableNV_CALLBACK vkCmdSetShadingRateImageEnableNV_CallbackFunctionPointer; + int vkCmdSetShadingRateImageEnableNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetShadingRateImageEnableNV_CallInstance; + char vkCmdSetRepresentativeFragmentTestEnableNV_IgnoreBool; + char vkCmdSetRepresentativeFragmentTestEnableNV_CallbackBool; + CMOCK_vkCmdSetRepresentativeFragmentTestEnableNV_CALLBACK vkCmdSetRepresentativeFragmentTestEnableNV_CallbackFunctionPointer; + int vkCmdSetRepresentativeFragmentTestEnableNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetRepresentativeFragmentTestEnableNV_CallInstance; + char vkCmdSetCoverageReductionModeNV_IgnoreBool; + char vkCmdSetCoverageReductionModeNV_CallbackBool; + CMOCK_vkCmdSetCoverageReductionModeNV_CALLBACK vkCmdSetCoverageReductionModeNV_CallbackFunctionPointer; + int vkCmdSetCoverageReductionModeNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetCoverageReductionModeNV_CallInstance; + char vkGetShaderModuleIdentifierEXT_IgnoreBool; + char vkGetShaderModuleIdentifierEXT_CallbackBool; + CMOCK_vkGetShaderModuleIdentifierEXT_CALLBACK vkGetShaderModuleIdentifierEXT_CallbackFunctionPointer; + int vkGetShaderModuleIdentifierEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetShaderModuleIdentifierEXT_CallInstance; + char vkGetShaderModuleCreateInfoIdentifierEXT_IgnoreBool; + char vkGetShaderModuleCreateInfoIdentifierEXT_CallbackBool; + CMOCK_vkGetShaderModuleCreateInfoIdentifierEXT_CALLBACK vkGetShaderModuleCreateInfoIdentifierEXT_CallbackFunctionPointer; + int vkGetShaderModuleCreateInfoIdentifierEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetShaderModuleCreateInfoIdentifierEXT_CallInstance; + char vkGetPhysicalDeviceOpticalFlowImageFormatsNV_IgnoreBool; + VkResult vkGetPhysicalDeviceOpticalFlowImageFormatsNV_FinalReturn; + char vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallbackBool; + CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALLBACK vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallbackFunctionPointer; + int vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallInstance; + char vkCreateOpticalFlowSessionNV_IgnoreBool; + VkResult vkCreateOpticalFlowSessionNV_FinalReturn; + char vkCreateOpticalFlowSessionNV_CallbackBool; + CMOCK_vkCreateOpticalFlowSessionNV_CALLBACK vkCreateOpticalFlowSessionNV_CallbackFunctionPointer; + int vkCreateOpticalFlowSessionNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateOpticalFlowSessionNV_CallInstance; + char vkDestroyOpticalFlowSessionNV_IgnoreBool; + char vkDestroyOpticalFlowSessionNV_CallbackBool; + CMOCK_vkDestroyOpticalFlowSessionNV_CALLBACK vkDestroyOpticalFlowSessionNV_CallbackFunctionPointer; + int vkDestroyOpticalFlowSessionNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyOpticalFlowSessionNV_CallInstance; + char vkBindOpticalFlowSessionImageNV_IgnoreBool; + VkResult vkBindOpticalFlowSessionImageNV_FinalReturn; + char vkBindOpticalFlowSessionImageNV_CallbackBool; + CMOCK_vkBindOpticalFlowSessionImageNV_CALLBACK vkBindOpticalFlowSessionImageNV_CallbackFunctionPointer; + int vkBindOpticalFlowSessionImageNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkBindOpticalFlowSessionImageNV_CallInstance; + char vkCmdOpticalFlowExecuteNV_IgnoreBool; + char vkCmdOpticalFlowExecuteNV_CallbackBool; + CMOCK_vkCmdOpticalFlowExecuteNV_CALLBACK vkCmdOpticalFlowExecuteNV_CallbackFunctionPointer; + int vkCmdOpticalFlowExecuteNV_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdOpticalFlowExecuteNV_CallInstance; + char vkCreateShadersEXT_IgnoreBool; + VkResult vkCreateShadersEXT_FinalReturn; + char vkCreateShadersEXT_CallbackBool; + CMOCK_vkCreateShadersEXT_CALLBACK vkCreateShadersEXT_CallbackFunctionPointer; + int vkCreateShadersEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateShadersEXT_CallInstance; + char vkDestroyShaderEXT_IgnoreBool; + char vkDestroyShaderEXT_CallbackBool; + CMOCK_vkDestroyShaderEXT_CALLBACK vkDestroyShaderEXT_CallbackFunctionPointer; + int vkDestroyShaderEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyShaderEXT_CallInstance; + char vkGetShaderBinaryDataEXT_IgnoreBool; + VkResult vkGetShaderBinaryDataEXT_FinalReturn; + char vkGetShaderBinaryDataEXT_CallbackBool; + CMOCK_vkGetShaderBinaryDataEXT_CALLBACK vkGetShaderBinaryDataEXT_CallbackFunctionPointer; + int vkGetShaderBinaryDataEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetShaderBinaryDataEXT_CallInstance; + char vkCmdBindShadersEXT_IgnoreBool; + char vkCmdBindShadersEXT_CallbackBool; + CMOCK_vkCmdBindShadersEXT_CALLBACK vkCmdBindShadersEXT_CallbackFunctionPointer; + int vkCmdBindShadersEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBindShadersEXT_CallInstance; + char vkGetFramebufferTilePropertiesQCOM_IgnoreBool; + VkResult vkGetFramebufferTilePropertiesQCOM_FinalReturn; + char vkGetFramebufferTilePropertiesQCOM_CallbackBool; + CMOCK_vkGetFramebufferTilePropertiesQCOM_CALLBACK vkGetFramebufferTilePropertiesQCOM_CallbackFunctionPointer; + int vkGetFramebufferTilePropertiesQCOM_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetFramebufferTilePropertiesQCOM_CallInstance; + char vkGetDynamicRenderingTilePropertiesQCOM_IgnoreBool; + VkResult vkGetDynamicRenderingTilePropertiesQCOM_FinalReturn; + char vkGetDynamicRenderingTilePropertiesQCOM_CallbackBool; + CMOCK_vkGetDynamicRenderingTilePropertiesQCOM_CALLBACK vkGetDynamicRenderingTilePropertiesQCOM_CallbackFunctionPointer; + int vkGetDynamicRenderingTilePropertiesQCOM_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDynamicRenderingTilePropertiesQCOM_CallInstance; + char vkCmdSetAttachmentFeedbackLoopEnableEXT_IgnoreBool; + char vkCmdSetAttachmentFeedbackLoopEnableEXT_CallbackBool; + CMOCK_vkCmdSetAttachmentFeedbackLoopEnableEXT_CALLBACK vkCmdSetAttachmentFeedbackLoopEnableEXT_CallbackFunctionPointer; + int vkCmdSetAttachmentFeedbackLoopEnableEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetAttachmentFeedbackLoopEnableEXT_CallInstance; + char vkCreateAccelerationStructureKHR_IgnoreBool; + VkResult vkCreateAccelerationStructureKHR_FinalReturn; + char vkCreateAccelerationStructureKHR_CallbackBool; + CMOCK_vkCreateAccelerationStructureKHR_CALLBACK vkCreateAccelerationStructureKHR_CallbackFunctionPointer; + int vkCreateAccelerationStructureKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateAccelerationStructureKHR_CallInstance; + char vkDestroyAccelerationStructureKHR_IgnoreBool; + char vkDestroyAccelerationStructureKHR_CallbackBool; + CMOCK_vkDestroyAccelerationStructureKHR_CALLBACK vkDestroyAccelerationStructureKHR_CallbackFunctionPointer; + int vkDestroyAccelerationStructureKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkDestroyAccelerationStructureKHR_CallInstance; + char vkCmdBuildAccelerationStructuresKHR_IgnoreBool; + char vkCmdBuildAccelerationStructuresKHR_CallbackBool; + CMOCK_vkCmdBuildAccelerationStructuresKHR_CALLBACK vkCmdBuildAccelerationStructuresKHR_CallbackFunctionPointer; + int vkCmdBuildAccelerationStructuresKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBuildAccelerationStructuresKHR_CallInstance; + char vkCmdBuildAccelerationStructuresIndirectKHR_IgnoreBool; + char vkCmdBuildAccelerationStructuresIndirectKHR_CallbackBool; + CMOCK_vkCmdBuildAccelerationStructuresIndirectKHR_CALLBACK vkCmdBuildAccelerationStructuresIndirectKHR_CallbackFunctionPointer; + int vkCmdBuildAccelerationStructuresIndirectKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdBuildAccelerationStructuresIndirectKHR_CallInstance; + char vkBuildAccelerationStructuresKHR_IgnoreBool; + VkResult vkBuildAccelerationStructuresKHR_FinalReturn; + char vkBuildAccelerationStructuresKHR_CallbackBool; + CMOCK_vkBuildAccelerationStructuresKHR_CALLBACK vkBuildAccelerationStructuresKHR_CallbackFunctionPointer; + int vkBuildAccelerationStructuresKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkBuildAccelerationStructuresKHR_CallInstance; + char vkCopyAccelerationStructureKHR_IgnoreBool; + VkResult vkCopyAccelerationStructureKHR_FinalReturn; + char vkCopyAccelerationStructureKHR_CallbackBool; + CMOCK_vkCopyAccelerationStructureKHR_CALLBACK vkCopyAccelerationStructureKHR_CallbackFunctionPointer; + int vkCopyAccelerationStructureKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCopyAccelerationStructureKHR_CallInstance; + char vkCopyAccelerationStructureToMemoryKHR_IgnoreBool; + VkResult vkCopyAccelerationStructureToMemoryKHR_FinalReturn; + char vkCopyAccelerationStructureToMemoryKHR_CallbackBool; + CMOCK_vkCopyAccelerationStructureToMemoryKHR_CALLBACK vkCopyAccelerationStructureToMemoryKHR_CallbackFunctionPointer; + int vkCopyAccelerationStructureToMemoryKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCopyAccelerationStructureToMemoryKHR_CallInstance; + char vkCopyMemoryToAccelerationStructureKHR_IgnoreBool; + VkResult vkCopyMemoryToAccelerationStructureKHR_FinalReturn; + char vkCopyMemoryToAccelerationStructureKHR_CallbackBool; + CMOCK_vkCopyMemoryToAccelerationStructureKHR_CALLBACK vkCopyMemoryToAccelerationStructureKHR_CallbackFunctionPointer; + int vkCopyMemoryToAccelerationStructureKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCopyMemoryToAccelerationStructureKHR_CallInstance; + char vkWriteAccelerationStructuresPropertiesKHR_IgnoreBool; + VkResult vkWriteAccelerationStructuresPropertiesKHR_FinalReturn; + char vkWriteAccelerationStructuresPropertiesKHR_CallbackBool; + CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALLBACK vkWriteAccelerationStructuresPropertiesKHR_CallbackFunctionPointer; + int vkWriteAccelerationStructuresPropertiesKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkWriteAccelerationStructuresPropertiesKHR_CallInstance; + char vkCmdCopyAccelerationStructureKHR_IgnoreBool; + char vkCmdCopyAccelerationStructureKHR_CallbackBool; + CMOCK_vkCmdCopyAccelerationStructureKHR_CALLBACK vkCmdCopyAccelerationStructureKHR_CallbackFunctionPointer; + int vkCmdCopyAccelerationStructureKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdCopyAccelerationStructureKHR_CallInstance; + char vkCmdCopyAccelerationStructureToMemoryKHR_IgnoreBool; + char vkCmdCopyAccelerationStructureToMemoryKHR_CallbackBool; + CMOCK_vkCmdCopyAccelerationStructureToMemoryKHR_CALLBACK vkCmdCopyAccelerationStructureToMemoryKHR_CallbackFunctionPointer; + int vkCmdCopyAccelerationStructureToMemoryKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdCopyAccelerationStructureToMemoryKHR_CallInstance; + char vkCmdCopyMemoryToAccelerationStructureKHR_IgnoreBool; + char vkCmdCopyMemoryToAccelerationStructureKHR_CallbackBool; + CMOCK_vkCmdCopyMemoryToAccelerationStructureKHR_CALLBACK vkCmdCopyMemoryToAccelerationStructureKHR_CallbackFunctionPointer; + int vkCmdCopyMemoryToAccelerationStructureKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdCopyMemoryToAccelerationStructureKHR_CallInstance; + char vkGetAccelerationStructureDeviceAddressKHR_IgnoreBool; + VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR_FinalReturn; + char vkGetAccelerationStructureDeviceAddressKHR_CallbackBool; + CMOCK_vkGetAccelerationStructureDeviceAddressKHR_CALLBACK vkGetAccelerationStructureDeviceAddressKHR_CallbackFunctionPointer; + int vkGetAccelerationStructureDeviceAddressKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetAccelerationStructureDeviceAddressKHR_CallInstance; + char vkCmdWriteAccelerationStructuresPropertiesKHR_IgnoreBool; + char vkCmdWriteAccelerationStructuresPropertiesKHR_CallbackBool; + CMOCK_vkCmdWriteAccelerationStructuresPropertiesKHR_CALLBACK vkCmdWriteAccelerationStructuresPropertiesKHR_CallbackFunctionPointer; + int vkCmdWriteAccelerationStructuresPropertiesKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdWriteAccelerationStructuresPropertiesKHR_CallInstance; + char vkGetDeviceAccelerationStructureCompatibilityKHR_IgnoreBool; + char vkGetDeviceAccelerationStructureCompatibilityKHR_CallbackBool; + CMOCK_vkGetDeviceAccelerationStructureCompatibilityKHR_CALLBACK vkGetDeviceAccelerationStructureCompatibilityKHR_CallbackFunctionPointer; + int vkGetDeviceAccelerationStructureCompatibilityKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetDeviceAccelerationStructureCompatibilityKHR_CallInstance; + char vkGetAccelerationStructureBuildSizesKHR_IgnoreBool; + char vkGetAccelerationStructureBuildSizesKHR_CallbackBool; + CMOCK_vkGetAccelerationStructureBuildSizesKHR_CALLBACK vkGetAccelerationStructureBuildSizesKHR_CallbackFunctionPointer; + int vkGetAccelerationStructureBuildSizesKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetAccelerationStructureBuildSizesKHR_CallInstance; + char vkCmdTraceRaysKHR_IgnoreBool; + char vkCmdTraceRaysKHR_CallbackBool; + CMOCK_vkCmdTraceRaysKHR_CALLBACK vkCmdTraceRaysKHR_CallbackFunctionPointer; + int vkCmdTraceRaysKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdTraceRaysKHR_CallInstance; + char vkCreateRayTracingPipelinesKHR_IgnoreBool; + VkResult vkCreateRayTracingPipelinesKHR_FinalReturn; + char vkCreateRayTracingPipelinesKHR_CallbackBool; + CMOCK_vkCreateRayTracingPipelinesKHR_CALLBACK vkCreateRayTracingPipelinesKHR_CallbackFunctionPointer; + int vkCreateRayTracingPipelinesKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCreateRayTracingPipelinesKHR_CallInstance; + char vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_IgnoreBool; + VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_FinalReturn; + char vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallbackBool; + CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALLBACK vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallbackFunctionPointer; + int vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallInstance; + char vkCmdTraceRaysIndirectKHR_IgnoreBool; + char vkCmdTraceRaysIndirectKHR_CallbackBool; + CMOCK_vkCmdTraceRaysIndirectKHR_CALLBACK vkCmdTraceRaysIndirectKHR_CallbackFunctionPointer; + int vkCmdTraceRaysIndirectKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdTraceRaysIndirectKHR_CallInstance; + char vkGetRayTracingShaderGroupStackSizeKHR_IgnoreBool; + VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR_FinalReturn; + char vkGetRayTracingShaderGroupStackSizeKHR_CallbackBool; + CMOCK_vkGetRayTracingShaderGroupStackSizeKHR_CALLBACK vkGetRayTracingShaderGroupStackSizeKHR_CallbackFunctionPointer; + int vkGetRayTracingShaderGroupStackSizeKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkGetRayTracingShaderGroupStackSizeKHR_CallInstance; + char vkCmdSetRayTracingPipelineStackSizeKHR_IgnoreBool; + char vkCmdSetRayTracingPipelineStackSizeKHR_CallbackBool; + CMOCK_vkCmdSetRayTracingPipelineStackSizeKHR_CALLBACK vkCmdSetRayTracingPipelineStackSizeKHR_CallbackFunctionPointer; + int vkCmdSetRayTracingPipelineStackSizeKHR_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdSetRayTracingPipelineStackSizeKHR_CallInstance; + char vkCmdDrawMeshTasksEXT_IgnoreBool; + char vkCmdDrawMeshTasksEXT_CallbackBool; + CMOCK_vkCmdDrawMeshTasksEXT_CALLBACK vkCmdDrawMeshTasksEXT_CallbackFunctionPointer; + int vkCmdDrawMeshTasksEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDrawMeshTasksEXT_CallInstance; + char vkCmdDrawMeshTasksIndirectEXT_IgnoreBool; + char vkCmdDrawMeshTasksIndirectEXT_CallbackBool; + CMOCK_vkCmdDrawMeshTasksIndirectEXT_CALLBACK vkCmdDrawMeshTasksIndirectEXT_CallbackFunctionPointer; + int vkCmdDrawMeshTasksIndirectEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDrawMeshTasksIndirectEXT_CallInstance; + char vkCmdDrawMeshTasksIndirectCountEXT_IgnoreBool; + char vkCmdDrawMeshTasksIndirectCountEXT_CallbackBool; + CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALLBACK vkCmdDrawMeshTasksIndirectCountEXT_CallbackFunctionPointer; + int vkCmdDrawMeshTasksIndirectCountEXT_CallbackCalls; + CMOCK_MEM_INDEX_TYPE vkCmdDrawMeshTasksIndirectCountEXT_CallInstance; +} Mock; + +extern jmp_buf AbortFrame; + +void Mockvulkan_core_Verify(void) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_MEM_INDEX_TYPE call_instance; + call_instance = Mock.vkCreateInstance_CallInstance; + if (Mock.vkCreateInstance_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateInstance); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateInstance_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyInstance_CallInstance; + if (Mock.vkDestroyInstance_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyInstance); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyInstance_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkEnumeratePhysicalDevices_CallInstance; + if (Mock.vkEnumeratePhysicalDevices_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkEnumeratePhysicalDevices); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkEnumeratePhysicalDevices_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceFeatures_CallInstance; + if (Mock.vkGetPhysicalDeviceFeatures_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceFeatures); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceFeatures_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceFormatProperties_CallInstance; + if (Mock.vkGetPhysicalDeviceFormatProperties_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceFormatProperties); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceFormatProperties_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceImageFormatProperties_CallInstance; + if (Mock.vkGetPhysicalDeviceImageFormatProperties_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceImageFormatProperties); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceImageFormatProperties_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceProperties_CallInstance; + if (Mock.vkGetPhysicalDeviceProperties_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceProperties); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceProperties_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceQueueFamilyProperties_CallInstance; + if (Mock.vkGetPhysicalDeviceQueueFamilyProperties_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceQueueFamilyProperties); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceQueueFamilyProperties_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceMemoryProperties_CallInstance; + if (Mock.vkGetPhysicalDeviceMemoryProperties_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceMemoryProperties); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceMemoryProperties_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetInstanceProcAddr_CallInstance; + if (Mock.vkGetInstanceProcAddr_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetInstanceProcAddr); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetInstanceProcAddr_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDeviceProcAddr_CallInstance; + if (Mock.vkGetDeviceProcAddr_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDeviceProcAddr); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDeviceProcAddr_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateDevice_CallInstance; + if (Mock.vkCreateDevice_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateDevice); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateDevice_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyDevice_CallInstance; + if (Mock.vkDestroyDevice_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyDevice); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyDevice_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkEnumerateInstanceExtensionProperties_CallInstance; + if (Mock.vkEnumerateInstanceExtensionProperties_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkEnumerateInstanceExtensionProperties); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkEnumerateInstanceExtensionProperties_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkEnumerateDeviceExtensionProperties_CallInstance; + if (Mock.vkEnumerateDeviceExtensionProperties_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkEnumerateDeviceExtensionProperties); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkEnumerateDeviceExtensionProperties_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkEnumerateInstanceLayerProperties_CallInstance; + if (Mock.vkEnumerateInstanceLayerProperties_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkEnumerateInstanceLayerProperties); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkEnumerateInstanceLayerProperties_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkEnumerateDeviceLayerProperties_CallInstance; + if (Mock.vkEnumerateDeviceLayerProperties_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkEnumerateDeviceLayerProperties); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkEnumerateDeviceLayerProperties_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDeviceQueue_CallInstance; + if (Mock.vkGetDeviceQueue_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDeviceQueue); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDeviceQueue_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkQueueSubmit_CallInstance; + if (Mock.vkQueueSubmit_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkQueueSubmit); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkQueueSubmit_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkQueueWaitIdle_CallInstance; + if (Mock.vkQueueWaitIdle_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkQueueWaitIdle); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkQueueWaitIdle_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDeviceWaitIdle_CallInstance; + if (Mock.vkDeviceWaitIdle_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDeviceWaitIdle); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDeviceWaitIdle_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkAllocateMemory_CallInstance; + if (Mock.vkAllocateMemory_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkAllocateMemory); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkAllocateMemory_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkFreeMemory_CallInstance; + if (Mock.vkFreeMemory_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkFreeMemory); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkFreeMemory_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkMapMemory_CallInstance; + if (Mock.vkMapMemory_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkMapMemory); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkMapMemory_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkUnmapMemory_CallInstance; + if (Mock.vkUnmapMemory_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkUnmapMemory); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkUnmapMemory_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkFlushMappedMemoryRanges_CallInstance; + if (Mock.vkFlushMappedMemoryRanges_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkFlushMappedMemoryRanges); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkFlushMappedMemoryRanges_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkInvalidateMappedMemoryRanges_CallInstance; + if (Mock.vkInvalidateMappedMemoryRanges_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkInvalidateMappedMemoryRanges); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkInvalidateMappedMemoryRanges_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDeviceMemoryCommitment_CallInstance; + if (Mock.vkGetDeviceMemoryCommitment_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDeviceMemoryCommitment); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDeviceMemoryCommitment_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkBindBufferMemory_CallInstance; + if (Mock.vkBindBufferMemory_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkBindBufferMemory); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkBindBufferMemory_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkBindImageMemory_CallInstance; + if (Mock.vkBindImageMemory_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkBindImageMemory); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkBindImageMemory_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetBufferMemoryRequirements_CallInstance; + if (Mock.vkGetBufferMemoryRequirements_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetBufferMemoryRequirements); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetBufferMemoryRequirements_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetImageMemoryRequirements_CallInstance; + if (Mock.vkGetImageMemoryRequirements_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetImageMemoryRequirements); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetImageMemoryRequirements_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetImageSparseMemoryRequirements_CallInstance; + if (Mock.vkGetImageSparseMemoryRequirements_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetImageSparseMemoryRequirements); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetImageSparseMemoryRequirements_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceSparseImageFormatProperties_CallInstance; + if (Mock.vkGetPhysicalDeviceSparseImageFormatProperties_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceSparseImageFormatProperties); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceSparseImageFormatProperties_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkQueueBindSparse_CallInstance; + if (Mock.vkQueueBindSparse_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkQueueBindSparse); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkQueueBindSparse_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateFence_CallInstance; + if (Mock.vkCreateFence_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateFence); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateFence_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyFence_CallInstance; + if (Mock.vkDestroyFence_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyFence); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyFence_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkResetFences_CallInstance; + if (Mock.vkResetFences_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkResetFences); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkResetFences_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetFenceStatus_CallInstance; + if (Mock.vkGetFenceStatus_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetFenceStatus); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetFenceStatus_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkWaitForFences_CallInstance; + if (Mock.vkWaitForFences_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkWaitForFences); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkWaitForFences_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateSemaphore_CallInstance; + if (Mock.vkCreateSemaphore_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateSemaphore); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateSemaphore_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroySemaphore_CallInstance; + if (Mock.vkDestroySemaphore_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroySemaphore); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroySemaphore_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateEvent_CallInstance; + if (Mock.vkCreateEvent_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateEvent); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateEvent_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyEvent_CallInstance; + if (Mock.vkDestroyEvent_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyEvent); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyEvent_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetEventStatus_CallInstance; + if (Mock.vkGetEventStatus_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetEventStatus); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetEventStatus_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkSetEvent_CallInstance; + if (Mock.vkSetEvent_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkSetEvent); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkSetEvent_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkResetEvent_CallInstance; + if (Mock.vkResetEvent_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkResetEvent); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkResetEvent_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateQueryPool_CallInstance; + if (Mock.vkCreateQueryPool_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateQueryPool); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateQueryPool_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyQueryPool_CallInstance; + if (Mock.vkDestroyQueryPool_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyQueryPool); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyQueryPool_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetQueryPoolResults_CallInstance; + if (Mock.vkGetQueryPoolResults_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetQueryPoolResults); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetQueryPoolResults_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateBuffer_CallInstance; + if (Mock.vkCreateBuffer_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateBuffer); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateBuffer_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyBuffer_CallInstance; + if (Mock.vkDestroyBuffer_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyBuffer); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyBuffer_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateBufferView_CallInstance; + if (Mock.vkCreateBufferView_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateBufferView); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateBufferView_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyBufferView_CallInstance; + if (Mock.vkDestroyBufferView_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyBufferView); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyBufferView_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateImage_CallInstance; + if (Mock.vkCreateImage_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateImage); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateImage_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyImage_CallInstance; + if (Mock.vkDestroyImage_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyImage); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyImage_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetImageSubresourceLayout_CallInstance; + if (Mock.vkGetImageSubresourceLayout_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetImageSubresourceLayout); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetImageSubresourceLayout_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateImageView_CallInstance; + if (Mock.vkCreateImageView_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateImageView); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateImageView_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyImageView_CallInstance; + if (Mock.vkDestroyImageView_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyImageView); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyImageView_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateShaderModule_CallInstance; + if (Mock.vkCreateShaderModule_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateShaderModule); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateShaderModule_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyShaderModule_CallInstance; + if (Mock.vkDestroyShaderModule_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyShaderModule); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyShaderModule_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreatePipelineCache_CallInstance; + if (Mock.vkCreatePipelineCache_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreatePipelineCache); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreatePipelineCache_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyPipelineCache_CallInstance; + if (Mock.vkDestroyPipelineCache_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyPipelineCache); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyPipelineCache_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPipelineCacheData_CallInstance; + if (Mock.vkGetPipelineCacheData_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPipelineCacheData); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPipelineCacheData_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkMergePipelineCaches_CallInstance; + if (Mock.vkMergePipelineCaches_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkMergePipelineCaches); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkMergePipelineCaches_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateGraphicsPipelines_CallInstance; + if (Mock.vkCreateGraphicsPipelines_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateGraphicsPipelines); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateGraphicsPipelines_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateComputePipelines_CallInstance; + if (Mock.vkCreateComputePipelines_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateComputePipelines); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateComputePipelines_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyPipeline_CallInstance; + if (Mock.vkDestroyPipeline_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyPipeline); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyPipeline_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreatePipelineLayout_CallInstance; + if (Mock.vkCreatePipelineLayout_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreatePipelineLayout); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreatePipelineLayout_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyPipelineLayout_CallInstance; + if (Mock.vkDestroyPipelineLayout_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyPipelineLayout); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyPipelineLayout_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateSampler_CallInstance; + if (Mock.vkCreateSampler_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateSampler); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateSampler_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroySampler_CallInstance; + if (Mock.vkDestroySampler_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroySampler); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroySampler_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateDescriptorSetLayout_CallInstance; + if (Mock.vkCreateDescriptorSetLayout_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateDescriptorSetLayout); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateDescriptorSetLayout_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyDescriptorSetLayout_CallInstance; + if (Mock.vkDestroyDescriptorSetLayout_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyDescriptorSetLayout); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyDescriptorSetLayout_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateDescriptorPool_CallInstance; + if (Mock.vkCreateDescriptorPool_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateDescriptorPool); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateDescriptorPool_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyDescriptorPool_CallInstance; + if (Mock.vkDestroyDescriptorPool_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyDescriptorPool); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyDescriptorPool_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkResetDescriptorPool_CallInstance; + if (Mock.vkResetDescriptorPool_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkResetDescriptorPool); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkResetDescriptorPool_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkAllocateDescriptorSets_CallInstance; + if (Mock.vkAllocateDescriptorSets_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkAllocateDescriptorSets); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkAllocateDescriptorSets_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkFreeDescriptorSets_CallInstance; + if (Mock.vkFreeDescriptorSets_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkFreeDescriptorSets); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkFreeDescriptorSets_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkUpdateDescriptorSets_CallInstance; + if (Mock.vkUpdateDescriptorSets_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkUpdateDescriptorSets); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkUpdateDescriptorSets_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateFramebuffer_CallInstance; + if (Mock.vkCreateFramebuffer_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateFramebuffer); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateFramebuffer_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyFramebuffer_CallInstance; + if (Mock.vkDestroyFramebuffer_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyFramebuffer); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyFramebuffer_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateRenderPass_CallInstance; + if (Mock.vkCreateRenderPass_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateRenderPass); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateRenderPass_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyRenderPass_CallInstance; + if (Mock.vkDestroyRenderPass_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyRenderPass); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyRenderPass_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetRenderAreaGranularity_CallInstance; + if (Mock.vkGetRenderAreaGranularity_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetRenderAreaGranularity); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetRenderAreaGranularity_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateCommandPool_CallInstance; + if (Mock.vkCreateCommandPool_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateCommandPool); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateCommandPool_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyCommandPool_CallInstance; + if (Mock.vkDestroyCommandPool_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyCommandPool); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyCommandPool_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkResetCommandPool_CallInstance; + if (Mock.vkResetCommandPool_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkResetCommandPool); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkResetCommandPool_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkAllocateCommandBuffers_CallInstance; + if (Mock.vkAllocateCommandBuffers_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkAllocateCommandBuffers); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkAllocateCommandBuffers_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkFreeCommandBuffers_CallInstance; + if (Mock.vkFreeCommandBuffers_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkFreeCommandBuffers); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkFreeCommandBuffers_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkBeginCommandBuffer_CallInstance; + if (Mock.vkBeginCommandBuffer_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkBeginCommandBuffer); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkBeginCommandBuffer_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkEndCommandBuffer_CallInstance; + if (Mock.vkEndCommandBuffer_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkEndCommandBuffer); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkEndCommandBuffer_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkResetCommandBuffer_CallInstance; + if (Mock.vkResetCommandBuffer_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkResetCommandBuffer); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkResetCommandBuffer_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBindPipeline_CallInstance; + if (Mock.vkCmdBindPipeline_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBindPipeline); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBindPipeline_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetViewport_CallInstance; + if (Mock.vkCmdSetViewport_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetViewport); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetViewport_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetScissor_CallInstance; + if (Mock.vkCmdSetScissor_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetScissor); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetScissor_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetLineWidth_CallInstance; + if (Mock.vkCmdSetLineWidth_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetLineWidth); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetLineWidth_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetDepthBias_CallInstance; + if (Mock.vkCmdSetDepthBias_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetDepthBias); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetDepthBias_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetBlendConstants_CallInstance; + if (Mock.vkCmdSetBlendConstants_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetBlendConstants); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetBlendConstants_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetDepthBounds_CallInstance; + if (Mock.vkCmdSetDepthBounds_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetDepthBounds); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetDepthBounds_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetStencilCompareMask_CallInstance; + if (Mock.vkCmdSetStencilCompareMask_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetStencilCompareMask); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetStencilCompareMask_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetStencilWriteMask_CallInstance; + if (Mock.vkCmdSetStencilWriteMask_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetStencilWriteMask); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetStencilWriteMask_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetStencilReference_CallInstance; + if (Mock.vkCmdSetStencilReference_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetStencilReference); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetStencilReference_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBindDescriptorSets_CallInstance; + if (Mock.vkCmdBindDescriptorSets_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBindDescriptorSets); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBindDescriptorSets_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBindIndexBuffer_CallInstance; + if (Mock.vkCmdBindIndexBuffer_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBindIndexBuffer); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBindIndexBuffer_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBindVertexBuffers_CallInstance; + if (Mock.vkCmdBindVertexBuffers_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBindVertexBuffers); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBindVertexBuffers_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDraw_CallInstance; + if (Mock.vkCmdDraw_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDraw); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDraw_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDrawIndexed_CallInstance; + if (Mock.vkCmdDrawIndexed_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDrawIndexed); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDrawIndexed_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDrawIndirect_CallInstance; + if (Mock.vkCmdDrawIndirect_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDrawIndirect); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDrawIndirect_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDrawIndexedIndirect_CallInstance; + if (Mock.vkCmdDrawIndexedIndirect_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDrawIndexedIndirect); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDrawIndexedIndirect_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDispatch_CallInstance; + if (Mock.vkCmdDispatch_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDispatch); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDispatch_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDispatchIndirect_CallInstance; + if (Mock.vkCmdDispatchIndirect_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDispatchIndirect); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDispatchIndirect_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdCopyBuffer_CallInstance; + if (Mock.vkCmdCopyBuffer_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdCopyBuffer); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdCopyBuffer_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdCopyImage_CallInstance; + if (Mock.vkCmdCopyImage_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdCopyImage); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdCopyImage_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBlitImage_CallInstance; + if (Mock.vkCmdBlitImage_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBlitImage); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBlitImage_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdCopyBufferToImage_CallInstance; + if (Mock.vkCmdCopyBufferToImage_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdCopyBufferToImage); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdCopyBufferToImage_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdCopyImageToBuffer_CallInstance; + if (Mock.vkCmdCopyImageToBuffer_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdCopyImageToBuffer); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdCopyImageToBuffer_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdUpdateBuffer_CallInstance; + if (Mock.vkCmdUpdateBuffer_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdUpdateBuffer); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdUpdateBuffer_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdFillBuffer_CallInstance; + if (Mock.vkCmdFillBuffer_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdFillBuffer); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdFillBuffer_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdClearColorImage_CallInstance; + if (Mock.vkCmdClearColorImage_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdClearColorImage); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdClearColorImage_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdClearDepthStencilImage_CallInstance; + if (Mock.vkCmdClearDepthStencilImage_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdClearDepthStencilImage); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdClearDepthStencilImage_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdClearAttachments_CallInstance; + if (Mock.vkCmdClearAttachments_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdClearAttachments); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdClearAttachments_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdResolveImage_CallInstance; + if (Mock.vkCmdResolveImage_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdResolveImage); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdResolveImage_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetEvent_CallInstance; + if (Mock.vkCmdSetEvent_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetEvent); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetEvent_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdResetEvent_CallInstance; + if (Mock.vkCmdResetEvent_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdResetEvent); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdResetEvent_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdWaitEvents_CallInstance; + if (Mock.vkCmdWaitEvents_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdWaitEvents); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdWaitEvents_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdPipelineBarrier_CallInstance; + if (Mock.vkCmdPipelineBarrier_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdPipelineBarrier); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdPipelineBarrier_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBeginQuery_CallInstance; + if (Mock.vkCmdBeginQuery_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBeginQuery); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBeginQuery_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdEndQuery_CallInstance; + if (Mock.vkCmdEndQuery_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdEndQuery); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdEndQuery_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdResetQueryPool_CallInstance; + if (Mock.vkCmdResetQueryPool_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdResetQueryPool); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdResetQueryPool_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdWriteTimestamp_CallInstance; + if (Mock.vkCmdWriteTimestamp_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdWriteTimestamp); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdWriteTimestamp_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdCopyQueryPoolResults_CallInstance; + if (Mock.vkCmdCopyQueryPoolResults_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdCopyQueryPoolResults); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdCopyQueryPoolResults_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdPushConstants_CallInstance; + if (Mock.vkCmdPushConstants_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdPushConstants); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdPushConstants_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBeginRenderPass_CallInstance; + if (Mock.vkCmdBeginRenderPass_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBeginRenderPass); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBeginRenderPass_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdNextSubpass_CallInstance; + if (Mock.vkCmdNextSubpass_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdNextSubpass); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdNextSubpass_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdEndRenderPass_CallInstance; + if (Mock.vkCmdEndRenderPass_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdEndRenderPass); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdEndRenderPass_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdExecuteCommands_CallInstance; + if (Mock.vkCmdExecuteCommands_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdExecuteCommands); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdExecuteCommands_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkEnumerateInstanceVersion_CallInstance; + if (Mock.vkEnumerateInstanceVersion_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkEnumerateInstanceVersion); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkEnumerateInstanceVersion_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkBindBufferMemory2_CallInstance; + if (Mock.vkBindBufferMemory2_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkBindBufferMemory2); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkBindBufferMemory2_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkBindImageMemory2_CallInstance; + if (Mock.vkBindImageMemory2_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkBindImageMemory2); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkBindImageMemory2_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDeviceGroupPeerMemoryFeatures_CallInstance; + if (Mock.vkGetDeviceGroupPeerMemoryFeatures_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDeviceGroupPeerMemoryFeatures); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDeviceGroupPeerMemoryFeatures_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetDeviceMask_CallInstance; + if (Mock.vkCmdSetDeviceMask_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetDeviceMask); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetDeviceMask_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDispatchBase_CallInstance; + if (Mock.vkCmdDispatchBase_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDispatchBase); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDispatchBase_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkEnumeratePhysicalDeviceGroups_CallInstance; + if (Mock.vkEnumeratePhysicalDeviceGroups_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkEnumeratePhysicalDeviceGroups); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkEnumeratePhysicalDeviceGroups_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetImageMemoryRequirements2_CallInstance; + if (Mock.vkGetImageMemoryRequirements2_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetImageMemoryRequirements2); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetImageMemoryRequirements2_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetBufferMemoryRequirements2_CallInstance; + if (Mock.vkGetBufferMemoryRequirements2_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetBufferMemoryRequirements2); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetBufferMemoryRequirements2_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetImageSparseMemoryRequirements2_CallInstance; + if (Mock.vkGetImageSparseMemoryRequirements2_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetImageSparseMemoryRequirements2); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetImageSparseMemoryRequirements2_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceFeatures2_CallInstance; + if (Mock.vkGetPhysicalDeviceFeatures2_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceFeatures2); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceFeatures2_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceProperties2_CallInstance; + if (Mock.vkGetPhysicalDeviceProperties2_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceProperties2); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceProperties2_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceFormatProperties2_CallInstance; + if (Mock.vkGetPhysicalDeviceFormatProperties2_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceFormatProperties2); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceFormatProperties2_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceImageFormatProperties2_CallInstance; + if (Mock.vkGetPhysicalDeviceImageFormatProperties2_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceImageFormatProperties2); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceImageFormatProperties2_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceQueueFamilyProperties2_CallInstance; + if (Mock.vkGetPhysicalDeviceQueueFamilyProperties2_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceQueueFamilyProperties2); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceQueueFamilyProperties2_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceMemoryProperties2_CallInstance; + if (Mock.vkGetPhysicalDeviceMemoryProperties2_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceMemoryProperties2); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceMemoryProperties2_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_CallInstance; + if (Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceSparseImageFormatProperties2); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkTrimCommandPool_CallInstance; + if (Mock.vkTrimCommandPool_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkTrimCommandPool); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkTrimCommandPool_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDeviceQueue2_CallInstance; + if (Mock.vkGetDeviceQueue2_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDeviceQueue2); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDeviceQueue2_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateSamplerYcbcrConversion_CallInstance; + if (Mock.vkCreateSamplerYcbcrConversion_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateSamplerYcbcrConversion); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateSamplerYcbcrConversion_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroySamplerYcbcrConversion_CallInstance; + if (Mock.vkDestroySamplerYcbcrConversion_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroySamplerYcbcrConversion); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroySamplerYcbcrConversion_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateDescriptorUpdateTemplate_CallInstance; + if (Mock.vkCreateDescriptorUpdateTemplate_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateDescriptorUpdateTemplate); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateDescriptorUpdateTemplate_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyDescriptorUpdateTemplate_CallInstance; + if (Mock.vkDestroyDescriptorUpdateTemplate_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyDescriptorUpdateTemplate); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyDescriptorUpdateTemplate_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkUpdateDescriptorSetWithTemplate_CallInstance; + if (Mock.vkUpdateDescriptorSetWithTemplate_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkUpdateDescriptorSetWithTemplate); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkUpdateDescriptorSetWithTemplate_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceExternalBufferProperties_CallInstance; + if (Mock.vkGetPhysicalDeviceExternalBufferProperties_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceExternalBufferProperties); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceExternalBufferProperties_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceExternalFenceProperties_CallInstance; + if (Mock.vkGetPhysicalDeviceExternalFenceProperties_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceExternalFenceProperties); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceExternalFenceProperties_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_CallInstance; + if (Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceExternalSemaphoreProperties); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDescriptorSetLayoutSupport_CallInstance; + if (Mock.vkGetDescriptorSetLayoutSupport_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDescriptorSetLayoutSupport); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDescriptorSetLayoutSupport_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDrawIndirectCount_CallInstance; + if (Mock.vkCmdDrawIndirectCount_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDrawIndirectCount); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDrawIndirectCount_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDrawIndexedIndirectCount_CallInstance; + if (Mock.vkCmdDrawIndexedIndirectCount_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDrawIndexedIndirectCount); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDrawIndexedIndirectCount_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateRenderPass2_CallInstance; + if (Mock.vkCreateRenderPass2_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateRenderPass2); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateRenderPass2_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBeginRenderPass2_CallInstance; + if (Mock.vkCmdBeginRenderPass2_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBeginRenderPass2); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBeginRenderPass2_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdNextSubpass2_CallInstance; + if (Mock.vkCmdNextSubpass2_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdNextSubpass2); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdNextSubpass2_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdEndRenderPass2_CallInstance; + if (Mock.vkCmdEndRenderPass2_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdEndRenderPass2); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdEndRenderPass2_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkResetQueryPool_CallInstance; + if (Mock.vkResetQueryPool_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkResetQueryPool); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkResetQueryPool_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetSemaphoreCounterValue_CallInstance; + if (Mock.vkGetSemaphoreCounterValue_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetSemaphoreCounterValue); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetSemaphoreCounterValue_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkWaitSemaphores_CallInstance; + if (Mock.vkWaitSemaphores_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkWaitSemaphores); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkWaitSemaphores_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkSignalSemaphore_CallInstance; + if (Mock.vkSignalSemaphore_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkSignalSemaphore); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkSignalSemaphore_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetBufferDeviceAddress_CallInstance; + if (Mock.vkGetBufferDeviceAddress_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetBufferDeviceAddress); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetBufferDeviceAddress_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetBufferOpaqueCaptureAddress_CallInstance; + if (Mock.vkGetBufferOpaqueCaptureAddress_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetBufferOpaqueCaptureAddress); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetBufferOpaqueCaptureAddress_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDeviceMemoryOpaqueCaptureAddress_CallInstance; + if (Mock.vkGetDeviceMemoryOpaqueCaptureAddress_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDeviceMemoryOpaqueCaptureAddress); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDeviceMemoryOpaqueCaptureAddress_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceToolProperties_CallInstance; + if (Mock.vkGetPhysicalDeviceToolProperties_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceToolProperties); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceToolProperties_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreatePrivateDataSlot_CallInstance; + if (Mock.vkCreatePrivateDataSlot_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreatePrivateDataSlot); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreatePrivateDataSlot_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyPrivateDataSlot_CallInstance; + if (Mock.vkDestroyPrivateDataSlot_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyPrivateDataSlot); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyPrivateDataSlot_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkSetPrivateData_CallInstance; + if (Mock.vkSetPrivateData_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkSetPrivateData); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkSetPrivateData_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPrivateData_CallInstance; + if (Mock.vkGetPrivateData_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPrivateData); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPrivateData_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetEvent2_CallInstance; + if (Mock.vkCmdSetEvent2_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetEvent2); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetEvent2_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdResetEvent2_CallInstance; + if (Mock.vkCmdResetEvent2_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdResetEvent2); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdResetEvent2_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdWaitEvents2_CallInstance; + if (Mock.vkCmdWaitEvents2_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdWaitEvents2); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdWaitEvents2_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdPipelineBarrier2_CallInstance; + if (Mock.vkCmdPipelineBarrier2_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdPipelineBarrier2); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdPipelineBarrier2_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdWriteTimestamp2_CallInstance; + if (Mock.vkCmdWriteTimestamp2_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdWriteTimestamp2); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdWriteTimestamp2_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkQueueSubmit2_CallInstance; + if (Mock.vkQueueSubmit2_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkQueueSubmit2); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkQueueSubmit2_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdCopyBuffer2_CallInstance; + if (Mock.vkCmdCopyBuffer2_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdCopyBuffer2); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdCopyBuffer2_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdCopyImage2_CallInstance; + if (Mock.vkCmdCopyImage2_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdCopyImage2); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdCopyImage2_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdCopyBufferToImage2_CallInstance; + if (Mock.vkCmdCopyBufferToImage2_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdCopyBufferToImage2); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdCopyBufferToImage2_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdCopyImageToBuffer2_CallInstance; + if (Mock.vkCmdCopyImageToBuffer2_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdCopyImageToBuffer2); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdCopyImageToBuffer2_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBlitImage2_CallInstance; + if (Mock.vkCmdBlitImage2_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBlitImage2); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBlitImage2_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdResolveImage2_CallInstance; + if (Mock.vkCmdResolveImage2_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdResolveImage2); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdResolveImage2_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBeginRendering_CallInstance; + if (Mock.vkCmdBeginRendering_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBeginRendering); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBeginRendering_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdEndRendering_CallInstance; + if (Mock.vkCmdEndRendering_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdEndRendering); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdEndRendering_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetCullMode_CallInstance; + if (Mock.vkCmdSetCullMode_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetCullMode); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetCullMode_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetFrontFace_CallInstance; + if (Mock.vkCmdSetFrontFace_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetFrontFace); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetFrontFace_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetPrimitiveTopology_CallInstance; + if (Mock.vkCmdSetPrimitiveTopology_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetPrimitiveTopology); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetPrimitiveTopology_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetViewportWithCount_CallInstance; + if (Mock.vkCmdSetViewportWithCount_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetViewportWithCount); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetViewportWithCount_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetScissorWithCount_CallInstance; + if (Mock.vkCmdSetScissorWithCount_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetScissorWithCount); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetScissorWithCount_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBindVertexBuffers2_CallInstance; + if (Mock.vkCmdBindVertexBuffers2_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBindVertexBuffers2); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBindVertexBuffers2_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetDepthTestEnable_CallInstance; + if (Mock.vkCmdSetDepthTestEnable_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetDepthTestEnable); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetDepthTestEnable_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetDepthWriteEnable_CallInstance; + if (Mock.vkCmdSetDepthWriteEnable_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetDepthWriteEnable); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetDepthWriteEnable_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetDepthCompareOp_CallInstance; + if (Mock.vkCmdSetDepthCompareOp_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetDepthCompareOp); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetDepthCompareOp_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetDepthBoundsTestEnable_CallInstance; + if (Mock.vkCmdSetDepthBoundsTestEnable_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetDepthBoundsTestEnable); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetDepthBoundsTestEnable_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetStencilTestEnable_CallInstance; + if (Mock.vkCmdSetStencilTestEnable_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetStencilTestEnable); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetStencilTestEnable_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetStencilOp_CallInstance; + if (Mock.vkCmdSetStencilOp_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetStencilOp); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetStencilOp_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetRasterizerDiscardEnable_CallInstance; + if (Mock.vkCmdSetRasterizerDiscardEnable_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetRasterizerDiscardEnable); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetRasterizerDiscardEnable_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetDepthBiasEnable_CallInstance; + if (Mock.vkCmdSetDepthBiasEnable_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetDepthBiasEnable); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetDepthBiasEnable_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetPrimitiveRestartEnable_CallInstance; + if (Mock.vkCmdSetPrimitiveRestartEnable_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetPrimitiveRestartEnable); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetPrimitiveRestartEnable_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDeviceBufferMemoryRequirements_CallInstance; + if (Mock.vkGetDeviceBufferMemoryRequirements_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDeviceBufferMemoryRequirements); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDeviceBufferMemoryRequirements_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDeviceImageMemoryRequirements_CallInstance; + if (Mock.vkGetDeviceImageMemoryRequirements_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDeviceImageMemoryRequirements); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDeviceImageMemoryRequirements_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDeviceImageSparseMemoryRequirements_CallInstance; + if (Mock.vkGetDeviceImageSparseMemoryRequirements_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDeviceImageSparseMemoryRequirements); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDeviceImageSparseMemoryRequirements_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroySurfaceKHR_CallInstance; + if (Mock.vkDestroySurfaceKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroySurfaceKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroySurfaceKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceSurfaceSupportKHR_CallInstance; + if (Mock.vkGetPhysicalDeviceSurfaceSupportKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceSurfaceSupportKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceSurfaceSupportKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallInstance; + if (Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceSurfaceCapabilitiesKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_CallInstance; + if (Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceSurfaceFormatsKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_CallInstance; + if (Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceSurfacePresentModesKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateSwapchainKHR_CallInstance; + if (Mock.vkCreateSwapchainKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateSwapchainKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateSwapchainKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroySwapchainKHR_CallInstance; + if (Mock.vkDestroySwapchainKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroySwapchainKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroySwapchainKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetSwapchainImagesKHR_CallInstance; + if (Mock.vkGetSwapchainImagesKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetSwapchainImagesKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetSwapchainImagesKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkAcquireNextImageKHR_CallInstance; + if (Mock.vkAcquireNextImageKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkAcquireNextImageKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkAcquireNextImageKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkQueuePresentKHR_CallInstance; + if (Mock.vkQueuePresentKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkQueuePresentKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkQueuePresentKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDeviceGroupPresentCapabilitiesKHR_CallInstance; + if (Mock.vkGetDeviceGroupPresentCapabilitiesKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDeviceGroupPresentCapabilitiesKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDeviceGroupPresentCapabilitiesKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDeviceGroupSurfacePresentModesKHR_CallInstance; + if (Mock.vkGetDeviceGroupSurfacePresentModesKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDeviceGroupSurfacePresentModesKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDeviceGroupSurfacePresentModesKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDevicePresentRectanglesKHR_CallInstance; + if (Mock.vkGetPhysicalDevicePresentRectanglesKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDevicePresentRectanglesKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDevicePresentRectanglesKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkAcquireNextImage2KHR_CallInstance; + if (Mock.vkAcquireNextImage2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkAcquireNextImage2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkAcquireNextImage2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_CallInstance; + if (Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceDisplayPropertiesKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallInstance; + if (Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceDisplayPlanePropertiesKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDisplayPlaneSupportedDisplaysKHR_CallInstance; + if (Mock.vkGetDisplayPlaneSupportedDisplaysKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDisplayPlaneSupportedDisplaysKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDisplayPlaneSupportedDisplaysKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDisplayModePropertiesKHR_CallInstance; + if (Mock.vkGetDisplayModePropertiesKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDisplayModePropertiesKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDisplayModePropertiesKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateDisplayModeKHR_CallInstance; + if (Mock.vkCreateDisplayModeKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateDisplayModeKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateDisplayModeKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDisplayPlaneCapabilitiesKHR_CallInstance; + if (Mock.vkGetDisplayPlaneCapabilitiesKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDisplayPlaneCapabilitiesKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDisplayPlaneCapabilitiesKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateDisplayPlaneSurfaceKHR_CallInstance; + if (Mock.vkCreateDisplayPlaneSurfaceKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateDisplayPlaneSurfaceKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateDisplayPlaneSurfaceKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateSharedSwapchainsKHR_CallInstance; + if (Mock.vkCreateSharedSwapchainsKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateSharedSwapchainsKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateSharedSwapchainsKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_CallInstance; + if (Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceVideoCapabilitiesKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallInstance; + if (Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceVideoFormatPropertiesKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateVideoSessionKHR_CallInstance; + if (Mock.vkCreateVideoSessionKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateVideoSessionKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateVideoSessionKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyVideoSessionKHR_CallInstance; + if (Mock.vkDestroyVideoSessionKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyVideoSessionKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyVideoSessionKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetVideoSessionMemoryRequirementsKHR_CallInstance; + if (Mock.vkGetVideoSessionMemoryRequirementsKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetVideoSessionMemoryRequirementsKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetVideoSessionMemoryRequirementsKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkBindVideoSessionMemoryKHR_CallInstance; + if (Mock.vkBindVideoSessionMemoryKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkBindVideoSessionMemoryKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkBindVideoSessionMemoryKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateVideoSessionParametersKHR_CallInstance; + if (Mock.vkCreateVideoSessionParametersKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateVideoSessionParametersKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateVideoSessionParametersKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkUpdateVideoSessionParametersKHR_CallInstance; + if (Mock.vkUpdateVideoSessionParametersKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkUpdateVideoSessionParametersKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkUpdateVideoSessionParametersKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyVideoSessionParametersKHR_CallInstance; + if (Mock.vkDestroyVideoSessionParametersKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyVideoSessionParametersKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyVideoSessionParametersKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBeginVideoCodingKHR_CallInstance; + if (Mock.vkCmdBeginVideoCodingKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBeginVideoCodingKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBeginVideoCodingKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdEndVideoCodingKHR_CallInstance; + if (Mock.vkCmdEndVideoCodingKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdEndVideoCodingKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdEndVideoCodingKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdControlVideoCodingKHR_CallInstance; + if (Mock.vkCmdControlVideoCodingKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdControlVideoCodingKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdControlVideoCodingKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDecodeVideoKHR_CallInstance; + if (Mock.vkCmdDecodeVideoKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDecodeVideoKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDecodeVideoKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBeginRenderingKHR_CallInstance; + if (Mock.vkCmdBeginRenderingKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBeginRenderingKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBeginRenderingKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdEndRenderingKHR_CallInstance; + if (Mock.vkCmdEndRenderingKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdEndRenderingKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdEndRenderingKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceFeatures2KHR_CallInstance; + if (Mock.vkGetPhysicalDeviceFeatures2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceFeatures2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceFeatures2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceProperties2KHR_CallInstance; + if (Mock.vkGetPhysicalDeviceProperties2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceProperties2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceProperties2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceFormatProperties2KHR_CallInstance; + if (Mock.vkGetPhysicalDeviceFormatProperties2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceFormatProperties2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceFormatProperties2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_CallInstance; + if (Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceImageFormatProperties2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_CallInstance; + if (Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceQueueFamilyProperties2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceMemoryProperties2KHR_CallInstance; + if (Mock.vkGetPhysicalDeviceMemoryProperties2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceMemoryProperties2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceMemoryProperties2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CallInstance; + if (Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceSparseImageFormatProperties2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_CallInstance; + if (Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDeviceGroupPeerMemoryFeaturesKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetDeviceMaskKHR_CallInstance; + if (Mock.vkCmdSetDeviceMaskKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetDeviceMaskKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetDeviceMaskKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDispatchBaseKHR_CallInstance; + if (Mock.vkCmdDispatchBaseKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDispatchBaseKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDispatchBaseKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkTrimCommandPoolKHR_CallInstance; + if (Mock.vkTrimCommandPoolKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkTrimCommandPoolKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkTrimCommandPoolKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkEnumeratePhysicalDeviceGroupsKHR_CallInstance; + if (Mock.vkEnumeratePhysicalDeviceGroupsKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkEnumeratePhysicalDeviceGroupsKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkEnumeratePhysicalDeviceGroupsKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_CallInstance; + if (Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceExternalBufferPropertiesKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetMemoryFdKHR_CallInstance; + if (Mock.vkGetMemoryFdKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetMemoryFdKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetMemoryFdKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetMemoryFdPropertiesKHR_CallInstance; + if (Mock.vkGetMemoryFdPropertiesKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetMemoryFdPropertiesKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetMemoryFdPropertiesKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CallInstance; + if (Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkImportSemaphoreFdKHR_CallInstance; + if (Mock.vkImportSemaphoreFdKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkImportSemaphoreFdKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkImportSemaphoreFdKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetSemaphoreFdKHR_CallInstance; + if (Mock.vkGetSemaphoreFdKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetSemaphoreFdKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetSemaphoreFdKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdPushDescriptorSetKHR_CallInstance; + if (Mock.vkCmdPushDescriptorSetKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdPushDescriptorSetKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdPushDescriptorSetKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdPushDescriptorSetWithTemplateKHR_CallInstance; + if (Mock.vkCmdPushDescriptorSetWithTemplateKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdPushDescriptorSetWithTemplateKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdPushDescriptorSetWithTemplateKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateDescriptorUpdateTemplateKHR_CallInstance; + if (Mock.vkCreateDescriptorUpdateTemplateKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateDescriptorUpdateTemplateKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateDescriptorUpdateTemplateKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyDescriptorUpdateTemplateKHR_CallInstance; + if (Mock.vkDestroyDescriptorUpdateTemplateKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyDescriptorUpdateTemplateKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyDescriptorUpdateTemplateKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkUpdateDescriptorSetWithTemplateKHR_CallInstance; + if (Mock.vkUpdateDescriptorSetWithTemplateKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkUpdateDescriptorSetWithTemplateKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkUpdateDescriptorSetWithTemplateKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateRenderPass2KHR_CallInstance; + if (Mock.vkCreateRenderPass2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateRenderPass2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateRenderPass2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBeginRenderPass2KHR_CallInstance; + if (Mock.vkCmdBeginRenderPass2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBeginRenderPass2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBeginRenderPass2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdNextSubpass2KHR_CallInstance; + if (Mock.vkCmdNextSubpass2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdNextSubpass2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdNextSubpass2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdEndRenderPass2KHR_CallInstance; + if (Mock.vkCmdEndRenderPass2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdEndRenderPass2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdEndRenderPass2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetSwapchainStatusKHR_CallInstance; + if (Mock.vkGetSwapchainStatusKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetSwapchainStatusKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetSwapchainStatusKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_CallInstance; + if (Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceExternalFencePropertiesKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkImportFenceFdKHR_CallInstance; + if (Mock.vkImportFenceFdKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkImportFenceFdKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkImportFenceFdKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetFenceFdKHR_CallInstance; + if (Mock.vkGetFenceFdKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetFenceFdKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetFenceFdKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallInstance; + if (Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CallInstance; + if (Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkAcquireProfilingLockKHR_CallInstance; + if (Mock.vkAcquireProfilingLockKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkAcquireProfilingLockKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkAcquireProfilingLockKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkReleaseProfilingLockKHR_CallInstance; + if (Mock.vkReleaseProfilingLockKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkReleaseProfilingLockKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkReleaseProfilingLockKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallInstance; + if (Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceSurfaceCapabilities2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_CallInstance; + if (Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceSurfaceFormats2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceDisplayProperties2KHR_CallInstance; + if (Mock.vkGetPhysicalDeviceDisplayProperties2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceDisplayProperties2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceDisplayProperties2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallInstance; + if (Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceDisplayPlaneProperties2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDisplayModeProperties2KHR_CallInstance; + if (Mock.vkGetDisplayModeProperties2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDisplayModeProperties2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDisplayModeProperties2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDisplayPlaneCapabilities2KHR_CallInstance; + if (Mock.vkGetDisplayPlaneCapabilities2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDisplayPlaneCapabilities2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDisplayPlaneCapabilities2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetImageMemoryRequirements2KHR_CallInstance; + if (Mock.vkGetImageMemoryRequirements2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetImageMemoryRequirements2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetImageMemoryRequirements2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetBufferMemoryRequirements2KHR_CallInstance; + if (Mock.vkGetBufferMemoryRequirements2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetBufferMemoryRequirements2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetBufferMemoryRequirements2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetImageSparseMemoryRequirements2KHR_CallInstance; + if (Mock.vkGetImageSparseMemoryRequirements2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetImageSparseMemoryRequirements2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetImageSparseMemoryRequirements2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateSamplerYcbcrConversionKHR_CallInstance; + if (Mock.vkCreateSamplerYcbcrConversionKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateSamplerYcbcrConversionKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateSamplerYcbcrConversionKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroySamplerYcbcrConversionKHR_CallInstance; + if (Mock.vkDestroySamplerYcbcrConversionKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroySamplerYcbcrConversionKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroySamplerYcbcrConversionKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkBindBufferMemory2KHR_CallInstance; + if (Mock.vkBindBufferMemory2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkBindBufferMemory2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkBindBufferMemory2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkBindImageMemory2KHR_CallInstance; + if (Mock.vkBindImageMemory2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkBindImageMemory2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkBindImageMemory2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDescriptorSetLayoutSupportKHR_CallInstance; + if (Mock.vkGetDescriptorSetLayoutSupportKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDescriptorSetLayoutSupportKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDescriptorSetLayoutSupportKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDrawIndirectCountKHR_CallInstance; + if (Mock.vkCmdDrawIndirectCountKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDrawIndirectCountKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDrawIndirectCountKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDrawIndexedIndirectCountKHR_CallInstance; + if (Mock.vkCmdDrawIndexedIndirectCountKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDrawIndexedIndirectCountKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDrawIndexedIndirectCountKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetSemaphoreCounterValueKHR_CallInstance; + if (Mock.vkGetSemaphoreCounterValueKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetSemaphoreCounterValueKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetSemaphoreCounterValueKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkWaitSemaphoresKHR_CallInstance; + if (Mock.vkWaitSemaphoresKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkWaitSemaphoresKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkWaitSemaphoresKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkSignalSemaphoreKHR_CallInstance; + if (Mock.vkSignalSemaphoreKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkSignalSemaphoreKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkSignalSemaphoreKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_CallInstance; + if (Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceFragmentShadingRatesKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetFragmentShadingRateKHR_CallInstance; + if (Mock.vkCmdSetFragmentShadingRateKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetFragmentShadingRateKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetFragmentShadingRateKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkWaitForPresentKHR_CallInstance; + if (Mock.vkWaitForPresentKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkWaitForPresentKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkWaitForPresentKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetBufferDeviceAddressKHR_CallInstance; + if (Mock.vkGetBufferDeviceAddressKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetBufferDeviceAddressKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetBufferDeviceAddressKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetBufferOpaqueCaptureAddressKHR_CallInstance; + if (Mock.vkGetBufferOpaqueCaptureAddressKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetBufferOpaqueCaptureAddressKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetBufferOpaqueCaptureAddressKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_CallInstance; + if (Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDeviceMemoryOpaqueCaptureAddressKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateDeferredOperationKHR_CallInstance; + if (Mock.vkCreateDeferredOperationKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateDeferredOperationKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateDeferredOperationKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyDeferredOperationKHR_CallInstance; + if (Mock.vkDestroyDeferredOperationKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyDeferredOperationKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyDeferredOperationKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDeferredOperationMaxConcurrencyKHR_CallInstance; + if (Mock.vkGetDeferredOperationMaxConcurrencyKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDeferredOperationMaxConcurrencyKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDeferredOperationMaxConcurrencyKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDeferredOperationResultKHR_CallInstance; + if (Mock.vkGetDeferredOperationResultKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDeferredOperationResultKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDeferredOperationResultKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDeferredOperationJoinKHR_CallInstance; + if (Mock.vkDeferredOperationJoinKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDeferredOperationJoinKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDeferredOperationJoinKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPipelineExecutablePropertiesKHR_CallInstance; + if (Mock.vkGetPipelineExecutablePropertiesKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPipelineExecutablePropertiesKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPipelineExecutablePropertiesKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPipelineExecutableStatisticsKHR_CallInstance; + if (Mock.vkGetPipelineExecutableStatisticsKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPipelineExecutableStatisticsKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPipelineExecutableStatisticsKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPipelineExecutableInternalRepresentationsKHR_CallInstance; + if (Mock.vkGetPipelineExecutableInternalRepresentationsKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPipelineExecutableInternalRepresentationsKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPipelineExecutableInternalRepresentationsKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkMapMemory2KHR_CallInstance; + if (Mock.vkMapMemory2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkMapMemory2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkMapMemory2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkUnmapMemory2KHR_CallInstance; + if (Mock.vkUnmapMemory2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkUnmapMemory2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkUnmapMemory2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetEvent2KHR_CallInstance; + if (Mock.vkCmdSetEvent2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetEvent2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetEvent2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdResetEvent2KHR_CallInstance; + if (Mock.vkCmdResetEvent2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdResetEvent2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdResetEvent2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdWaitEvents2KHR_CallInstance; + if (Mock.vkCmdWaitEvents2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdWaitEvents2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdWaitEvents2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdPipelineBarrier2KHR_CallInstance; + if (Mock.vkCmdPipelineBarrier2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdPipelineBarrier2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdPipelineBarrier2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdWriteTimestamp2KHR_CallInstance; + if (Mock.vkCmdWriteTimestamp2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdWriteTimestamp2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdWriteTimestamp2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkQueueSubmit2KHR_CallInstance; + if (Mock.vkQueueSubmit2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkQueueSubmit2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkQueueSubmit2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdWriteBufferMarker2AMD_CallInstance; + if (Mock.vkCmdWriteBufferMarker2AMD_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdWriteBufferMarker2AMD); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdWriteBufferMarker2AMD_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetQueueCheckpointData2NV_CallInstance; + if (Mock.vkGetQueueCheckpointData2NV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetQueueCheckpointData2NV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetQueueCheckpointData2NV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdCopyBuffer2KHR_CallInstance; + if (Mock.vkCmdCopyBuffer2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdCopyBuffer2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdCopyBuffer2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdCopyImage2KHR_CallInstance; + if (Mock.vkCmdCopyImage2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdCopyImage2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdCopyImage2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdCopyBufferToImage2KHR_CallInstance; + if (Mock.vkCmdCopyBufferToImage2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdCopyBufferToImage2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdCopyBufferToImage2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdCopyImageToBuffer2KHR_CallInstance; + if (Mock.vkCmdCopyImageToBuffer2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdCopyImageToBuffer2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdCopyImageToBuffer2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBlitImage2KHR_CallInstance; + if (Mock.vkCmdBlitImage2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBlitImage2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBlitImage2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdResolveImage2KHR_CallInstance; + if (Mock.vkCmdResolveImage2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdResolveImage2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdResolveImage2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdTraceRaysIndirect2KHR_CallInstance; + if (Mock.vkCmdTraceRaysIndirect2KHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdTraceRaysIndirect2KHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdTraceRaysIndirect2KHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDeviceBufferMemoryRequirementsKHR_CallInstance; + if (Mock.vkGetDeviceBufferMemoryRequirementsKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDeviceBufferMemoryRequirementsKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDeviceBufferMemoryRequirementsKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDeviceImageMemoryRequirementsKHR_CallInstance; + if (Mock.vkGetDeviceImageMemoryRequirementsKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDeviceImageMemoryRequirementsKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDeviceImageMemoryRequirementsKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_CallInstance; + if (Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDeviceImageSparseMemoryRequirementsKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateDebugReportCallbackEXT_CallInstance; + if (Mock.vkCreateDebugReportCallbackEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateDebugReportCallbackEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateDebugReportCallbackEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyDebugReportCallbackEXT_CallInstance; + if (Mock.vkDestroyDebugReportCallbackEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyDebugReportCallbackEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyDebugReportCallbackEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDebugReportMessageEXT_CallInstance; + if (Mock.vkDebugReportMessageEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDebugReportMessageEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDebugReportMessageEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDebugMarkerSetObjectTagEXT_CallInstance; + if (Mock.vkDebugMarkerSetObjectTagEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDebugMarkerSetObjectTagEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDebugMarkerSetObjectTagEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDebugMarkerSetObjectNameEXT_CallInstance; + if (Mock.vkDebugMarkerSetObjectNameEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDebugMarkerSetObjectNameEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDebugMarkerSetObjectNameEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDebugMarkerBeginEXT_CallInstance; + if (Mock.vkCmdDebugMarkerBeginEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDebugMarkerBeginEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDebugMarkerBeginEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDebugMarkerEndEXT_CallInstance; + if (Mock.vkCmdDebugMarkerEndEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDebugMarkerEndEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDebugMarkerEndEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDebugMarkerInsertEXT_CallInstance; + if (Mock.vkCmdDebugMarkerInsertEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDebugMarkerInsertEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDebugMarkerInsertEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBindTransformFeedbackBuffersEXT_CallInstance; + if (Mock.vkCmdBindTransformFeedbackBuffersEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBindTransformFeedbackBuffersEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBindTransformFeedbackBuffersEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBeginTransformFeedbackEXT_CallInstance; + if (Mock.vkCmdBeginTransformFeedbackEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBeginTransformFeedbackEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBeginTransformFeedbackEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdEndTransformFeedbackEXT_CallInstance; + if (Mock.vkCmdEndTransformFeedbackEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdEndTransformFeedbackEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdEndTransformFeedbackEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBeginQueryIndexedEXT_CallInstance; + if (Mock.vkCmdBeginQueryIndexedEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBeginQueryIndexedEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBeginQueryIndexedEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdEndQueryIndexedEXT_CallInstance; + if (Mock.vkCmdEndQueryIndexedEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdEndQueryIndexedEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdEndQueryIndexedEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDrawIndirectByteCountEXT_CallInstance; + if (Mock.vkCmdDrawIndirectByteCountEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDrawIndirectByteCountEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDrawIndirectByteCountEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateCuModuleNVX_CallInstance; + if (Mock.vkCreateCuModuleNVX_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateCuModuleNVX); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateCuModuleNVX_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateCuFunctionNVX_CallInstance; + if (Mock.vkCreateCuFunctionNVX_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateCuFunctionNVX); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateCuFunctionNVX_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyCuModuleNVX_CallInstance; + if (Mock.vkDestroyCuModuleNVX_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyCuModuleNVX); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyCuModuleNVX_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyCuFunctionNVX_CallInstance; + if (Mock.vkDestroyCuFunctionNVX_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyCuFunctionNVX); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyCuFunctionNVX_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdCuLaunchKernelNVX_CallInstance; + if (Mock.vkCmdCuLaunchKernelNVX_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdCuLaunchKernelNVX); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdCuLaunchKernelNVX_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetImageViewHandleNVX_CallInstance; + if (Mock.vkGetImageViewHandleNVX_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetImageViewHandleNVX); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetImageViewHandleNVX_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetImageViewAddressNVX_CallInstance; + if (Mock.vkGetImageViewAddressNVX_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetImageViewAddressNVX); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetImageViewAddressNVX_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDrawIndirectCountAMD_CallInstance; + if (Mock.vkCmdDrawIndirectCountAMD_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDrawIndirectCountAMD); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDrawIndirectCountAMD_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDrawIndexedIndirectCountAMD_CallInstance; + if (Mock.vkCmdDrawIndexedIndirectCountAMD_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDrawIndexedIndirectCountAMD); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDrawIndexedIndirectCountAMD_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetShaderInfoAMD_CallInstance; + if (Mock.vkGetShaderInfoAMD_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetShaderInfoAMD); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetShaderInfoAMD_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallInstance; + if (Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceExternalImageFormatPropertiesNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBeginConditionalRenderingEXT_CallInstance; + if (Mock.vkCmdBeginConditionalRenderingEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBeginConditionalRenderingEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBeginConditionalRenderingEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdEndConditionalRenderingEXT_CallInstance; + if (Mock.vkCmdEndConditionalRenderingEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdEndConditionalRenderingEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdEndConditionalRenderingEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetViewportWScalingNV_CallInstance; + if (Mock.vkCmdSetViewportWScalingNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetViewportWScalingNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetViewportWScalingNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkReleaseDisplayEXT_CallInstance; + if (Mock.vkReleaseDisplayEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkReleaseDisplayEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkReleaseDisplayEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallInstance; + if (Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceSurfaceCapabilities2EXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDisplayPowerControlEXT_CallInstance; + if (Mock.vkDisplayPowerControlEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDisplayPowerControlEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDisplayPowerControlEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkRegisterDeviceEventEXT_CallInstance; + if (Mock.vkRegisterDeviceEventEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkRegisterDeviceEventEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkRegisterDeviceEventEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkRegisterDisplayEventEXT_CallInstance; + if (Mock.vkRegisterDisplayEventEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkRegisterDisplayEventEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkRegisterDisplayEventEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetSwapchainCounterEXT_CallInstance; + if (Mock.vkGetSwapchainCounterEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetSwapchainCounterEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetSwapchainCounterEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetRefreshCycleDurationGOOGLE_CallInstance; + if (Mock.vkGetRefreshCycleDurationGOOGLE_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetRefreshCycleDurationGOOGLE); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetRefreshCycleDurationGOOGLE_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPastPresentationTimingGOOGLE_CallInstance; + if (Mock.vkGetPastPresentationTimingGOOGLE_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPastPresentationTimingGOOGLE); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPastPresentationTimingGOOGLE_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetDiscardRectangleEXT_CallInstance; + if (Mock.vkCmdSetDiscardRectangleEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetDiscardRectangleEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetDiscardRectangleEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetDiscardRectangleEnableEXT_CallInstance; + if (Mock.vkCmdSetDiscardRectangleEnableEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetDiscardRectangleEnableEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetDiscardRectangleEnableEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetDiscardRectangleModeEXT_CallInstance; + if (Mock.vkCmdSetDiscardRectangleModeEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetDiscardRectangleModeEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetDiscardRectangleModeEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkSetHdrMetadataEXT_CallInstance; + if (Mock.vkSetHdrMetadataEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkSetHdrMetadataEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkSetHdrMetadataEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkSetDebugUtilsObjectNameEXT_CallInstance; + if (Mock.vkSetDebugUtilsObjectNameEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkSetDebugUtilsObjectNameEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkSetDebugUtilsObjectNameEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkSetDebugUtilsObjectTagEXT_CallInstance; + if (Mock.vkSetDebugUtilsObjectTagEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkSetDebugUtilsObjectTagEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkSetDebugUtilsObjectTagEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkQueueBeginDebugUtilsLabelEXT_CallInstance; + if (Mock.vkQueueBeginDebugUtilsLabelEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkQueueBeginDebugUtilsLabelEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkQueueBeginDebugUtilsLabelEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkQueueEndDebugUtilsLabelEXT_CallInstance; + if (Mock.vkQueueEndDebugUtilsLabelEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkQueueEndDebugUtilsLabelEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkQueueEndDebugUtilsLabelEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkQueueInsertDebugUtilsLabelEXT_CallInstance; + if (Mock.vkQueueInsertDebugUtilsLabelEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkQueueInsertDebugUtilsLabelEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkQueueInsertDebugUtilsLabelEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBeginDebugUtilsLabelEXT_CallInstance; + if (Mock.vkCmdBeginDebugUtilsLabelEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBeginDebugUtilsLabelEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBeginDebugUtilsLabelEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdEndDebugUtilsLabelEXT_CallInstance; + if (Mock.vkCmdEndDebugUtilsLabelEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdEndDebugUtilsLabelEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdEndDebugUtilsLabelEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdInsertDebugUtilsLabelEXT_CallInstance; + if (Mock.vkCmdInsertDebugUtilsLabelEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdInsertDebugUtilsLabelEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdInsertDebugUtilsLabelEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateDebugUtilsMessengerEXT_CallInstance; + if (Mock.vkCreateDebugUtilsMessengerEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateDebugUtilsMessengerEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateDebugUtilsMessengerEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyDebugUtilsMessengerEXT_CallInstance; + if (Mock.vkDestroyDebugUtilsMessengerEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyDebugUtilsMessengerEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyDebugUtilsMessengerEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkSubmitDebugUtilsMessageEXT_CallInstance; + if (Mock.vkSubmitDebugUtilsMessageEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkSubmitDebugUtilsMessageEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkSubmitDebugUtilsMessageEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetSampleLocationsEXT_CallInstance; + if (Mock.vkCmdSetSampleLocationsEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetSampleLocationsEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetSampleLocationsEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_CallInstance; + if (Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceMultisamplePropertiesEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetImageDrmFormatModifierPropertiesEXT_CallInstance; + if (Mock.vkGetImageDrmFormatModifierPropertiesEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetImageDrmFormatModifierPropertiesEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetImageDrmFormatModifierPropertiesEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateValidationCacheEXT_CallInstance; + if (Mock.vkCreateValidationCacheEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateValidationCacheEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateValidationCacheEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyValidationCacheEXT_CallInstance; + if (Mock.vkDestroyValidationCacheEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyValidationCacheEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyValidationCacheEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkMergeValidationCachesEXT_CallInstance; + if (Mock.vkMergeValidationCachesEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkMergeValidationCachesEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkMergeValidationCachesEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetValidationCacheDataEXT_CallInstance; + if (Mock.vkGetValidationCacheDataEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetValidationCacheDataEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetValidationCacheDataEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBindShadingRateImageNV_CallInstance; + if (Mock.vkCmdBindShadingRateImageNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBindShadingRateImageNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBindShadingRateImageNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetViewportShadingRatePaletteNV_CallInstance; + if (Mock.vkCmdSetViewportShadingRatePaletteNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetViewportShadingRatePaletteNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetViewportShadingRatePaletteNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetCoarseSampleOrderNV_CallInstance; + if (Mock.vkCmdSetCoarseSampleOrderNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetCoarseSampleOrderNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetCoarseSampleOrderNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateAccelerationStructureNV_CallInstance; + if (Mock.vkCreateAccelerationStructureNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateAccelerationStructureNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateAccelerationStructureNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyAccelerationStructureNV_CallInstance; + if (Mock.vkDestroyAccelerationStructureNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyAccelerationStructureNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyAccelerationStructureNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetAccelerationStructureMemoryRequirementsNV_CallInstance; + if (Mock.vkGetAccelerationStructureMemoryRequirementsNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetAccelerationStructureMemoryRequirementsNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetAccelerationStructureMemoryRequirementsNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkBindAccelerationStructureMemoryNV_CallInstance; + if (Mock.vkBindAccelerationStructureMemoryNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkBindAccelerationStructureMemoryNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkBindAccelerationStructureMemoryNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBuildAccelerationStructureNV_CallInstance; + if (Mock.vkCmdBuildAccelerationStructureNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBuildAccelerationStructureNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBuildAccelerationStructureNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdCopyAccelerationStructureNV_CallInstance; + if (Mock.vkCmdCopyAccelerationStructureNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdCopyAccelerationStructureNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdCopyAccelerationStructureNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdTraceRaysNV_CallInstance; + if (Mock.vkCmdTraceRaysNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdTraceRaysNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdTraceRaysNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateRayTracingPipelinesNV_CallInstance; + if (Mock.vkCreateRayTracingPipelinesNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateRayTracingPipelinesNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateRayTracingPipelinesNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetRayTracingShaderGroupHandlesKHR_CallInstance; + if (Mock.vkGetRayTracingShaderGroupHandlesKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetRayTracingShaderGroupHandlesKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetRayTracingShaderGroupHandlesKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetRayTracingShaderGroupHandlesNV_CallInstance; + if (Mock.vkGetRayTracingShaderGroupHandlesNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetRayTracingShaderGroupHandlesNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetRayTracingShaderGroupHandlesNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetAccelerationStructureHandleNV_CallInstance; + if (Mock.vkGetAccelerationStructureHandleNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetAccelerationStructureHandleNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetAccelerationStructureHandleNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdWriteAccelerationStructuresPropertiesNV_CallInstance; + if (Mock.vkCmdWriteAccelerationStructuresPropertiesNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdWriteAccelerationStructuresPropertiesNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdWriteAccelerationStructuresPropertiesNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCompileDeferredNV_CallInstance; + if (Mock.vkCompileDeferredNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCompileDeferredNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCompileDeferredNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetMemoryHostPointerPropertiesEXT_CallInstance; + if (Mock.vkGetMemoryHostPointerPropertiesEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetMemoryHostPointerPropertiesEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetMemoryHostPointerPropertiesEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdWriteBufferMarkerAMD_CallInstance; + if (Mock.vkCmdWriteBufferMarkerAMD_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdWriteBufferMarkerAMD); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdWriteBufferMarkerAMD_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallInstance; + if (Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetCalibratedTimestampsEXT_CallInstance; + if (Mock.vkGetCalibratedTimestampsEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetCalibratedTimestampsEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetCalibratedTimestampsEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDrawMeshTasksNV_CallInstance; + if (Mock.vkCmdDrawMeshTasksNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDrawMeshTasksNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDrawMeshTasksNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDrawMeshTasksIndirectNV_CallInstance; + if (Mock.vkCmdDrawMeshTasksIndirectNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDrawMeshTasksIndirectNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDrawMeshTasksIndirectNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDrawMeshTasksIndirectCountNV_CallInstance; + if (Mock.vkCmdDrawMeshTasksIndirectCountNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDrawMeshTasksIndirectCountNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDrawMeshTasksIndirectCountNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetExclusiveScissorEnableNV_CallInstance; + if (Mock.vkCmdSetExclusiveScissorEnableNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetExclusiveScissorEnableNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetExclusiveScissorEnableNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetExclusiveScissorNV_CallInstance; + if (Mock.vkCmdSetExclusiveScissorNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetExclusiveScissorNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetExclusiveScissorNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetCheckpointNV_CallInstance; + if (Mock.vkCmdSetCheckpointNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetCheckpointNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetCheckpointNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetQueueCheckpointDataNV_CallInstance; + if (Mock.vkGetQueueCheckpointDataNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetQueueCheckpointDataNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetQueueCheckpointDataNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkInitializePerformanceApiINTEL_CallInstance; + if (Mock.vkInitializePerformanceApiINTEL_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkInitializePerformanceApiINTEL); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkInitializePerformanceApiINTEL_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkUninitializePerformanceApiINTEL_CallInstance; + if (Mock.vkUninitializePerformanceApiINTEL_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkUninitializePerformanceApiINTEL); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkUninitializePerformanceApiINTEL_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetPerformanceMarkerINTEL_CallInstance; + if (Mock.vkCmdSetPerformanceMarkerINTEL_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetPerformanceMarkerINTEL); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetPerformanceMarkerINTEL_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetPerformanceStreamMarkerINTEL_CallInstance; + if (Mock.vkCmdSetPerformanceStreamMarkerINTEL_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetPerformanceStreamMarkerINTEL); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetPerformanceStreamMarkerINTEL_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetPerformanceOverrideINTEL_CallInstance; + if (Mock.vkCmdSetPerformanceOverrideINTEL_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetPerformanceOverrideINTEL); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetPerformanceOverrideINTEL_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkAcquirePerformanceConfigurationINTEL_CallInstance; + if (Mock.vkAcquirePerformanceConfigurationINTEL_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkAcquirePerformanceConfigurationINTEL); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkAcquirePerformanceConfigurationINTEL_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkReleasePerformanceConfigurationINTEL_CallInstance; + if (Mock.vkReleasePerformanceConfigurationINTEL_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkReleasePerformanceConfigurationINTEL); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkReleasePerformanceConfigurationINTEL_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkQueueSetPerformanceConfigurationINTEL_CallInstance; + if (Mock.vkQueueSetPerformanceConfigurationINTEL_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkQueueSetPerformanceConfigurationINTEL); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkQueueSetPerformanceConfigurationINTEL_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPerformanceParameterINTEL_CallInstance; + if (Mock.vkGetPerformanceParameterINTEL_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPerformanceParameterINTEL); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPerformanceParameterINTEL_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkSetLocalDimmingAMD_CallInstance; + if (Mock.vkSetLocalDimmingAMD_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkSetLocalDimmingAMD); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkSetLocalDimmingAMD_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetBufferDeviceAddressEXT_CallInstance; + if (Mock.vkGetBufferDeviceAddressEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetBufferDeviceAddressEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetBufferDeviceAddressEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceToolPropertiesEXT_CallInstance; + if (Mock.vkGetPhysicalDeviceToolPropertiesEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceToolPropertiesEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceToolPropertiesEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallInstance; + if (Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallInstance; + if (Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateHeadlessSurfaceEXT_CallInstance; + if (Mock.vkCreateHeadlessSurfaceEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateHeadlessSurfaceEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateHeadlessSurfaceEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetLineStippleEXT_CallInstance; + if (Mock.vkCmdSetLineStippleEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetLineStippleEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetLineStippleEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkResetQueryPoolEXT_CallInstance; + if (Mock.vkResetQueryPoolEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkResetQueryPoolEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkResetQueryPoolEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetCullModeEXT_CallInstance; + if (Mock.vkCmdSetCullModeEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetCullModeEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetCullModeEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetFrontFaceEXT_CallInstance; + if (Mock.vkCmdSetFrontFaceEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetFrontFaceEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetFrontFaceEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetPrimitiveTopologyEXT_CallInstance; + if (Mock.vkCmdSetPrimitiveTopologyEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetPrimitiveTopologyEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetPrimitiveTopologyEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetViewportWithCountEXT_CallInstance; + if (Mock.vkCmdSetViewportWithCountEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetViewportWithCountEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetViewportWithCountEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetScissorWithCountEXT_CallInstance; + if (Mock.vkCmdSetScissorWithCountEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetScissorWithCountEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetScissorWithCountEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBindVertexBuffers2EXT_CallInstance; + if (Mock.vkCmdBindVertexBuffers2EXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBindVertexBuffers2EXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBindVertexBuffers2EXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetDepthTestEnableEXT_CallInstance; + if (Mock.vkCmdSetDepthTestEnableEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetDepthTestEnableEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetDepthTestEnableEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetDepthWriteEnableEXT_CallInstance; + if (Mock.vkCmdSetDepthWriteEnableEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetDepthWriteEnableEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetDepthWriteEnableEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetDepthCompareOpEXT_CallInstance; + if (Mock.vkCmdSetDepthCompareOpEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetDepthCompareOpEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetDepthCompareOpEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetDepthBoundsTestEnableEXT_CallInstance; + if (Mock.vkCmdSetDepthBoundsTestEnableEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetDepthBoundsTestEnableEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetDepthBoundsTestEnableEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetStencilTestEnableEXT_CallInstance; + if (Mock.vkCmdSetStencilTestEnableEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetStencilTestEnableEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetStencilTestEnableEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetStencilOpEXT_CallInstance; + if (Mock.vkCmdSetStencilOpEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetStencilOpEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetStencilOpEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkReleaseSwapchainImagesEXT_CallInstance; + if (Mock.vkReleaseSwapchainImagesEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkReleaseSwapchainImagesEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkReleaseSwapchainImagesEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetGeneratedCommandsMemoryRequirementsNV_CallInstance; + if (Mock.vkGetGeneratedCommandsMemoryRequirementsNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetGeneratedCommandsMemoryRequirementsNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetGeneratedCommandsMemoryRequirementsNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdPreprocessGeneratedCommandsNV_CallInstance; + if (Mock.vkCmdPreprocessGeneratedCommandsNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdPreprocessGeneratedCommandsNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdPreprocessGeneratedCommandsNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdExecuteGeneratedCommandsNV_CallInstance; + if (Mock.vkCmdExecuteGeneratedCommandsNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdExecuteGeneratedCommandsNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdExecuteGeneratedCommandsNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBindPipelineShaderGroupNV_CallInstance; + if (Mock.vkCmdBindPipelineShaderGroupNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBindPipelineShaderGroupNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBindPipelineShaderGroupNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateIndirectCommandsLayoutNV_CallInstance; + if (Mock.vkCreateIndirectCommandsLayoutNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateIndirectCommandsLayoutNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateIndirectCommandsLayoutNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyIndirectCommandsLayoutNV_CallInstance; + if (Mock.vkDestroyIndirectCommandsLayoutNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyIndirectCommandsLayoutNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyIndirectCommandsLayoutNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkAcquireDrmDisplayEXT_CallInstance; + if (Mock.vkAcquireDrmDisplayEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkAcquireDrmDisplayEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkAcquireDrmDisplayEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDrmDisplayEXT_CallInstance; + if (Mock.vkGetDrmDisplayEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDrmDisplayEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDrmDisplayEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreatePrivateDataSlotEXT_CallInstance; + if (Mock.vkCreatePrivateDataSlotEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreatePrivateDataSlotEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreatePrivateDataSlotEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyPrivateDataSlotEXT_CallInstance; + if (Mock.vkDestroyPrivateDataSlotEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyPrivateDataSlotEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyPrivateDataSlotEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkSetPrivateDataEXT_CallInstance; + if (Mock.vkSetPrivateDataEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkSetPrivateDataEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkSetPrivateDataEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPrivateDataEXT_CallInstance; + if (Mock.vkGetPrivateDataEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPrivateDataEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPrivateDataEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDescriptorSetLayoutSizeEXT_CallInstance; + if (Mock.vkGetDescriptorSetLayoutSizeEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDescriptorSetLayoutSizeEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDescriptorSetLayoutSizeEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_CallInstance; + if (Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDescriptorSetLayoutBindingOffsetEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDescriptorEXT_CallInstance; + if (Mock.vkGetDescriptorEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDescriptorEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDescriptorEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBindDescriptorBuffersEXT_CallInstance; + if (Mock.vkCmdBindDescriptorBuffersEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBindDescriptorBuffersEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBindDescriptorBuffersEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetDescriptorBufferOffsetsEXT_CallInstance; + if (Mock.vkCmdSetDescriptorBufferOffsetsEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetDescriptorBufferOffsetsEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetDescriptorBufferOffsetsEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CallInstance; + if (Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBindDescriptorBufferEmbeddedSamplersEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_CallInstance; + if (Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetBufferOpaqueCaptureDescriptorDataEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_CallInstance; + if (Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetImageOpaqueCaptureDescriptorDataEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallInstance; + if (Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetImageViewOpaqueCaptureDescriptorDataEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallInstance; + if (Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetSamplerOpaqueCaptureDescriptorDataEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallInstance; + if (Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetFragmentShadingRateEnumNV_CallInstance; + if (Mock.vkCmdSetFragmentShadingRateEnumNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetFragmentShadingRateEnumNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetFragmentShadingRateEnumNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetImageSubresourceLayout2EXT_CallInstance; + if (Mock.vkGetImageSubresourceLayout2EXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetImageSubresourceLayout2EXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetImageSubresourceLayout2EXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDeviceFaultInfoEXT_CallInstance; + if (Mock.vkGetDeviceFaultInfoEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDeviceFaultInfoEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDeviceFaultInfoEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetVertexInputEXT_CallInstance; + if (Mock.vkCmdSetVertexInputEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetVertexInputEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetVertexInputEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallInstance; + if (Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSubpassShadingHUAWEI_CallInstance; + if (Mock.vkCmdSubpassShadingHUAWEI_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSubpassShadingHUAWEI); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSubpassShadingHUAWEI_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBindInvocationMaskHUAWEI_CallInstance; + if (Mock.vkCmdBindInvocationMaskHUAWEI_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBindInvocationMaskHUAWEI); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBindInvocationMaskHUAWEI_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetMemoryRemoteAddressNV_CallInstance; + if (Mock.vkGetMemoryRemoteAddressNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetMemoryRemoteAddressNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetMemoryRemoteAddressNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPipelinePropertiesEXT_CallInstance; + if (Mock.vkGetPipelinePropertiesEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPipelinePropertiesEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPipelinePropertiesEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetPatchControlPointsEXT_CallInstance; + if (Mock.vkCmdSetPatchControlPointsEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetPatchControlPointsEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetPatchControlPointsEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetRasterizerDiscardEnableEXT_CallInstance; + if (Mock.vkCmdSetRasterizerDiscardEnableEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetRasterizerDiscardEnableEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetRasterizerDiscardEnableEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetDepthBiasEnableEXT_CallInstance; + if (Mock.vkCmdSetDepthBiasEnableEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetDepthBiasEnableEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetDepthBiasEnableEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetLogicOpEXT_CallInstance; + if (Mock.vkCmdSetLogicOpEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetLogicOpEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetLogicOpEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetPrimitiveRestartEnableEXT_CallInstance; + if (Mock.vkCmdSetPrimitiveRestartEnableEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetPrimitiveRestartEnableEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetPrimitiveRestartEnableEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetColorWriteEnableEXT_CallInstance; + if (Mock.vkCmdSetColorWriteEnableEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetColorWriteEnableEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetColorWriteEnableEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDrawMultiEXT_CallInstance; + if (Mock.vkCmdDrawMultiEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDrawMultiEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDrawMultiEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDrawMultiIndexedEXT_CallInstance; + if (Mock.vkCmdDrawMultiIndexedEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDrawMultiIndexedEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDrawMultiIndexedEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateMicromapEXT_CallInstance; + if (Mock.vkCreateMicromapEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateMicromapEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateMicromapEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyMicromapEXT_CallInstance; + if (Mock.vkDestroyMicromapEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyMicromapEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyMicromapEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBuildMicromapsEXT_CallInstance; + if (Mock.vkCmdBuildMicromapsEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBuildMicromapsEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBuildMicromapsEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkBuildMicromapsEXT_CallInstance; + if (Mock.vkBuildMicromapsEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkBuildMicromapsEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkBuildMicromapsEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCopyMicromapEXT_CallInstance; + if (Mock.vkCopyMicromapEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCopyMicromapEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCopyMicromapEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCopyMicromapToMemoryEXT_CallInstance; + if (Mock.vkCopyMicromapToMemoryEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCopyMicromapToMemoryEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCopyMicromapToMemoryEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCopyMemoryToMicromapEXT_CallInstance; + if (Mock.vkCopyMemoryToMicromapEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCopyMemoryToMicromapEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCopyMemoryToMicromapEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkWriteMicromapsPropertiesEXT_CallInstance; + if (Mock.vkWriteMicromapsPropertiesEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkWriteMicromapsPropertiesEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkWriteMicromapsPropertiesEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdCopyMicromapEXT_CallInstance; + if (Mock.vkCmdCopyMicromapEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdCopyMicromapEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdCopyMicromapEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdCopyMicromapToMemoryEXT_CallInstance; + if (Mock.vkCmdCopyMicromapToMemoryEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdCopyMicromapToMemoryEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdCopyMicromapToMemoryEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdCopyMemoryToMicromapEXT_CallInstance; + if (Mock.vkCmdCopyMemoryToMicromapEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdCopyMemoryToMicromapEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdCopyMemoryToMicromapEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdWriteMicromapsPropertiesEXT_CallInstance; + if (Mock.vkCmdWriteMicromapsPropertiesEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdWriteMicromapsPropertiesEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdWriteMicromapsPropertiesEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDeviceMicromapCompatibilityEXT_CallInstance; + if (Mock.vkGetDeviceMicromapCompatibilityEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDeviceMicromapCompatibilityEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDeviceMicromapCompatibilityEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetMicromapBuildSizesEXT_CallInstance; + if (Mock.vkGetMicromapBuildSizesEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetMicromapBuildSizesEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetMicromapBuildSizesEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDrawClusterHUAWEI_CallInstance; + if (Mock.vkCmdDrawClusterHUAWEI_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDrawClusterHUAWEI); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDrawClusterHUAWEI_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDrawClusterIndirectHUAWEI_CallInstance; + if (Mock.vkCmdDrawClusterIndirectHUAWEI_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDrawClusterIndirectHUAWEI); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDrawClusterIndirectHUAWEI_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkSetDeviceMemoryPriorityEXT_CallInstance; + if (Mock.vkSetDeviceMemoryPriorityEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkSetDeviceMemoryPriorityEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkSetDeviceMemoryPriorityEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_CallInstance; + if (Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDescriptorSetLayoutHostMappingInfoVALVE); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDescriptorSetHostMappingVALVE_CallInstance; + if (Mock.vkGetDescriptorSetHostMappingVALVE_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDescriptorSetHostMappingVALVE); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDescriptorSetHostMappingVALVE_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdCopyMemoryIndirectNV_CallInstance; + if (Mock.vkCmdCopyMemoryIndirectNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdCopyMemoryIndirectNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdCopyMemoryIndirectNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdCopyMemoryToImageIndirectNV_CallInstance; + if (Mock.vkCmdCopyMemoryToImageIndirectNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdCopyMemoryToImageIndirectNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdCopyMemoryToImageIndirectNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDecompressMemoryNV_CallInstance; + if (Mock.vkCmdDecompressMemoryNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDecompressMemoryNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDecompressMemoryNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDecompressMemoryIndirectCountNV_CallInstance; + if (Mock.vkCmdDecompressMemoryIndirectCountNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDecompressMemoryIndirectCountNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDecompressMemoryIndirectCountNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetTessellationDomainOriginEXT_CallInstance; + if (Mock.vkCmdSetTessellationDomainOriginEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetTessellationDomainOriginEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetTessellationDomainOriginEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetDepthClampEnableEXT_CallInstance; + if (Mock.vkCmdSetDepthClampEnableEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetDepthClampEnableEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetDepthClampEnableEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetPolygonModeEXT_CallInstance; + if (Mock.vkCmdSetPolygonModeEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetPolygonModeEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetPolygonModeEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetRasterizationSamplesEXT_CallInstance; + if (Mock.vkCmdSetRasterizationSamplesEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetRasterizationSamplesEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetRasterizationSamplesEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetSampleMaskEXT_CallInstance; + if (Mock.vkCmdSetSampleMaskEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetSampleMaskEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetSampleMaskEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetAlphaToCoverageEnableEXT_CallInstance; + if (Mock.vkCmdSetAlphaToCoverageEnableEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetAlphaToCoverageEnableEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetAlphaToCoverageEnableEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetAlphaToOneEnableEXT_CallInstance; + if (Mock.vkCmdSetAlphaToOneEnableEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetAlphaToOneEnableEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetAlphaToOneEnableEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetLogicOpEnableEXT_CallInstance; + if (Mock.vkCmdSetLogicOpEnableEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetLogicOpEnableEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetLogicOpEnableEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetColorBlendEnableEXT_CallInstance; + if (Mock.vkCmdSetColorBlendEnableEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetColorBlendEnableEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetColorBlendEnableEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetColorBlendEquationEXT_CallInstance; + if (Mock.vkCmdSetColorBlendEquationEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetColorBlendEquationEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetColorBlendEquationEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetColorWriteMaskEXT_CallInstance; + if (Mock.vkCmdSetColorWriteMaskEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetColorWriteMaskEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetColorWriteMaskEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetRasterizationStreamEXT_CallInstance; + if (Mock.vkCmdSetRasterizationStreamEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetRasterizationStreamEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetRasterizationStreamEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetConservativeRasterizationModeEXT_CallInstance; + if (Mock.vkCmdSetConservativeRasterizationModeEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetConservativeRasterizationModeEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetConservativeRasterizationModeEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetExtraPrimitiveOverestimationSizeEXT_CallInstance; + if (Mock.vkCmdSetExtraPrimitiveOverestimationSizeEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetExtraPrimitiveOverestimationSizeEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetExtraPrimitiveOverestimationSizeEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetDepthClipEnableEXT_CallInstance; + if (Mock.vkCmdSetDepthClipEnableEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetDepthClipEnableEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetDepthClipEnableEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetSampleLocationsEnableEXT_CallInstance; + if (Mock.vkCmdSetSampleLocationsEnableEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetSampleLocationsEnableEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetSampleLocationsEnableEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetColorBlendAdvancedEXT_CallInstance; + if (Mock.vkCmdSetColorBlendAdvancedEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetColorBlendAdvancedEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetColorBlendAdvancedEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetProvokingVertexModeEXT_CallInstance; + if (Mock.vkCmdSetProvokingVertexModeEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetProvokingVertexModeEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetProvokingVertexModeEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetLineRasterizationModeEXT_CallInstance; + if (Mock.vkCmdSetLineRasterizationModeEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetLineRasterizationModeEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetLineRasterizationModeEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetLineStippleEnableEXT_CallInstance; + if (Mock.vkCmdSetLineStippleEnableEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetLineStippleEnableEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetLineStippleEnableEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetDepthClipNegativeOneToOneEXT_CallInstance; + if (Mock.vkCmdSetDepthClipNegativeOneToOneEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetDepthClipNegativeOneToOneEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetDepthClipNegativeOneToOneEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetViewportWScalingEnableNV_CallInstance; + if (Mock.vkCmdSetViewportWScalingEnableNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetViewportWScalingEnableNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetViewportWScalingEnableNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetViewportSwizzleNV_CallInstance; + if (Mock.vkCmdSetViewportSwizzleNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetViewportSwizzleNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetViewportSwizzleNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetCoverageToColorEnableNV_CallInstance; + if (Mock.vkCmdSetCoverageToColorEnableNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetCoverageToColorEnableNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetCoverageToColorEnableNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetCoverageToColorLocationNV_CallInstance; + if (Mock.vkCmdSetCoverageToColorLocationNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetCoverageToColorLocationNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetCoverageToColorLocationNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetCoverageModulationModeNV_CallInstance; + if (Mock.vkCmdSetCoverageModulationModeNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetCoverageModulationModeNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetCoverageModulationModeNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetCoverageModulationTableEnableNV_CallInstance; + if (Mock.vkCmdSetCoverageModulationTableEnableNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetCoverageModulationTableEnableNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetCoverageModulationTableEnableNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetCoverageModulationTableNV_CallInstance; + if (Mock.vkCmdSetCoverageModulationTableNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetCoverageModulationTableNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetCoverageModulationTableNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetShadingRateImageEnableNV_CallInstance; + if (Mock.vkCmdSetShadingRateImageEnableNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetShadingRateImageEnableNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetShadingRateImageEnableNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetRepresentativeFragmentTestEnableNV_CallInstance; + if (Mock.vkCmdSetRepresentativeFragmentTestEnableNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetRepresentativeFragmentTestEnableNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetRepresentativeFragmentTestEnableNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetCoverageReductionModeNV_CallInstance; + if (Mock.vkCmdSetCoverageReductionModeNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetCoverageReductionModeNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetCoverageReductionModeNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetShaderModuleIdentifierEXT_CallInstance; + if (Mock.vkGetShaderModuleIdentifierEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetShaderModuleIdentifierEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetShaderModuleIdentifierEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetShaderModuleCreateInfoIdentifierEXT_CallInstance; + if (Mock.vkGetShaderModuleCreateInfoIdentifierEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetShaderModuleCreateInfoIdentifierEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetShaderModuleCreateInfoIdentifierEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallInstance; + if (Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceOpticalFlowImageFormatsNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateOpticalFlowSessionNV_CallInstance; + if (Mock.vkCreateOpticalFlowSessionNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateOpticalFlowSessionNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateOpticalFlowSessionNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyOpticalFlowSessionNV_CallInstance; + if (Mock.vkDestroyOpticalFlowSessionNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyOpticalFlowSessionNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyOpticalFlowSessionNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkBindOpticalFlowSessionImageNV_CallInstance; + if (Mock.vkBindOpticalFlowSessionImageNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkBindOpticalFlowSessionImageNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkBindOpticalFlowSessionImageNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdOpticalFlowExecuteNV_CallInstance; + if (Mock.vkCmdOpticalFlowExecuteNV_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdOpticalFlowExecuteNV); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdOpticalFlowExecuteNV_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateShadersEXT_CallInstance; + if (Mock.vkCreateShadersEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateShadersEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateShadersEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyShaderEXT_CallInstance; + if (Mock.vkDestroyShaderEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyShaderEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyShaderEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetShaderBinaryDataEXT_CallInstance; + if (Mock.vkGetShaderBinaryDataEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetShaderBinaryDataEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetShaderBinaryDataEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBindShadersEXT_CallInstance; + if (Mock.vkCmdBindShadersEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBindShadersEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBindShadersEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetFramebufferTilePropertiesQCOM_CallInstance; + if (Mock.vkGetFramebufferTilePropertiesQCOM_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetFramebufferTilePropertiesQCOM); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetFramebufferTilePropertiesQCOM_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDynamicRenderingTilePropertiesQCOM_CallInstance; + if (Mock.vkGetDynamicRenderingTilePropertiesQCOM_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDynamicRenderingTilePropertiesQCOM); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDynamicRenderingTilePropertiesQCOM_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetAttachmentFeedbackLoopEnableEXT_CallInstance; + if (Mock.vkCmdSetAttachmentFeedbackLoopEnableEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetAttachmentFeedbackLoopEnableEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetAttachmentFeedbackLoopEnableEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateAccelerationStructureKHR_CallInstance; + if (Mock.vkCreateAccelerationStructureKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateAccelerationStructureKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateAccelerationStructureKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkDestroyAccelerationStructureKHR_CallInstance; + if (Mock.vkDestroyAccelerationStructureKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkDestroyAccelerationStructureKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkDestroyAccelerationStructureKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBuildAccelerationStructuresKHR_CallInstance; + if (Mock.vkCmdBuildAccelerationStructuresKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBuildAccelerationStructuresKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBuildAccelerationStructuresKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdBuildAccelerationStructuresIndirectKHR_CallInstance; + if (Mock.vkCmdBuildAccelerationStructuresIndirectKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdBuildAccelerationStructuresIndirectKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdBuildAccelerationStructuresIndirectKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkBuildAccelerationStructuresKHR_CallInstance; + if (Mock.vkBuildAccelerationStructuresKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkBuildAccelerationStructuresKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkBuildAccelerationStructuresKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCopyAccelerationStructureKHR_CallInstance; + if (Mock.vkCopyAccelerationStructureKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCopyAccelerationStructureKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCopyAccelerationStructureKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCopyAccelerationStructureToMemoryKHR_CallInstance; + if (Mock.vkCopyAccelerationStructureToMemoryKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCopyAccelerationStructureToMemoryKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCopyAccelerationStructureToMemoryKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCopyMemoryToAccelerationStructureKHR_CallInstance; + if (Mock.vkCopyMemoryToAccelerationStructureKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCopyMemoryToAccelerationStructureKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCopyMemoryToAccelerationStructureKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkWriteAccelerationStructuresPropertiesKHR_CallInstance; + if (Mock.vkWriteAccelerationStructuresPropertiesKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkWriteAccelerationStructuresPropertiesKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkWriteAccelerationStructuresPropertiesKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdCopyAccelerationStructureKHR_CallInstance; + if (Mock.vkCmdCopyAccelerationStructureKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdCopyAccelerationStructureKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdCopyAccelerationStructureKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdCopyAccelerationStructureToMemoryKHR_CallInstance; + if (Mock.vkCmdCopyAccelerationStructureToMemoryKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdCopyAccelerationStructureToMemoryKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdCopyAccelerationStructureToMemoryKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdCopyMemoryToAccelerationStructureKHR_CallInstance; + if (Mock.vkCmdCopyMemoryToAccelerationStructureKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdCopyMemoryToAccelerationStructureKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdCopyMemoryToAccelerationStructureKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetAccelerationStructureDeviceAddressKHR_CallInstance; + if (Mock.vkGetAccelerationStructureDeviceAddressKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetAccelerationStructureDeviceAddressKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetAccelerationStructureDeviceAddressKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_CallInstance; + if (Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdWriteAccelerationStructuresPropertiesKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_CallInstance; + if (Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetDeviceAccelerationStructureCompatibilityKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetAccelerationStructureBuildSizesKHR_CallInstance; + if (Mock.vkGetAccelerationStructureBuildSizesKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetAccelerationStructureBuildSizesKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetAccelerationStructureBuildSizesKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdTraceRaysKHR_CallInstance; + if (Mock.vkCmdTraceRaysKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdTraceRaysKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdTraceRaysKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCreateRayTracingPipelinesKHR_CallInstance; + if (Mock.vkCreateRayTracingPipelinesKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCreateRayTracingPipelinesKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCreateRayTracingPipelinesKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallInstance; + if (Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdTraceRaysIndirectKHR_CallInstance; + if (Mock.vkCmdTraceRaysIndirectKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdTraceRaysIndirectKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdTraceRaysIndirectKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkGetRayTracingShaderGroupStackSizeKHR_CallInstance; + if (Mock.vkGetRayTracingShaderGroupStackSizeKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkGetRayTracingShaderGroupStackSizeKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkGetRayTracingShaderGroupStackSizeKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdSetRayTracingPipelineStackSizeKHR_CallInstance; + if (Mock.vkCmdSetRayTracingPipelineStackSizeKHR_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdSetRayTracingPipelineStackSizeKHR); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdSetRayTracingPipelineStackSizeKHR_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDrawMeshTasksEXT_CallInstance; + if (Mock.vkCmdDrawMeshTasksEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDrawMeshTasksEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDrawMeshTasksEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDrawMeshTasksIndirectEXT_CallInstance; + if (Mock.vkCmdDrawMeshTasksIndirectEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDrawMeshTasksIndirectEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDrawMeshTasksIndirectEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.vkCmdDrawMeshTasksIndirectCountEXT_CallInstance; + if (Mock.vkCmdDrawMeshTasksIndirectCountEXT_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_vkCmdDrawMeshTasksIndirectCountEXT); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.vkCmdDrawMeshTasksIndirectCountEXT_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } +} + +void Mockvulkan_core_Init(void) +{ + Mockvulkan_core_Destroy(); +} + +void Mockvulkan_core_Destroy(void) +{ + CMock_Guts_MemFreeAll(); + memset(&Mock, 0, sizeof(Mock)); +} + +VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateInstance_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateInstance); + cmock_call_instance = (CMOCK_vkCreateInstance_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateInstance_CallInstance); + Mock.vkCreateInstance_CallInstance = CMock_Guts_MemNext(Mock.vkCreateInstance_CallInstance); + if (Mock.vkCreateInstance_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateInstance_FinalReturn; + memcpy((void*)(&Mock.vkCreateInstance_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateInstance_CallbackBool && + Mock.vkCreateInstance_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateInstance_CallbackFunctionPointer(pCreateInfo, pAllocator, pInstance, Mock.vkCreateInstance_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateInstance,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkInstanceCreateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateInstance,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInstance) + { + UNITY_SET_DETAILS(CMockString_vkCreateInstance,CMockString_pInstance); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInstance), (void*)(pInstance), sizeof(VkInstance), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateInstance_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateInstance_CallbackFunctionPointer(pCreateInfo, pAllocator, pInstance, Mock.vkCreateInstance_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pInstance_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pInstance, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pInstance, (const void*)cmock_call_instance->ReturnThruPtr_pInstance_Val, + cmock_call_instance->ReturnThruPtr_pInstance_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateInstance(CMOCK_vkCreateInstance_CALL_INSTANCE* cmock_call_instance, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); +void CMockExpectParameters_vkCreateInstance(CMOCK_vkCreateInstance_CALL_INSTANCE* cmock_call_instance, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) +{ + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pInstance = pInstance; + cmock_call_instance->IgnoreArg_pInstance = 0; + cmock_call_instance->ReturnThruPtr_pInstance_Used = 0; +} + +void vkCreateInstance_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateInstance_CALL_INSTANCE)); + CMOCK_vkCreateInstance_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateInstance_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateInstance_CallInstance = CMock_Guts_MemChain(Mock.vkCreateInstance_CallInstance, cmock_guts_index); + Mock.vkCreateInstance_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateInstance_IgnoreBool = (char)1; +} + +void vkCreateInstance_CMockStopIgnore(void) +{ + if(Mock.vkCreateInstance_IgnoreBool) + Mock.vkCreateInstance_CallInstance = CMock_Guts_MemNext(Mock.vkCreateInstance_CallInstance); + Mock.vkCreateInstance_IgnoreBool = (char)0; +} + +void vkCreateInstance_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateInstance_CALL_INSTANCE)); + CMOCK_vkCreateInstance_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateInstance_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateInstance_CallInstance = CMock_Guts_MemChain(Mock.vkCreateInstance_CallInstance, cmock_guts_index); + Mock.vkCreateInstance_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateInstance_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateInstance_CALL_INSTANCE)); + CMOCK_vkCreateInstance_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateInstance_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateInstance_CallInstance = CMock_Guts_MemChain(Mock.vkCreateInstance_CallInstance, cmock_guts_index); + Mock.vkCreateInstance_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateInstance(cmock_call_instance, pCreateInfo, pAllocator, pInstance); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateInstance_AddCallback(CMOCK_vkCreateInstance_CALLBACK Callback) +{ + Mock.vkCreateInstance_IgnoreBool = (char)0; + Mock.vkCreateInstance_CallbackBool = (char)1; + Mock.vkCreateInstance_CallbackFunctionPointer = Callback; +} + +void vkCreateInstance_Stub(CMOCK_vkCreateInstance_CALLBACK Callback) +{ + Mock.vkCreateInstance_IgnoreBool = (char)0; + Mock.vkCreateInstance_CallbackBool = (char)0; + Mock.vkCreateInstance_CallbackFunctionPointer = Callback; +} + +void vkCreateInstance_CMockReturnMemThruPtr_pInstance(UNITY_LINE_TYPE cmock_line, VkInstance const* pInstance, size_t cmock_size) +{ + CMOCK_vkCreateInstance_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateInstance_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateInstance_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pInstance_Used = 1; + cmock_call_instance->ReturnThruPtr_pInstance_Val = pInstance; + cmock_call_instance->ReturnThruPtr_pInstance_Size = cmock_size; +} + +void vkCreateInstance_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateInstance_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateInstance_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateInstance_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateInstance_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateInstance_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateInstance_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateInstance_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateInstance_CMockIgnoreArg_pInstance(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateInstance_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateInstance_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateInstance_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInstance = 1; +} + +void vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyInstance_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyInstance); + cmock_call_instance = (CMOCK_vkDestroyInstance_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyInstance_CallInstance); + Mock.vkDestroyInstance_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyInstance_CallInstance); + if (Mock.vkDestroyInstance_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyInstance_CallbackBool && + Mock.vkDestroyInstance_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyInstance_CallbackFunctionPointer(instance, pAllocator, Mock.vkDestroyInstance_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_instance) + { + UNITY_SET_DETAILS(CMockString_vkDestroyInstance,CMockString_instance); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), sizeof(VkInstance), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyInstance,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyInstance_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyInstance_CallbackFunctionPointer(instance, pAllocator, Mock.vkDestroyInstance_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyInstance(CMOCK_vkDestroyInstance_CALL_INSTANCE* cmock_call_instance, VkInstance instance, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyInstance(CMOCK_vkDestroyInstance_CALL_INSTANCE* cmock_call_instance, VkInstance instance, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), + sizeof(VkInstance[sizeof(instance) == sizeof(VkInstance) ? 1 : -1])); /* add VkInstance to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_instance = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyInstance_CMockIgnore(void) +{ + Mock.vkDestroyInstance_IgnoreBool = (char)1; +} + +void vkDestroyInstance_CMockStopIgnore(void) +{ + Mock.vkDestroyInstance_IgnoreBool = (char)0; +} + +void vkDestroyInstance_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyInstance_CALL_INSTANCE)); + CMOCK_vkDestroyInstance_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyInstance_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyInstance_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyInstance_CallInstance, cmock_guts_index); + Mock.vkDestroyInstance_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyInstance_CMockExpect(UNITY_LINE_TYPE cmock_line, VkInstance instance, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyInstance_CALL_INSTANCE)); + CMOCK_vkDestroyInstance_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyInstance_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyInstance_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyInstance_CallInstance, cmock_guts_index); + Mock.vkDestroyInstance_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyInstance(cmock_call_instance, instance, pAllocator); +} + +void vkDestroyInstance_AddCallback(CMOCK_vkDestroyInstance_CALLBACK Callback) +{ + Mock.vkDestroyInstance_IgnoreBool = (char)0; + Mock.vkDestroyInstance_CallbackBool = (char)1; + Mock.vkDestroyInstance_CallbackFunctionPointer = Callback; +} + +void vkDestroyInstance_Stub(CMOCK_vkDestroyInstance_CALLBACK Callback) +{ + Mock.vkDestroyInstance_IgnoreBool = (char)0; + Mock.vkDestroyInstance_CallbackBool = (char)0; + Mock.vkDestroyInstance_CallbackFunctionPointer = Callback; +} + +void vkDestroyInstance_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyInstance_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyInstance_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyInstance_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_instance = 1; +} + +void vkDestroyInstance_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyInstance_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyInstance_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyInstance_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +VkResult vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkEnumeratePhysicalDevices_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkEnumeratePhysicalDevices); + cmock_call_instance = (CMOCK_vkEnumeratePhysicalDevices_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkEnumeratePhysicalDevices_CallInstance); + Mock.vkEnumeratePhysicalDevices_CallInstance = CMock_Guts_MemNext(Mock.vkEnumeratePhysicalDevices_CallInstance); + if (Mock.vkEnumeratePhysicalDevices_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkEnumeratePhysicalDevices_FinalReturn; + memcpy((void*)(&Mock.vkEnumeratePhysicalDevices_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkEnumeratePhysicalDevices_CallbackBool && + Mock.vkEnumeratePhysicalDevices_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkEnumeratePhysicalDevices_CallbackFunctionPointer(instance, pPhysicalDeviceCount, pPhysicalDevices, Mock.vkEnumeratePhysicalDevices_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_instance) + { + UNITY_SET_DETAILS(CMockString_vkEnumeratePhysicalDevices,CMockString_instance); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), sizeof(VkInstance), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPhysicalDeviceCount) + { + UNITY_SET_DETAILS(CMockString_vkEnumeratePhysicalDevices,CMockString_pPhysicalDeviceCount); + if (cmock_call_instance->Expected_pPhysicalDeviceCount == NULL) + { UNITY_TEST_ASSERT_NULL(pPhysicalDeviceCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pPhysicalDeviceCount, pPhysicalDeviceCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pPhysicalDevices) + { + UNITY_SET_DETAILS(CMockString_vkEnumeratePhysicalDevices,CMockString_pPhysicalDevices); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pPhysicalDevices), (void*)(pPhysicalDevices), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkEnumeratePhysicalDevices_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkEnumeratePhysicalDevices_CallbackFunctionPointer(instance, pPhysicalDeviceCount, pPhysicalDevices, Mock.vkEnumeratePhysicalDevices_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPhysicalDeviceCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPhysicalDeviceCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPhysicalDeviceCount, (const void*)cmock_call_instance->ReturnThruPtr_pPhysicalDeviceCount_Val, + cmock_call_instance->ReturnThruPtr_pPhysicalDeviceCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pPhysicalDevices_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPhysicalDevices, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPhysicalDevices, (const void*)cmock_call_instance->ReturnThruPtr_pPhysicalDevices_Val, + cmock_call_instance->ReturnThruPtr_pPhysicalDevices_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkEnumeratePhysicalDevices(CMOCK_vkEnumeratePhysicalDevices_CALL_INSTANCE* cmock_call_instance, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); +void CMockExpectParameters_vkEnumeratePhysicalDevices(CMOCK_vkEnumeratePhysicalDevices_CALL_INSTANCE* cmock_call_instance, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) +{ + memcpy((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), + sizeof(VkInstance[sizeof(instance) == sizeof(VkInstance) ? 1 : -1])); /* add VkInstance to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_instance = 0; + cmock_call_instance->Expected_pPhysicalDeviceCount = pPhysicalDeviceCount; + cmock_call_instance->IgnoreArg_pPhysicalDeviceCount = 0; + cmock_call_instance->ReturnThruPtr_pPhysicalDeviceCount_Used = 0; + cmock_call_instance->Expected_pPhysicalDevices = pPhysicalDevices; + cmock_call_instance->IgnoreArg_pPhysicalDevices = 0; + cmock_call_instance->ReturnThruPtr_pPhysicalDevices_Used = 0; +} + +void vkEnumeratePhysicalDevices_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkEnumeratePhysicalDevices_CALL_INSTANCE)); + CMOCK_vkEnumeratePhysicalDevices_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDevices_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkEnumeratePhysicalDevices_CallInstance = CMock_Guts_MemChain(Mock.vkEnumeratePhysicalDevices_CallInstance, cmock_guts_index); + Mock.vkEnumeratePhysicalDevices_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkEnumeratePhysicalDevices_IgnoreBool = (char)1; +} + +void vkEnumeratePhysicalDevices_CMockStopIgnore(void) +{ + if(Mock.vkEnumeratePhysicalDevices_IgnoreBool) + Mock.vkEnumeratePhysicalDevices_CallInstance = CMock_Guts_MemNext(Mock.vkEnumeratePhysicalDevices_CallInstance); + Mock.vkEnumeratePhysicalDevices_IgnoreBool = (char)0; +} + +void vkEnumeratePhysicalDevices_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkEnumeratePhysicalDevices_CALL_INSTANCE)); + CMOCK_vkEnumeratePhysicalDevices_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDevices_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkEnumeratePhysicalDevices_CallInstance = CMock_Guts_MemChain(Mock.vkEnumeratePhysicalDevices_CallInstance, cmock_guts_index); + Mock.vkEnumeratePhysicalDevices_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkEnumeratePhysicalDevices_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkEnumeratePhysicalDevices_CALL_INSTANCE)); + CMOCK_vkEnumeratePhysicalDevices_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDevices_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkEnumeratePhysicalDevices_CallInstance = CMock_Guts_MemChain(Mock.vkEnumeratePhysicalDevices_CallInstance, cmock_guts_index); + Mock.vkEnumeratePhysicalDevices_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkEnumeratePhysicalDevices(cmock_call_instance, instance, pPhysicalDeviceCount, pPhysicalDevices); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkEnumeratePhysicalDevices_AddCallback(CMOCK_vkEnumeratePhysicalDevices_CALLBACK Callback) +{ + Mock.vkEnumeratePhysicalDevices_IgnoreBool = (char)0; + Mock.vkEnumeratePhysicalDevices_CallbackBool = (char)1; + Mock.vkEnumeratePhysicalDevices_CallbackFunctionPointer = Callback; +} + +void vkEnumeratePhysicalDevices_Stub(CMOCK_vkEnumeratePhysicalDevices_CALLBACK Callback) +{ + Mock.vkEnumeratePhysicalDevices_IgnoreBool = (char)0; + Mock.vkEnumeratePhysicalDevices_CallbackBool = (char)0; + Mock.vkEnumeratePhysicalDevices_CallbackFunctionPointer = Callback; +} + +void vkEnumeratePhysicalDevices_CMockReturnMemThruPtr_pPhysicalDeviceCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPhysicalDeviceCount, size_t cmock_size) +{ + CMOCK_vkEnumeratePhysicalDevices_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDevices_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumeratePhysicalDevices_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPhysicalDeviceCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pPhysicalDeviceCount_Val = pPhysicalDeviceCount; + cmock_call_instance->ReturnThruPtr_pPhysicalDeviceCount_Size = cmock_size; +} + +void vkEnumeratePhysicalDevices_CMockReturnMemThruPtr_pPhysicalDevices(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice const* pPhysicalDevices, size_t cmock_size) +{ + CMOCK_vkEnumeratePhysicalDevices_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDevices_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumeratePhysicalDevices_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPhysicalDevices_Used = 1; + cmock_call_instance->ReturnThruPtr_pPhysicalDevices_Val = pPhysicalDevices; + cmock_call_instance->ReturnThruPtr_pPhysicalDevices_Size = cmock_size; +} + +void vkEnumeratePhysicalDevices_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkEnumeratePhysicalDevices_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDevices_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumeratePhysicalDevices_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_instance = 1; +} + +void vkEnumeratePhysicalDevices_CMockIgnoreArg_pPhysicalDeviceCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkEnumeratePhysicalDevices_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDevices_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumeratePhysicalDevices_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPhysicalDeviceCount = 1; +} + +void vkEnumeratePhysicalDevices_CMockIgnoreArg_pPhysicalDevices(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkEnumeratePhysicalDevices_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDevices_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumeratePhysicalDevices_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPhysicalDevices = 1; +} + +void vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceFeatures_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceFeatures); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFeatures_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceFeatures_CallInstance); + Mock.vkGetPhysicalDeviceFeatures_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceFeatures_CallInstance); + if (Mock.vkGetPhysicalDeviceFeatures_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetPhysicalDeviceFeatures_CallbackBool && + Mock.vkGetPhysicalDeviceFeatures_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceFeatures_CallbackFunctionPointer(physicalDevice, pFeatures, Mock.vkGetPhysicalDeviceFeatures_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceFeatures,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pFeatures) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceFeatures,CMockString_pFeatures); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pFeatures), (void*)(pFeatures), sizeof(VkPhysicalDeviceFeatures), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceFeatures_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceFeatures_CallbackFunctionPointer(physicalDevice, pFeatures, Mock.vkGetPhysicalDeviceFeatures_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pFeatures_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pFeatures, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pFeatures, (const void*)cmock_call_instance->ReturnThruPtr_pFeatures_Val, + cmock_call_instance->ReturnThruPtr_pFeatures_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetPhysicalDeviceFeatures(CMOCK_vkGetPhysicalDeviceFeatures_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); +void CMockExpectParameters_vkGetPhysicalDeviceFeatures(CMOCK_vkGetPhysicalDeviceFeatures_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pFeatures = pFeatures; + cmock_call_instance->IgnoreArg_pFeatures = 0; + cmock_call_instance->ReturnThruPtr_pFeatures_Used = 0; +} + +void vkGetPhysicalDeviceFeatures_CMockIgnore(void) +{ + Mock.vkGetPhysicalDeviceFeatures_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceFeatures_CMockStopIgnore(void) +{ + Mock.vkGetPhysicalDeviceFeatures_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceFeatures_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceFeatures_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceFeatures_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFeatures_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceFeatures_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceFeatures_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceFeatures_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceFeatures_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceFeatures_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceFeatures_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFeatures_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceFeatures_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceFeatures_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceFeatures_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceFeatures(cmock_call_instance, physicalDevice, pFeatures); +} + +void vkGetPhysicalDeviceFeatures_AddCallback(CMOCK_vkGetPhysicalDeviceFeatures_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceFeatures_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceFeatures_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceFeatures_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceFeatures_Stub(CMOCK_vkGetPhysicalDeviceFeatures_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceFeatures_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceFeatures_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceFeatures_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceFeatures_CMockReturnMemThruPtr_pFeatures(UNITY_LINE_TYPE cmock_line, VkPhysicalDeviceFeatures const* pFeatures, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceFeatures_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFeatures_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceFeatures_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pFeatures_Used = 1; + cmock_call_instance->ReturnThruPtr_pFeatures_Val = pFeatures; + cmock_call_instance->ReturnThruPtr_pFeatures_Size = cmock_size; +} + +void vkGetPhysicalDeviceFeatures_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceFeatures_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFeatures_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceFeatures_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceFeatures_CMockIgnoreArg_pFeatures(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceFeatures_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFeatures_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceFeatures_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pFeatures = 1; +} + +void vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceFormatProperties_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceFormatProperties); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceFormatProperties_CallInstance); + Mock.vkGetPhysicalDeviceFormatProperties_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceFormatProperties_CallInstance); + if (Mock.vkGetPhysicalDeviceFormatProperties_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetPhysicalDeviceFormatProperties_CallbackBool && + Mock.vkGetPhysicalDeviceFormatProperties_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceFormatProperties_CallbackFunctionPointer(physicalDevice, format, pFormatProperties, Mock.vkGetPhysicalDeviceFormatProperties_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceFormatProperties,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_format) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceFormatProperties,CMockString_format); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_format), (void*)(&format), sizeof(VkFormat), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pFormatProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceFormatProperties,CMockString_pFormatProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pFormatProperties), (void*)(pFormatProperties), sizeof(VkFormatProperties), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceFormatProperties_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceFormatProperties_CallbackFunctionPointer(physicalDevice, format, pFormatProperties, Mock.vkGetPhysicalDeviceFormatProperties_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pFormatProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pFormatProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pFormatProperties, (const void*)cmock_call_instance->ReturnThruPtr_pFormatProperties_Val, + cmock_call_instance->ReturnThruPtr_pFormatProperties_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetPhysicalDeviceFormatProperties(CMOCK_vkGetPhysicalDeviceFormatProperties_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); +void CMockExpectParameters_vkGetPhysicalDeviceFormatProperties(CMOCK_vkGetPhysicalDeviceFormatProperties_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + memcpy((void*)(&cmock_call_instance->Expected_format), (void*)(&format), + sizeof(VkFormat[sizeof(format) == sizeof(VkFormat) ? 1 : -1])); /* add VkFormat to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_format = 0; + cmock_call_instance->Expected_pFormatProperties = pFormatProperties; + cmock_call_instance->IgnoreArg_pFormatProperties = 0; + cmock_call_instance->ReturnThruPtr_pFormatProperties_Used = 0; +} + +void vkGetPhysicalDeviceFormatProperties_CMockIgnore(void) +{ + Mock.vkGetPhysicalDeviceFormatProperties_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceFormatProperties_CMockStopIgnore(void) +{ + Mock.vkGetPhysicalDeviceFormatProperties_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceFormatProperties_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceFormatProperties_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceFormatProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceFormatProperties_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceFormatProperties_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceFormatProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceFormatProperties_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceFormatProperties_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceFormatProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceFormatProperties_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceFormatProperties_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceFormatProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceFormatProperties(cmock_call_instance, physicalDevice, format, pFormatProperties); +} + +void vkGetPhysicalDeviceFormatProperties_AddCallback(CMOCK_vkGetPhysicalDeviceFormatProperties_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceFormatProperties_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceFormatProperties_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceFormatProperties_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceFormatProperties_Stub(CMOCK_vkGetPhysicalDeviceFormatProperties_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceFormatProperties_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceFormatProperties_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceFormatProperties_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceFormatProperties_CMockReturnMemThruPtr_pFormatProperties(UNITY_LINE_TYPE cmock_line, VkFormatProperties const* pFormatProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceFormatProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceFormatProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pFormatProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pFormatProperties_Val = pFormatProperties; + cmock_call_instance->ReturnThruPtr_pFormatProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceFormatProperties_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceFormatProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceFormatProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceFormatProperties_CMockIgnoreArg_format(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceFormatProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceFormatProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_format = 1; +} + +void vkGetPhysicalDeviceFormatProperties_CMockIgnoreArg_pFormatProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceFormatProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceFormatProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pFormatProperties = 1; +} + +VkResult vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceImageFormatProperties); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceImageFormatProperties_CallInstance); + Mock.vkGetPhysicalDeviceImageFormatProperties_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceImageFormatProperties_CallInstance); + if (Mock.vkGetPhysicalDeviceImageFormatProperties_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPhysicalDeviceImageFormatProperties_FinalReturn; + memcpy((void*)(&Mock.vkGetPhysicalDeviceImageFormatProperties_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPhysicalDeviceImageFormatProperties_CallbackBool && + Mock.vkGetPhysicalDeviceImageFormatProperties_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPhysicalDeviceImageFormatProperties_CallbackFunctionPointer(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties, Mock.vkGetPhysicalDeviceImageFormatProperties_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceImageFormatProperties,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_format) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceImageFormatProperties,CMockString_format); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_format), (void*)(&format), sizeof(VkFormat), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_type) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceImageFormatProperties,CMockString_type); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_type), (void*)(&type), sizeof(VkImageType), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_tiling) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceImageFormatProperties,CMockString_tiling); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_tiling), (void*)(&tiling), sizeof(VkImageTiling), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_usage) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceImageFormatProperties,CMockString_usage); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_usage), (void*)(&usage), sizeof(VkImageUsageFlags), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_flags) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceImageFormatProperties,CMockString_flags); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_flags), (void*)(&flags), sizeof(VkImageCreateFlags), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pImageFormatProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceImageFormatProperties,CMockString_pImageFormatProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pImageFormatProperties), (void*)(pImageFormatProperties), sizeof(VkImageFormatProperties), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceImageFormatProperties_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPhysicalDeviceImageFormatProperties_CallbackFunctionPointer(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties, Mock.vkGetPhysicalDeviceImageFormatProperties_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pImageFormatProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pImageFormatProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pImageFormatProperties, (const void*)cmock_call_instance->ReturnThruPtr_pImageFormatProperties_Val, + cmock_call_instance->ReturnThruPtr_pImageFormatProperties_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPhysicalDeviceImageFormatProperties(CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); +void CMockExpectParameters_vkGetPhysicalDeviceImageFormatProperties(CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + memcpy((void*)(&cmock_call_instance->Expected_format), (void*)(&format), + sizeof(VkFormat[sizeof(format) == sizeof(VkFormat) ? 1 : -1])); /* add VkFormat to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_format = 0; + memcpy((void*)(&cmock_call_instance->Expected_type), (void*)(&type), + sizeof(VkImageType[sizeof(type) == sizeof(VkImageType) ? 1 : -1])); /* add VkImageType to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_type = 0; + memcpy((void*)(&cmock_call_instance->Expected_tiling), (void*)(&tiling), + sizeof(VkImageTiling[sizeof(tiling) == sizeof(VkImageTiling) ? 1 : -1])); /* add VkImageTiling to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_tiling = 0; + memcpy((void*)(&cmock_call_instance->Expected_usage), (void*)(&usage), + sizeof(VkImageUsageFlags[sizeof(usage) == sizeof(VkImageUsageFlags) ? 1 : -1])); /* add VkImageUsageFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_usage = 0; + memcpy((void*)(&cmock_call_instance->Expected_flags), (void*)(&flags), + sizeof(VkImageCreateFlags[sizeof(flags) == sizeof(VkImageCreateFlags) ? 1 : -1])); /* add VkImageCreateFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_flags = 0; + cmock_call_instance->Expected_pImageFormatProperties = pImageFormatProperties; + cmock_call_instance->IgnoreArg_pImageFormatProperties = 0; + cmock_call_instance->ReturnThruPtr_pImageFormatProperties_Used = 0; +} + +void vkGetPhysicalDeviceImageFormatProperties_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceImageFormatProperties_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceImageFormatProperties_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceImageFormatProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPhysicalDeviceImageFormatProperties_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceImageFormatProperties_CMockStopIgnore(void) +{ + if(Mock.vkGetPhysicalDeviceImageFormatProperties_IgnoreBool) + Mock.vkGetPhysicalDeviceImageFormatProperties_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceImageFormatProperties_CallInstance); + Mock.vkGetPhysicalDeviceImageFormatProperties_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceImageFormatProperties_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceImageFormatProperties_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceImageFormatProperties_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceImageFormatProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceImageFormatProperties_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceImageFormatProperties_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceImageFormatProperties_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceImageFormatProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceImageFormatProperties(cmock_call_instance, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPhysicalDeviceImageFormatProperties_AddCallback(CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceImageFormatProperties_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceImageFormatProperties_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceImageFormatProperties_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceImageFormatProperties_Stub(CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceImageFormatProperties_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceImageFormatProperties_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceImageFormatProperties_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceImageFormatProperties_CMockReturnMemThruPtr_pImageFormatProperties(UNITY_LINE_TYPE cmock_line, VkImageFormatProperties const* pImageFormatProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceImageFormatProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pImageFormatProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pImageFormatProperties_Val = pImageFormatProperties; + cmock_call_instance->ReturnThruPtr_pImageFormatProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceImageFormatProperties_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceImageFormatProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceImageFormatProperties_CMockIgnoreArg_format(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceImageFormatProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_format = 1; +} + +void vkGetPhysicalDeviceImageFormatProperties_CMockIgnoreArg_type(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceImageFormatProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_type = 1; +} + +void vkGetPhysicalDeviceImageFormatProperties_CMockIgnoreArg_tiling(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceImageFormatProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_tiling = 1; +} + +void vkGetPhysicalDeviceImageFormatProperties_CMockIgnoreArg_usage(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceImageFormatProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_usage = 1; +} + +void vkGetPhysicalDeviceImageFormatProperties_CMockIgnoreArg_flags(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceImageFormatProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_flags = 1; +} + +void vkGetPhysicalDeviceImageFormatProperties_CMockIgnoreArg_pImageFormatProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceImageFormatProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pImageFormatProperties = 1; +} + +void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceProperties_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceProperties); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceProperties_CallInstance); + Mock.vkGetPhysicalDeviceProperties_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceProperties_CallInstance); + if (Mock.vkGetPhysicalDeviceProperties_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetPhysicalDeviceProperties_CallbackBool && + Mock.vkGetPhysicalDeviceProperties_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceProperties_CallbackFunctionPointer(physicalDevice, pProperties, Mock.vkGetPhysicalDeviceProperties_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceProperties,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceProperties,CMockString_pProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pProperties), (void*)(pProperties), sizeof(VkPhysicalDeviceProperties), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceProperties_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceProperties_CallbackFunctionPointer(physicalDevice, pProperties, Mock.vkGetPhysicalDeviceProperties_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pProperties, (const void*)cmock_call_instance->ReturnThruPtr_pProperties_Val, + cmock_call_instance->ReturnThruPtr_pProperties_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetPhysicalDeviceProperties(CMOCK_vkGetPhysicalDeviceProperties_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); +void CMockExpectParameters_vkGetPhysicalDeviceProperties(CMOCK_vkGetPhysicalDeviceProperties_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pProperties = pProperties; + cmock_call_instance->IgnoreArg_pProperties = 0; + cmock_call_instance->ReturnThruPtr_pProperties_Used = 0; +} + +void vkGetPhysicalDeviceProperties_CMockIgnore(void) +{ + Mock.vkGetPhysicalDeviceProperties_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceProperties_CMockStopIgnore(void) +{ + Mock.vkGetPhysicalDeviceProperties_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceProperties_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceProperties_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceProperties_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceProperties_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceProperties_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceProperties_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceProperties_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceProperties_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceProperties(cmock_call_instance, physicalDevice, pProperties); +} + +void vkGetPhysicalDeviceProperties_AddCallback(CMOCK_vkGetPhysicalDeviceProperties_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceProperties_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceProperties_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceProperties_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceProperties_Stub(CMOCK_vkGetPhysicalDeviceProperties_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceProperties_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceProperties_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceProperties_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceProperties_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkPhysicalDeviceProperties const* pProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pProperties_Val = pProperties; + cmock_call_instance->ReturnThruPtr_pProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceProperties_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceProperties_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pProperties = 1; +} + +void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceQueueFamilyProperties_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceQueueFamilyProperties); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceQueueFamilyProperties_CallInstance); + Mock.vkGetPhysicalDeviceQueueFamilyProperties_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceQueueFamilyProperties_CallInstance); + if (Mock.vkGetPhysicalDeviceQueueFamilyProperties_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetPhysicalDeviceQueueFamilyProperties_CallbackBool && + Mock.vkGetPhysicalDeviceQueueFamilyProperties_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceQueueFamilyProperties_CallbackFunctionPointer(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, Mock.vkGetPhysicalDeviceQueueFamilyProperties_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceQueueFamilyProperties,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pQueueFamilyPropertyCount) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceQueueFamilyProperties,CMockString_pQueueFamilyPropertyCount); + if (cmock_call_instance->Expected_pQueueFamilyPropertyCount == NULL) + { UNITY_TEST_ASSERT_NULL(pQueueFamilyPropertyCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pQueueFamilyPropertyCount, pQueueFamilyPropertyCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pQueueFamilyProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceQueueFamilyProperties,CMockString_pQueueFamilyProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pQueueFamilyProperties), (void*)(pQueueFamilyProperties), sizeof(VkQueueFamilyProperties), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceQueueFamilyProperties_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceQueueFamilyProperties_CallbackFunctionPointer(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, Mock.vkGetPhysicalDeviceQueueFamilyProperties_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pQueueFamilyPropertyCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pQueueFamilyPropertyCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pQueueFamilyPropertyCount, (const void*)cmock_call_instance->ReturnThruPtr_pQueueFamilyPropertyCount_Val, + cmock_call_instance->ReturnThruPtr_pQueueFamilyPropertyCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pQueueFamilyProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pQueueFamilyProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pQueueFamilyProperties, (const void*)cmock_call_instance->ReturnThruPtr_pQueueFamilyProperties_Val, + cmock_call_instance->ReturnThruPtr_pQueueFamilyProperties_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetPhysicalDeviceQueueFamilyProperties(CMOCK_vkGetPhysicalDeviceQueueFamilyProperties_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties); +void CMockExpectParameters_vkGetPhysicalDeviceQueueFamilyProperties(CMOCK_vkGetPhysicalDeviceQueueFamilyProperties_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pQueueFamilyPropertyCount = pQueueFamilyPropertyCount; + cmock_call_instance->IgnoreArg_pQueueFamilyPropertyCount = 0; + cmock_call_instance->ReturnThruPtr_pQueueFamilyPropertyCount_Used = 0; + cmock_call_instance->Expected_pQueueFamilyProperties = pQueueFamilyProperties; + cmock_call_instance->IgnoreArg_pQueueFamilyProperties = 0; + cmock_call_instance->ReturnThruPtr_pQueueFamilyProperties_Used = 0; +} + +void vkGetPhysicalDeviceQueueFamilyProperties_CMockIgnore(void) +{ + Mock.vkGetPhysicalDeviceQueueFamilyProperties_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceQueueFamilyProperties_CMockStopIgnore(void) +{ + Mock.vkGetPhysicalDeviceQueueFamilyProperties_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceQueueFamilyProperties_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceQueueFamilyProperties_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceQueueFamilyProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceQueueFamilyProperties_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceQueueFamilyProperties_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceQueueFamilyProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceQueueFamilyProperties_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceQueueFamilyProperties_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceQueueFamilyProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceQueueFamilyProperties_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceQueueFamilyProperties_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceQueueFamilyProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceQueueFamilyProperties(cmock_call_instance, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); +} + +void vkGetPhysicalDeviceQueueFamilyProperties_AddCallback(CMOCK_vkGetPhysicalDeviceQueueFamilyProperties_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceQueueFamilyProperties_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceQueueFamilyProperties_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceQueueFamilyProperties_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceQueueFamilyProperties_Stub(CMOCK_vkGetPhysicalDeviceQueueFamilyProperties_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceQueueFamilyProperties_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceQueueFamilyProperties_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceQueueFamilyProperties_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceQueueFamilyProperties_CMockReturnMemThruPtr_pQueueFamilyPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pQueueFamilyPropertyCount, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceQueueFamilyProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceQueueFamilyProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pQueueFamilyPropertyCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pQueueFamilyPropertyCount_Val = pQueueFamilyPropertyCount; + cmock_call_instance->ReturnThruPtr_pQueueFamilyPropertyCount_Size = cmock_size; +} + +void vkGetPhysicalDeviceQueueFamilyProperties_CMockReturnMemThruPtr_pQueueFamilyProperties(UNITY_LINE_TYPE cmock_line, VkQueueFamilyProperties const* pQueueFamilyProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceQueueFamilyProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceQueueFamilyProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pQueueFamilyProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pQueueFamilyProperties_Val = pQueueFamilyProperties; + cmock_call_instance->ReturnThruPtr_pQueueFamilyProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceQueueFamilyProperties_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceQueueFamilyProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceQueueFamilyProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceQueueFamilyProperties_CMockIgnoreArg_pQueueFamilyPropertyCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceQueueFamilyProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceQueueFamilyProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pQueueFamilyPropertyCount = 1; +} + +void vkGetPhysicalDeviceQueueFamilyProperties_CMockIgnoreArg_pQueueFamilyProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceQueueFamilyProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceQueueFamilyProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pQueueFamilyProperties = 1; +} + +void vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceMemoryProperties_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceMemoryProperties); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceMemoryProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceMemoryProperties_CallInstance); + Mock.vkGetPhysicalDeviceMemoryProperties_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceMemoryProperties_CallInstance); + if (Mock.vkGetPhysicalDeviceMemoryProperties_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetPhysicalDeviceMemoryProperties_CallbackBool && + Mock.vkGetPhysicalDeviceMemoryProperties_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceMemoryProperties_CallbackFunctionPointer(physicalDevice, pMemoryProperties, Mock.vkGetPhysicalDeviceMemoryProperties_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceMemoryProperties,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMemoryProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceMemoryProperties,CMockString_pMemoryProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMemoryProperties), (void*)(pMemoryProperties), sizeof(VkPhysicalDeviceMemoryProperties), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceMemoryProperties_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceMemoryProperties_CallbackFunctionPointer(physicalDevice, pMemoryProperties, Mock.vkGetPhysicalDeviceMemoryProperties_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pMemoryProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pMemoryProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pMemoryProperties, (const void*)cmock_call_instance->ReturnThruPtr_pMemoryProperties_Val, + cmock_call_instance->ReturnThruPtr_pMemoryProperties_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetPhysicalDeviceMemoryProperties(CMOCK_vkGetPhysicalDeviceMemoryProperties_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); +void CMockExpectParameters_vkGetPhysicalDeviceMemoryProperties(CMOCK_vkGetPhysicalDeviceMemoryProperties_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pMemoryProperties = pMemoryProperties; + cmock_call_instance->IgnoreArg_pMemoryProperties = 0; + cmock_call_instance->ReturnThruPtr_pMemoryProperties_Used = 0; +} + +void vkGetPhysicalDeviceMemoryProperties_CMockIgnore(void) +{ + Mock.vkGetPhysicalDeviceMemoryProperties_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceMemoryProperties_CMockStopIgnore(void) +{ + Mock.vkGetPhysicalDeviceMemoryProperties_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceMemoryProperties_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceMemoryProperties_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceMemoryProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceMemoryProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceMemoryProperties_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceMemoryProperties_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceMemoryProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceMemoryProperties_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceMemoryProperties_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceMemoryProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceMemoryProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceMemoryProperties_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceMemoryProperties_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceMemoryProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceMemoryProperties(cmock_call_instance, physicalDevice, pMemoryProperties); +} + +void vkGetPhysicalDeviceMemoryProperties_AddCallback(CMOCK_vkGetPhysicalDeviceMemoryProperties_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceMemoryProperties_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceMemoryProperties_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceMemoryProperties_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceMemoryProperties_Stub(CMOCK_vkGetPhysicalDeviceMemoryProperties_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceMemoryProperties_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceMemoryProperties_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceMemoryProperties_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceMemoryProperties_CMockReturnMemThruPtr_pMemoryProperties(UNITY_LINE_TYPE cmock_line, VkPhysicalDeviceMemoryProperties const* pMemoryProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceMemoryProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceMemoryProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceMemoryProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pMemoryProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pMemoryProperties_Val = pMemoryProperties; + cmock_call_instance->ReturnThruPtr_pMemoryProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceMemoryProperties_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceMemoryProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceMemoryProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceMemoryProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceMemoryProperties_CMockIgnoreArg_pMemoryProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceMemoryProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceMemoryProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceMemoryProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMemoryProperties = 1; +} + +PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance, const char* pName) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetInstanceProcAddr_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetInstanceProcAddr); + cmock_call_instance = (CMOCK_vkGetInstanceProcAddr_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetInstanceProcAddr_CallInstance); + Mock.vkGetInstanceProcAddr_CallInstance = CMock_Guts_MemNext(Mock.vkGetInstanceProcAddr_CallInstance); + if (Mock.vkGetInstanceProcAddr_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetInstanceProcAddr_FinalReturn; + memcpy((void*)(&Mock.vkGetInstanceProcAddr_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(PFN_vkVoidFunction[sizeof(cmock_call_instance->ReturnVal) == sizeof(PFN_vkVoidFunction) ? 1 : -1])); /* add PFN_vkVoidFunction to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetInstanceProcAddr_CallbackBool && + Mock.vkGetInstanceProcAddr_CallbackFunctionPointer != NULL) + { + PFN_vkVoidFunction cmock_cb_ret = Mock.vkGetInstanceProcAddr_CallbackFunctionPointer(instance, pName, Mock.vkGetInstanceProcAddr_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_instance) + { + UNITY_SET_DETAILS(CMockString_vkGetInstanceProcAddr,CMockString_instance); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), sizeof(VkInstance), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pName) + { + UNITY_SET_DETAILS(CMockString_vkGetInstanceProcAddr,CMockString_pName); + UNITY_TEST_ASSERT_EQUAL_STRING(cmock_call_instance->Expected_pName, pName, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetInstanceProcAddr_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetInstanceProcAddr_CallbackFunctionPointer(instance, pName, Mock.vkGetInstanceProcAddr_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetInstanceProcAddr(CMOCK_vkGetInstanceProcAddr_CALL_INSTANCE* cmock_call_instance, VkInstance instance, const char* pName); +void CMockExpectParameters_vkGetInstanceProcAddr(CMOCK_vkGetInstanceProcAddr_CALL_INSTANCE* cmock_call_instance, VkInstance instance, const char* pName) +{ + memcpy((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), + sizeof(VkInstance[sizeof(instance) == sizeof(VkInstance) ? 1 : -1])); /* add VkInstance to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_instance = 0; + cmock_call_instance->Expected_pName = pName; + cmock_call_instance->IgnoreArg_pName = 0; +} + +void vkGetInstanceProcAddr_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, PFN_vkVoidFunction cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetInstanceProcAddr_CALL_INSTANCE)); + CMOCK_vkGetInstanceProcAddr_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetInstanceProcAddr_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetInstanceProcAddr_CallInstance = CMock_Guts_MemChain(Mock.vkGetInstanceProcAddr_CallInstance, cmock_guts_index); + Mock.vkGetInstanceProcAddr_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetInstanceProcAddr_IgnoreBool = (char)1; +} + +void vkGetInstanceProcAddr_CMockStopIgnore(void) +{ + if(Mock.vkGetInstanceProcAddr_IgnoreBool) + Mock.vkGetInstanceProcAddr_CallInstance = CMock_Guts_MemNext(Mock.vkGetInstanceProcAddr_CallInstance); + Mock.vkGetInstanceProcAddr_IgnoreBool = (char)0; +} + +void vkGetInstanceProcAddr_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, PFN_vkVoidFunction cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetInstanceProcAddr_CALL_INSTANCE)); + CMOCK_vkGetInstanceProcAddr_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetInstanceProcAddr_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetInstanceProcAddr_CallInstance = CMock_Guts_MemChain(Mock.vkGetInstanceProcAddr_CallInstance, cmock_guts_index); + Mock.vkGetInstanceProcAddr_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetInstanceProcAddr_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkInstance instance, const char* pName, PFN_vkVoidFunction cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetInstanceProcAddr_CALL_INSTANCE)); + CMOCK_vkGetInstanceProcAddr_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetInstanceProcAddr_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetInstanceProcAddr_CallInstance = CMock_Guts_MemChain(Mock.vkGetInstanceProcAddr_CallInstance, cmock_guts_index); + Mock.vkGetInstanceProcAddr_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetInstanceProcAddr(cmock_call_instance, instance, pName); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(PFN_vkVoidFunction[sizeof(cmock_to_return) == sizeof(PFN_vkVoidFunction) ? 1 : -1])); /* add PFN_vkVoidFunction to :treat_as_array if this causes an error */ +} + +void vkGetInstanceProcAddr_AddCallback(CMOCK_vkGetInstanceProcAddr_CALLBACK Callback) +{ + Mock.vkGetInstanceProcAddr_IgnoreBool = (char)0; + Mock.vkGetInstanceProcAddr_CallbackBool = (char)1; + Mock.vkGetInstanceProcAddr_CallbackFunctionPointer = Callback; +} + +void vkGetInstanceProcAddr_Stub(CMOCK_vkGetInstanceProcAddr_CALLBACK Callback) +{ + Mock.vkGetInstanceProcAddr_IgnoreBool = (char)0; + Mock.vkGetInstanceProcAddr_CallbackBool = (char)0; + Mock.vkGetInstanceProcAddr_CallbackFunctionPointer = Callback; +} + +void vkGetInstanceProcAddr_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetInstanceProcAddr_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetInstanceProcAddr_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetInstanceProcAddr_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_instance = 1; +} + +void vkGetInstanceProcAddr_CMockIgnoreArg_pName(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetInstanceProcAddr_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetInstanceProcAddr_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetInstanceProcAddr_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pName = 1; +} + +PFN_vkVoidFunction vkGetDeviceProcAddr(VkDevice device, const char* pName) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDeviceProcAddr_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDeviceProcAddr); + cmock_call_instance = (CMOCK_vkGetDeviceProcAddr_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDeviceProcAddr_CallInstance); + Mock.vkGetDeviceProcAddr_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeviceProcAddr_CallInstance); + if (Mock.vkGetDeviceProcAddr_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetDeviceProcAddr_FinalReturn; + memcpy((void*)(&Mock.vkGetDeviceProcAddr_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(PFN_vkVoidFunction[sizeof(cmock_call_instance->ReturnVal) == sizeof(PFN_vkVoidFunction) ? 1 : -1])); /* add PFN_vkVoidFunction to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetDeviceProcAddr_CallbackBool && + Mock.vkGetDeviceProcAddr_CallbackFunctionPointer != NULL) + { + PFN_vkVoidFunction cmock_cb_ret = Mock.vkGetDeviceProcAddr_CallbackFunctionPointer(device, pName, Mock.vkGetDeviceProcAddr_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceProcAddr,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pName) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceProcAddr,CMockString_pName); + UNITY_TEST_ASSERT_EQUAL_STRING(cmock_call_instance->Expected_pName, pName, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDeviceProcAddr_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetDeviceProcAddr_CallbackFunctionPointer(device, pName, Mock.vkGetDeviceProcAddr_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetDeviceProcAddr(CMOCK_vkGetDeviceProcAddr_CALL_INSTANCE* cmock_call_instance, VkDevice device, const char* pName); +void CMockExpectParameters_vkGetDeviceProcAddr(CMOCK_vkGetDeviceProcAddr_CALL_INSTANCE* cmock_call_instance, VkDevice device, const char* pName) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pName = pName; + cmock_call_instance->IgnoreArg_pName = 0; +} + +void vkGetDeviceProcAddr_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, PFN_vkVoidFunction cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceProcAddr_CALL_INSTANCE)); + CMOCK_vkGetDeviceProcAddr_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceProcAddr_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceProcAddr_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceProcAddr_CallInstance, cmock_guts_index); + Mock.vkGetDeviceProcAddr_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetDeviceProcAddr_IgnoreBool = (char)1; +} + +void vkGetDeviceProcAddr_CMockStopIgnore(void) +{ + if(Mock.vkGetDeviceProcAddr_IgnoreBool) + Mock.vkGetDeviceProcAddr_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeviceProcAddr_CallInstance); + Mock.vkGetDeviceProcAddr_IgnoreBool = (char)0; +} + +void vkGetDeviceProcAddr_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, PFN_vkVoidFunction cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceProcAddr_CALL_INSTANCE)); + CMOCK_vkGetDeviceProcAddr_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceProcAddr_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceProcAddr_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceProcAddr_CallInstance, cmock_guts_index); + Mock.vkGetDeviceProcAddr_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDeviceProcAddr_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const char* pName, PFN_vkVoidFunction cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceProcAddr_CALL_INSTANCE)); + CMOCK_vkGetDeviceProcAddr_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceProcAddr_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceProcAddr_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceProcAddr_CallInstance, cmock_guts_index); + Mock.vkGetDeviceProcAddr_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDeviceProcAddr(cmock_call_instance, device, pName); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(PFN_vkVoidFunction[sizeof(cmock_to_return) == sizeof(PFN_vkVoidFunction) ? 1 : -1])); /* add PFN_vkVoidFunction to :treat_as_array if this causes an error */ +} + +void vkGetDeviceProcAddr_AddCallback(CMOCK_vkGetDeviceProcAddr_CALLBACK Callback) +{ + Mock.vkGetDeviceProcAddr_IgnoreBool = (char)0; + Mock.vkGetDeviceProcAddr_CallbackBool = (char)1; + Mock.vkGetDeviceProcAddr_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceProcAddr_Stub(CMOCK_vkGetDeviceProcAddr_CALLBACK Callback) +{ + Mock.vkGetDeviceProcAddr_IgnoreBool = (char)0; + Mock.vkGetDeviceProcAddr_CallbackBool = (char)0; + Mock.vkGetDeviceProcAddr_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceProcAddr_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceProcAddr_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceProcAddr_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceProcAddr_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetDeviceProcAddr_CMockIgnoreArg_pName(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceProcAddr_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceProcAddr_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceProcAddr_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pName = 1; +} + +VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateDevice_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateDevice); + cmock_call_instance = (CMOCK_vkCreateDevice_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateDevice_CallInstance); + Mock.vkCreateDevice_CallInstance = CMock_Guts_MemNext(Mock.vkCreateDevice_CallInstance); + if (Mock.vkCreateDevice_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateDevice_FinalReturn; + memcpy((void*)(&Mock.vkCreateDevice_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateDevice_CallbackBool && + Mock.vkCreateDevice_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateDevice_CallbackFunctionPointer(physicalDevice, pCreateInfo, pAllocator, pDevice, Mock.vkCreateDevice_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkCreateDevice,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateDevice,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkDeviceCreateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateDevice,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDevice) + { + UNITY_SET_DETAILS(CMockString_vkCreateDevice,CMockString_pDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDevice), (void*)(pDevice), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateDevice_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateDevice_CallbackFunctionPointer(physicalDevice, pCreateInfo, pAllocator, pDevice, Mock.vkCreateDevice_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pDevice_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pDevice, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pDevice, (const void*)cmock_call_instance->ReturnThruPtr_pDevice_Val, + cmock_call_instance->ReturnThruPtr_pDevice_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateDevice(CMOCK_vkCreateDevice_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); +void CMockExpectParameters_vkCreateDevice(CMOCK_vkCreateDevice_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pDevice = pDevice; + cmock_call_instance->IgnoreArg_pDevice = 0; + cmock_call_instance->ReturnThruPtr_pDevice_Used = 0; +} + +void vkCreateDevice_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateDevice_CALL_INSTANCE)); + CMOCK_vkCreateDevice_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDevice_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateDevice_CallInstance = CMock_Guts_MemChain(Mock.vkCreateDevice_CallInstance, cmock_guts_index); + Mock.vkCreateDevice_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateDevice_IgnoreBool = (char)1; +} + +void vkCreateDevice_CMockStopIgnore(void) +{ + if(Mock.vkCreateDevice_IgnoreBool) + Mock.vkCreateDevice_CallInstance = CMock_Guts_MemNext(Mock.vkCreateDevice_CallInstance); + Mock.vkCreateDevice_IgnoreBool = (char)0; +} + +void vkCreateDevice_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateDevice_CALL_INSTANCE)); + CMOCK_vkCreateDevice_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDevice_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateDevice_CallInstance = CMock_Guts_MemChain(Mock.vkCreateDevice_CallInstance, cmock_guts_index); + Mock.vkCreateDevice_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateDevice_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateDevice_CALL_INSTANCE)); + CMOCK_vkCreateDevice_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDevice_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateDevice_CallInstance = CMock_Guts_MemChain(Mock.vkCreateDevice_CallInstance, cmock_guts_index); + Mock.vkCreateDevice_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateDevice(cmock_call_instance, physicalDevice, pCreateInfo, pAllocator, pDevice); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateDevice_AddCallback(CMOCK_vkCreateDevice_CALLBACK Callback) +{ + Mock.vkCreateDevice_IgnoreBool = (char)0; + Mock.vkCreateDevice_CallbackBool = (char)1; + Mock.vkCreateDevice_CallbackFunctionPointer = Callback; +} + +void vkCreateDevice_Stub(CMOCK_vkCreateDevice_CALLBACK Callback) +{ + Mock.vkCreateDevice_IgnoreBool = (char)0; + Mock.vkCreateDevice_CallbackBool = (char)0; + Mock.vkCreateDevice_CallbackFunctionPointer = Callback; +} + +void vkCreateDevice_CMockReturnMemThruPtr_pDevice(UNITY_LINE_TYPE cmock_line, VkDevice const* pDevice, size_t cmock_size) +{ + CMOCK_vkCreateDevice_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDevice_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDevice_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pDevice_Used = 1; + cmock_call_instance->ReturnThruPtr_pDevice_Val = pDevice; + cmock_call_instance->ReturnThruPtr_pDevice_Size = cmock_size; +} + +void vkCreateDevice_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDevice_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDevice_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDevice_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkCreateDevice_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDevice_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDevice_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDevice_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateDevice_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDevice_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDevice_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDevice_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateDevice_CMockIgnoreArg_pDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDevice_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDevice_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDevice_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDevice = 1; +} + +void vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyDevice_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyDevice); + cmock_call_instance = (CMOCK_vkDestroyDevice_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyDevice_CallInstance); + Mock.vkDestroyDevice_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyDevice_CallInstance); + if (Mock.vkDestroyDevice_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyDevice_CallbackBool && + Mock.vkDestroyDevice_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyDevice_CallbackFunctionPointer(device, pAllocator, Mock.vkDestroyDevice_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyDevice,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyDevice,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyDevice_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyDevice_CallbackFunctionPointer(device, pAllocator, Mock.vkDestroyDevice_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyDevice(CMOCK_vkDestroyDevice_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyDevice(CMOCK_vkDestroyDevice_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyDevice_CMockIgnore(void) +{ + Mock.vkDestroyDevice_IgnoreBool = (char)1; +} + +void vkDestroyDevice_CMockStopIgnore(void) +{ + Mock.vkDestroyDevice_IgnoreBool = (char)0; +} + +void vkDestroyDevice_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyDevice_CALL_INSTANCE)); + CMOCK_vkDestroyDevice_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDevice_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyDevice_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyDevice_CallInstance, cmock_guts_index); + Mock.vkDestroyDevice_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyDevice_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyDevice_CALL_INSTANCE)); + CMOCK_vkDestroyDevice_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDevice_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyDevice_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyDevice_CallInstance, cmock_guts_index); + Mock.vkDestroyDevice_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyDevice(cmock_call_instance, device, pAllocator); +} + +void vkDestroyDevice_AddCallback(CMOCK_vkDestroyDevice_CALLBACK Callback) +{ + Mock.vkDestroyDevice_IgnoreBool = (char)0; + Mock.vkDestroyDevice_CallbackBool = (char)1; + Mock.vkDestroyDevice_CallbackFunctionPointer = Callback; +} + +void vkDestroyDevice_Stub(CMOCK_vkDestroyDevice_CALLBACK Callback) +{ + Mock.vkDestroyDevice_IgnoreBool = (char)0; + Mock.vkDestroyDevice_CallbackBool = (char)0; + Mock.vkDestroyDevice_CallbackFunctionPointer = Callback; +} + +void vkDestroyDevice_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyDevice_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDevice_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyDevice_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyDevice_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyDevice_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDevice_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyDevice_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +VkResult vkEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkEnumerateInstanceExtensionProperties_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkEnumerateInstanceExtensionProperties); + cmock_call_instance = (CMOCK_vkEnumerateInstanceExtensionProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkEnumerateInstanceExtensionProperties_CallInstance); + Mock.vkEnumerateInstanceExtensionProperties_CallInstance = CMock_Guts_MemNext(Mock.vkEnumerateInstanceExtensionProperties_CallInstance); + if (Mock.vkEnumerateInstanceExtensionProperties_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkEnumerateInstanceExtensionProperties_FinalReturn; + memcpy((void*)(&Mock.vkEnumerateInstanceExtensionProperties_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkEnumerateInstanceExtensionProperties_CallbackBool && + Mock.vkEnumerateInstanceExtensionProperties_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkEnumerateInstanceExtensionProperties_CallbackFunctionPointer(pLayerName, pPropertyCount, pProperties, Mock.vkEnumerateInstanceExtensionProperties_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_pLayerName) + { + UNITY_SET_DETAILS(CMockString_vkEnumerateInstanceExtensionProperties,CMockString_pLayerName); + UNITY_TEST_ASSERT_EQUAL_STRING(cmock_call_instance->Expected_pLayerName, pLayerName, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPropertyCount) + { + UNITY_SET_DETAILS(CMockString_vkEnumerateInstanceExtensionProperties,CMockString_pPropertyCount); + if (cmock_call_instance->Expected_pPropertyCount == NULL) + { UNITY_TEST_ASSERT_NULL(pPropertyCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pPropertyCount, pPropertyCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pProperties) + { + UNITY_SET_DETAILS(CMockString_vkEnumerateInstanceExtensionProperties,CMockString_pProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pProperties), (void*)(pProperties), sizeof(VkExtensionProperties), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkEnumerateInstanceExtensionProperties_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkEnumerateInstanceExtensionProperties_CallbackFunctionPointer(pLayerName, pPropertyCount, pProperties, Mock.vkEnumerateInstanceExtensionProperties_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPropertyCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPropertyCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPropertyCount, (const void*)cmock_call_instance->ReturnThruPtr_pPropertyCount_Val, + cmock_call_instance->ReturnThruPtr_pPropertyCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pProperties, (const void*)cmock_call_instance->ReturnThruPtr_pProperties_Val, + cmock_call_instance->ReturnThruPtr_pProperties_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkEnumerateInstanceExtensionProperties(CMOCK_vkEnumerateInstanceExtensionProperties_CALL_INSTANCE* cmock_call_instance, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); +void CMockExpectParameters_vkEnumerateInstanceExtensionProperties(CMOCK_vkEnumerateInstanceExtensionProperties_CALL_INSTANCE* cmock_call_instance, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) +{ + cmock_call_instance->Expected_pLayerName = pLayerName; + cmock_call_instance->IgnoreArg_pLayerName = 0; + cmock_call_instance->Expected_pPropertyCount = pPropertyCount; + cmock_call_instance->IgnoreArg_pPropertyCount = 0; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Used = 0; + cmock_call_instance->Expected_pProperties = pProperties; + cmock_call_instance->IgnoreArg_pProperties = 0; + cmock_call_instance->ReturnThruPtr_pProperties_Used = 0; +} + +void vkEnumerateInstanceExtensionProperties_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkEnumerateInstanceExtensionProperties_CALL_INSTANCE)); + CMOCK_vkEnumerateInstanceExtensionProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateInstanceExtensionProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkEnumerateInstanceExtensionProperties_CallInstance = CMock_Guts_MemChain(Mock.vkEnumerateInstanceExtensionProperties_CallInstance, cmock_guts_index); + Mock.vkEnumerateInstanceExtensionProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkEnumerateInstanceExtensionProperties_IgnoreBool = (char)1; +} + +void vkEnumerateInstanceExtensionProperties_CMockStopIgnore(void) +{ + if(Mock.vkEnumerateInstanceExtensionProperties_IgnoreBool) + Mock.vkEnumerateInstanceExtensionProperties_CallInstance = CMock_Guts_MemNext(Mock.vkEnumerateInstanceExtensionProperties_CallInstance); + Mock.vkEnumerateInstanceExtensionProperties_IgnoreBool = (char)0; +} + +void vkEnumerateInstanceExtensionProperties_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkEnumerateInstanceExtensionProperties_CALL_INSTANCE)); + CMOCK_vkEnumerateInstanceExtensionProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateInstanceExtensionProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkEnumerateInstanceExtensionProperties_CallInstance = CMock_Guts_MemChain(Mock.vkEnumerateInstanceExtensionProperties_CallInstance, cmock_guts_index); + Mock.vkEnumerateInstanceExtensionProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkEnumerateInstanceExtensionProperties_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkEnumerateInstanceExtensionProperties_CALL_INSTANCE)); + CMOCK_vkEnumerateInstanceExtensionProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateInstanceExtensionProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkEnumerateInstanceExtensionProperties_CallInstance = CMock_Guts_MemChain(Mock.vkEnumerateInstanceExtensionProperties_CallInstance, cmock_guts_index); + Mock.vkEnumerateInstanceExtensionProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkEnumerateInstanceExtensionProperties(cmock_call_instance, pLayerName, pPropertyCount, pProperties); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkEnumerateInstanceExtensionProperties_AddCallback(CMOCK_vkEnumerateInstanceExtensionProperties_CALLBACK Callback) +{ + Mock.vkEnumerateInstanceExtensionProperties_IgnoreBool = (char)0; + Mock.vkEnumerateInstanceExtensionProperties_CallbackBool = (char)1; + Mock.vkEnumerateInstanceExtensionProperties_CallbackFunctionPointer = Callback; +} + +void vkEnumerateInstanceExtensionProperties_Stub(CMOCK_vkEnumerateInstanceExtensionProperties_CALLBACK Callback) +{ + Mock.vkEnumerateInstanceExtensionProperties_IgnoreBool = (char)0; + Mock.vkEnumerateInstanceExtensionProperties_CallbackBool = (char)0; + Mock.vkEnumerateInstanceExtensionProperties_CallbackFunctionPointer = Callback; +} + +void vkEnumerateInstanceExtensionProperties_CMockReturnMemThruPtr_pPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPropertyCount, size_t cmock_size) +{ + CMOCK_vkEnumerateInstanceExtensionProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateInstanceExtensionProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumerateInstanceExtensionProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPropertyCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Val = pPropertyCount; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Size = cmock_size; +} + +void vkEnumerateInstanceExtensionProperties_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkExtensionProperties const* pProperties, size_t cmock_size) +{ + CMOCK_vkEnumerateInstanceExtensionProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateInstanceExtensionProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumerateInstanceExtensionProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pProperties_Val = pProperties; + cmock_call_instance->ReturnThruPtr_pProperties_Size = cmock_size; +} + +void vkEnumerateInstanceExtensionProperties_CMockIgnoreArg_pLayerName(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkEnumerateInstanceExtensionProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateInstanceExtensionProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumerateInstanceExtensionProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pLayerName = 1; +} + +void vkEnumerateInstanceExtensionProperties_CMockIgnoreArg_pPropertyCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkEnumerateInstanceExtensionProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateInstanceExtensionProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumerateInstanceExtensionProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPropertyCount = 1; +} + +void vkEnumerateInstanceExtensionProperties_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkEnumerateInstanceExtensionProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateInstanceExtensionProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumerateInstanceExtensionProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pProperties = 1; +} + +VkResult vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkEnumerateDeviceExtensionProperties_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkEnumerateDeviceExtensionProperties); + cmock_call_instance = (CMOCK_vkEnumerateDeviceExtensionProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkEnumerateDeviceExtensionProperties_CallInstance); + Mock.vkEnumerateDeviceExtensionProperties_CallInstance = CMock_Guts_MemNext(Mock.vkEnumerateDeviceExtensionProperties_CallInstance); + if (Mock.vkEnumerateDeviceExtensionProperties_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkEnumerateDeviceExtensionProperties_FinalReturn; + memcpy((void*)(&Mock.vkEnumerateDeviceExtensionProperties_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkEnumerateDeviceExtensionProperties_CallbackBool && + Mock.vkEnumerateDeviceExtensionProperties_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkEnumerateDeviceExtensionProperties_CallbackFunctionPointer(physicalDevice, pLayerName, pPropertyCount, pProperties, Mock.vkEnumerateDeviceExtensionProperties_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkEnumerateDeviceExtensionProperties,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pLayerName) + { + UNITY_SET_DETAILS(CMockString_vkEnumerateDeviceExtensionProperties,CMockString_pLayerName); + UNITY_TEST_ASSERT_EQUAL_STRING(cmock_call_instance->Expected_pLayerName, pLayerName, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPropertyCount) + { + UNITY_SET_DETAILS(CMockString_vkEnumerateDeviceExtensionProperties,CMockString_pPropertyCount); + if (cmock_call_instance->Expected_pPropertyCount == NULL) + { UNITY_TEST_ASSERT_NULL(pPropertyCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pPropertyCount, pPropertyCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pProperties) + { + UNITY_SET_DETAILS(CMockString_vkEnumerateDeviceExtensionProperties,CMockString_pProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pProperties), (void*)(pProperties), sizeof(VkExtensionProperties), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkEnumerateDeviceExtensionProperties_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkEnumerateDeviceExtensionProperties_CallbackFunctionPointer(physicalDevice, pLayerName, pPropertyCount, pProperties, Mock.vkEnumerateDeviceExtensionProperties_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPropertyCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPropertyCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPropertyCount, (const void*)cmock_call_instance->ReturnThruPtr_pPropertyCount_Val, + cmock_call_instance->ReturnThruPtr_pPropertyCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pProperties, (const void*)cmock_call_instance->ReturnThruPtr_pProperties_Val, + cmock_call_instance->ReturnThruPtr_pProperties_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkEnumerateDeviceExtensionProperties(CMOCK_vkEnumerateDeviceExtensionProperties_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); +void CMockExpectParameters_vkEnumerateDeviceExtensionProperties(CMOCK_vkEnumerateDeviceExtensionProperties_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pLayerName = pLayerName; + cmock_call_instance->IgnoreArg_pLayerName = 0; + cmock_call_instance->Expected_pPropertyCount = pPropertyCount; + cmock_call_instance->IgnoreArg_pPropertyCount = 0; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Used = 0; + cmock_call_instance->Expected_pProperties = pProperties; + cmock_call_instance->IgnoreArg_pProperties = 0; + cmock_call_instance->ReturnThruPtr_pProperties_Used = 0; +} + +void vkEnumerateDeviceExtensionProperties_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkEnumerateDeviceExtensionProperties_CALL_INSTANCE)); + CMOCK_vkEnumerateDeviceExtensionProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateDeviceExtensionProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkEnumerateDeviceExtensionProperties_CallInstance = CMock_Guts_MemChain(Mock.vkEnumerateDeviceExtensionProperties_CallInstance, cmock_guts_index); + Mock.vkEnumerateDeviceExtensionProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkEnumerateDeviceExtensionProperties_IgnoreBool = (char)1; +} + +void vkEnumerateDeviceExtensionProperties_CMockStopIgnore(void) +{ + if(Mock.vkEnumerateDeviceExtensionProperties_IgnoreBool) + Mock.vkEnumerateDeviceExtensionProperties_CallInstance = CMock_Guts_MemNext(Mock.vkEnumerateDeviceExtensionProperties_CallInstance); + Mock.vkEnumerateDeviceExtensionProperties_IgnoreBool = (char)0; +} + +void vkEnumerateDeviceExtensionProperties_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkEnumerateDeviceExtensionProperties_CALL_INSTANCE)); + CMOCK_vkEnumerateDeviceExtensionProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateDeviceExtensionProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkEnumerateDeviceExtensionProperties_CallInstance = CMock_Guts_MemChain(Mock.vkEnumerateDeviceExtensionProperties_CallInstance, cmock_guts_index); + Mock.vkEnumerateDeviceExtensionProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkEnumerateDeviceExtensionProperties_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkEnumerateDeviceExtensionProperties_CALL_INSTANCE)); + CMOCK_vkEnumerateDeviceExtensionProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateDeviceExtensionProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkEnumerateDeviceExtensionProperties_CallInstance = CMock_Guts_MemChain(Mock.vkEnumerateDeviceExtensionProperties_CallInstance, cmock_guts_index); + Mock.vkEnumerateDeviceExtensionProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkEnumerateDeviceExtensionProperties(cmock_call_instance, physicalDevice, pLayerName, pPropertyCount, pProperties); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkEnumerateDeviceExtensionProperties_AddCallback(CMOCK_vkEnumerateDeviceExtensionProperties_CALLBACK Callback) +{ + Mock.vkEnumerateDeviceExtensionProperties_IgnoreBool = (char)0; + Mock.vkEnumerateDeviceExtensionProperties_CallbackBool = (char)1; + Mock.vkEnumerateDeviceExtensionProperties_CallbackFunctionPointer = Callback; +} + +void vkEnumerateDeviceExtensionProperties_Stub(CMOCK_vkEnumerateDeviceExtensionProperties_CALLBACK Callback) +{ + Mock.vkEnumerateDeviceExtensionProperties_IgnoreBool = (char)0; + Mock.vkEnumerateDeviceExtensionProperties_CallbackBool = (char)0; + Mock.vkEnumerateDeviceExtensionProperties_CallbackFunctionPointer = Callback; +} + +void vkEnumerateDeviceExtensionProperties_CMockReturnMemThruPtr_pPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPropertyCount, size_t cmock_size) +{ + CMOCK_vkEnumerateDeviceExtensionProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateDeviceExtensionProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumerateDeviceExtensionProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPropertyCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Val = pPropertyCount; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Size = cmock_size; +} + +void vkEnumerateDeviceExtensionProperties_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkExtensionProperties const* pProperties, size_t cmock_size) +{ + CMOCK_vkEnumerateDeviceExtensionProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateDeviceExtensionProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumerateDeviceExtensionProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pProperties_Val = pProperties; + cmock_call_instance->ReturnThruPtr_pProperties_Size = cmock_size; +} + +void vkEnumerateDeviceExtensionProperties_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkEnumerateDeviceExtensionProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateDeviceExtensionProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumerateDeviceExtensionProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkEnumerateDeviceExtensionProperties_CMockIgnoreArg_pLayerName(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkEnumerateDeviceExtensionProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateDeviceExtensionProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumerateDeviceExtensionProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pLayerName = 1; +} + +void vkEnumerateDeviceExtensionProperties_CMockIgnoreArg_pPropertyCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkEnumerateDeviceExtensionProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateDeviceExtensionProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumerateDeviceExtensionProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPropertyCount = 1; +} + +void vkEnumerateDeviceExtensionProperties_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkEnumerateDeviceExtensionProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateDeviceExtensionProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumerateDeviceExtensionProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pProperties = 1; +} + +VkResult vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkEnumerateInstanceLayerProperties_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkEnumerateInstanceLayerProperties); + cmock_call_instance = (CMOCK_vkEnumerateInstanceLayerProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkEnumerateInstanceLayerProperties_CallInstance); + Mock.vkEnumerateInstanceLayerProperties_CallInstance = CMock_Guts_MemNext(Mock.vkEnumerateInstanceLayerProperties_CallInstance); + if (Mock.vkEnumerateInstanceLayerProperties_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkEnumerateInstanceLayerProperties_FinalReturn; + memcpy((void*)(&Mock.vkEnumerateInstanceLayerProperties_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkEnumerateInstanceLayerProperties_CallbackBool && + Mock.vkEnumerateInstanceLayerProperties_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkEnumerateInstanceLayerProperties_CallbackFunctionPointer(pPropertyCount, pProperties, Mock.vkEnumerateInstanceLayerProperties_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_pPropertyCount) + { + UNITY_SET_DETAILS(CMockString_vkEnumerateInstanceLayerProperties,CMockString_pPropertyCount); + if (cmock_call_instance->Expected_pPropertyCount == NULL) + { UNITY_TEST_ASSERT_NULL(pPropertyCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pPropertyCount, pPropertyCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pProperties) + { + UNITY_SET_DETAILS(CMockString_vkEnumerateInstanceLayerProperties,CMockString_pProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pProperties), (void*)(pProperties), sizeof(VkLayerProperties), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkEnumerateInstanceLayerProperties_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkEnumerateInstanceLayerProperties_CallbackFunctionPointer(pPropertyCount, pProperties, Mock.vkEnumerateInstanceLayerProperties_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPropertyCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPropertyCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPropertyCount, (const void*)cmock_call_instance->ReturnThruPtr_pPropertyCount_Val, + cmock_call_instance->ReturnThruPtr_pPropertyCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pProperties, (const void*)cmock_call_instance->ReturnThruPtr_pProperties_Val, + cmock_call_instance->ReturnThruPtr_pProperties_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkEnumerateInstanceLayerProperties(CMOCK_vkEnumerateInstanceLayerProperties_CALL_INSTANCE* cmock_call_instance, uint32_t* pPropertyCount, VkLayerProperties* pProperties); +void CMockExpectParameters_vkEnumerateInstanceLayerProperties(CMOCK_vkEnumerateInstanceLayerProperties_CALL_INSTANCE* cmock_call_instance, uint32_t* pPropertyCount, VkLayerProperties* pProperties) +{ + cmock_call_instance->Expected_pPropertyCount = pPropertyCount; + cmock_call_instance->IgnoreArg_pPropertyCount = 0; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Used = 0; + cmock_call_instance->Expected_pProperties = pProperties; + cmock_call_instance->IgnoreArg_pProperties = 0; + cmock_call_instance->ReturnThruPtr_pProperties_Used = 0; +} + +void vkEnumerateInstanceLayerProperties_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkEnumerateInstanceLayerProperties_CALL_INSTANCE)); + CMOCK_vkEnumerateInstanceLayerProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateInstanceLayerProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkEnumerateInstanceLayerProperties_CallInstance = CMock_Guts_MemChain(Mock.vkEnumerateInstanceLayerProperties_CallInstance, cmock_guts_index); + Mock.vkEnumerateInstanceLayerProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkEnumerateInstanceLayerProperties_IgnoreBool = (char)1; +} + +void vkEnumerateInstanceLayerProperties_CMockStopIgnore(void) +{ + if(Mock.vkEnumerateInstanceLayerProperties_IgnoreBool) + Mock.vkEnumerateInstanceLayerProperties_CallInstance = CMock_Guts_MemNext(Mock.vkEnumerateInstanceLayerProperties_CallInstance); + Mock.vkEnumerateInstanceLayerProperties_IgnoreBool = (char)0; +} + +void vkEnumerateInstanceLayerProperties_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkEnumerateInstanceLayerProperties_CALL_INSTANCE)); + CMOCK_vkEnumerateInstanceLayerProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateInstanceLayerProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkEnumerateInstanceLayerProperties_CallInstance = CMock_Guts_MemChain(Mock.vkEnumerateInstanceLayerProperties_CallInstance, cmock_guts_index); + Mock.vkEnumerateInstanceLayerProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkEnumerateInstanceLayerProperties_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, uint32_t* pPropertyCount, VkLayerProperties* pProperties, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkEnumerateInstanceLayerProperties_CALL_INSTANCE)); + CMOCK_vkEnumerateInstanceLayerProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateInstanceLayerProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkEnumerateInstanceLayerProperties_CallInstance = CMock_Guts_MemChain(Mock.vkEnumerateInstanceLayerProperties_CallInstance, cmock_guts_index); + Mock.vkEnumerateInstanceLayerProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkEnumerateInstanceLayerProperties(cmock_call_instance, pPropertyCount, pProperties); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkEnumerateInstanceLayerProperties_AddCallback(CMOCK_vkEnumerateInstanceLayerProperties_CALLBACK Callback) +{ + Mock.vkEnumerateInstanceLayerProperties_IgnoreBool = (char)0; + Mock.vkEnumerateInstanceLayerProperties_CallbackBool = (char)1; + Mock.vkEnumerateInstanceLayerProperties_CallbackFunctionPointer = Callback; +} + +void vkEnumerateInstanceLayerProperties_Stub(CMOCK_vkEnumerateInstanceLayerProperties_CALLBACK Callback) +{ + Mock.vkEnumerateInstanceLayerProperties_IgnoreBool = (char)0; + Mock.vkEnumerateInstanceLayerProperties_CallbackBool = (char)0; + Mock.vkEnumerateInstanceLayerProperties_CallbackFunctionPointer = Callback; +} + +void vkEnumerateInstanceLayerProperties_CMockReturnMemThruPtr_pPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPropertyCount, size_t cmock_size) +{ + CMOCK_vkEnumerateInstanceLayerProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateInstanceLayerProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumerateInstanceLayerProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPropertyCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Val = pPropertyCount; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Size = cmock_size; +} + +void vkEnumerateInstanceLayerProperties_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkLayerProperties const* pProperties, size_t cmock_size) +{ + CMOCK_vkEnumerateInstanceLayerProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateInstanceLayerProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumerateInstanceLayerProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pProperties_Val = pProperties; + cmock_call_instance->ReturnThruPtr_pProperties_Size = cmock_size; +} + +void vkEnumerateInstanceLayerProperties_CMockIgnoreArg_pPropertyCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkEnumerateInstanceLayerProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateInstanceLayerProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumerateInstanceLayerProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPropertyCount = 1; +} + +void vkEnumerateInstanceLayerProperties_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkEnumerateInstanceLayerProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateInstanceLayerProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumerateInstanceLayerProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pProperties = 1; +} + +VkResult vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkEnumerateDeviceLayerProperties_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkEnumerateDeviceLayerProperties); + cmock_call_instance = (CMOCK_vkEnumerateDeviceLayerProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkEnumerateDeviceLayerProperties_CallInstance); + Mock.vkEnumerateDeviceLayerProperties_CallInstance = CMock_Guts_MemNext(Mock.vkEnumerateDeviceLayerProperties_CallInstance); + if (Mock.vkEnumerateDeviceLayerProperties_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkEnumerateDeviceLayerProperties_FinalReturn; + memcpy((void*)(&Mock.vkEnumerateDeviceLayerProperties_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkEnumerateDeviceLayerProperties_CallbackBool && + Mock.vkEnumerateDeviceLayerProperties_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkEnumerateDeviceLayerProperties_CallbackFunctionPointer(physicalDevice, pPropertyCount, pProperties, Mock.vkEnumerateDeviceLayerProperties_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkEnumerateDeviceLayerProperties,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPropertyCount) + { + UNITY_SET_DETAILS(CMockString_vkEnumerateDeviceLayerProperties,CMockString_pPropertyCount); + if (cmock_call_instance->Expected_pPropertyCount == NULL) + { UNITY_TEST_ASSERT_NULL(pPropertyCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pPropertyCount, pPropertyCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pProperties) + { + UNITY_SET_DETAILS(CMockString_vkEnumerateDeviceLayerProperties,CMockString_pProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pProperties), (void*)(pProperties), sizeof(VkLayerProperties), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkEnumerateDeviceLayerProperties_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkEnumerateDeviceLayerProperties_CallbackFunctionPointer(physicalDevice, pPropertyCount, pProperties, Mock.vkEnumerateDeviceLayerProperties_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPropertyCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPropertyCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPropertyCount, (const void*)cmock_call_instance->ReturnThruPtr_pPropertyCount_Val, + cmock_call_instance->ReturnThruPtr_pPropertyCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pProperties, (const void*)cmock_call_instance->ReturnThruPtr_pProperties_Val, + cmock_call_instance->ReturnThruPtr_pProperties_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkEnumerateDeviceLayerProperties(CMOCK_vkEnumerateDeviceLayerProperties_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties); +void CMockExpectParameters_vkEnumerateDeviceLayerProperties(CMOCK_vkEnumerateDeviceLayerProperties_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pPropertyCount = pPropertyCount; + cmock_call_instance->IgnoreArg_pPropertyCount = 0; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Used = 0; + cmock_call_instance->Expected_pProperties = pProperties; + cmock_call_instance->IgnoreArg_pProperties = 0; + cmock_call_instance->ReturnThruPtr_pProperties_Used = 0; +} + +void vkEnumerateDeviceLayerProperties_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkEnumerateDeviceLayerProperties_CALL_INSTANCE)); + CMOCK_vkEnumerateDeviceLayerProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateDeviceLayerProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkEnumerateDeviceLayerProperties_CallInstance = CMock_Guts_MemChain(Mock.vkEnumerateDeviceLayerProperties_CallInstance, cmock_guts_index); + Mock.vkEnumerateDeviceLayerProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkEnumerateDeviceLayerProperties_IgnoreBool = (char)1; +} + +void vkEnumerateDeviceLayerProperties_CMockStopIgnore(void) +{ + if(Mock.vkEnumerateDeviceLayerProperties_IgnoreBool) + Mock.vkEnumerateDeviceLayerProperties_CallInstance = CMock_Guts_MemNext(Mock.vkEnumerateDeviceLayerProperties_CallInstance); + Mock.vkEnumerateDeviceLayerProperties_IgnoreBool = (char)0; +} + +void vkEnumerateDeviceLayerProperties_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkEnumerateDeviceLayerProperties_CALL_INSTANCE)); + CMOCK_vkEnumerateDeviceLayerProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateDeviceLayerProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkEnumerateDeviceLayerProperties_CallInstance = CMock_Guts_MemChain(Mock.vkEnumerateDeviceLayerProperties_CallInstance, cmock_guts_index); + Mock.vkEnumerateDeviceLayerProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkEnumerateDeviceLayerProperties_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkEnumerateDeviceLayerProperties_CALL_INSTANCE)); + CMOCK_vkEnumerateDeviceLayerProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateDeviceLayerProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkEnumerateDeviceLayerProperties_CallInstance = CMock_Guts_MemChain(Mock.vkEnumerateDeviceLayerProperties_CallInstance, cmock_guts_index); + Mock.vkEnumerateDeviceLayerProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkEnumerateDeviceLayerProperties(cmock_call_instance, physicalDevice, pPropertyCount, pProperties); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkEnumerateDeviceLayerProperties_AddCallback(CMOCK_vkEnumerateDeviceLayerProperties_CALLBACK Callback) +{ + Mock.vkEnumerateDeviceLayerProperties_IgnoreBool = (char)0; + Mock.vkEnumerateDeviceLayerProperties_CallbackBool = (char)1; + Mock.vkEnumerateDeviceLayerProperties_CallbackFunctionPointer = Callback; +} + +void vkEnumerateDeviceLayerProperties_Stub(CMOCK_vkEnumerateDeviceLayerProperties_CALLBACK Callback) +{ + Mock.vkEnumerateDeviceLayerProperties_IgnoreBool = (char)0; + Mock.vkEnumerateDeviceLayerProperties_CallbackBool = (char)0; + Mock.vkEnumerateDeviceLayerProperties_CallbackFunctionPointer = Callback; +} + +void vkEnumerateDeviceLayerProperties_CMockReturnMemThruPtr_pPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPropertyCount, size_t cmock_size) +{ + CMOCK_vkEnumerateDeviceLayerProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateDeviceLayerProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumerateDeviceLayerProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPropertyCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Val = pPropertyCount; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Size = cmock_size; +} + +void vkEnumerateDeviceLayerProperties_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkLayerProperties const* pProperties, size_t cmock_size) +{ + CMOCK_vkEnumerateDeviceLayerProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateDeviceLayerProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumerateDeviceLayerProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pProperties_Val = pProperties; + cmock_call_instance->ReturnThruPtr_pProperties_Size = cmock_size; +} + +void vkEnumerateDeviceLayerProperties_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkEnumerateDeviceLayerProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateDeviceLayerProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumerateDeviceLayerProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkEnumerateDeviceLayerProperties_CMockIgnoreArg_pPropertyCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkEnumerateDeviceLayerProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateDeviceLayerProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumerateDeviceLayerProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPropertyCount = 1; +} + +void vkEnumerateDeviceLayerProperties_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkEnumerateDeviceLayerProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateDeviceLayerProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumerateDeviceLayerProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pProperties = 1; +} + +void vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDeviceQueue_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDeviceQueue); + cmock_call_instance = (CMOCK_vkGetDeviceQueue_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDeviceQueue_CallInstance); + Mock.vkGetDeviceQueue_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeviceQueue_CallInstance); + if (Mock.vkGetDeviceQueue_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetDeviceQueue_CallbackBool && + Mock.vkGetDeviceQueue_CallbackFunctionPointer != NULL) + { + Mock.vkGetDeviceQueue_CallbackFunctionPointer(device, queueFamilyIndex, queueIndex, pQueue, Mock.vkGetDeviceQueue_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceQueue,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queueFamilyIndex) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceQueue,CMockString_queueFamilyIndex); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_queueFamilyIndex, queueFamilyIndex, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queueIndex) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceQueue,CMockString_queueIndex); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_queueIndex, queueIndex, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pQueue) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceQueue,CMockString_pQueue); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pQueue), (void*)(pQueue), sizeof(VkQueue), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDeviceQueue_CallbackFunctionPointer != NULL) + { + Mock.vkGetDeviceQueue_CallbackFunctionPointer(device, queueFamilyIndex, queueIndex, pQueue, Mock.vkGetDeviceQueue_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pQueue_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pQueue, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pQueue, (const void*)cmock_call_instance->ReturnThruPtr_pQueue_Val, + cmock_call_instance->ReturnThruPtr_pQueue_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetDeviceQueue(CMOCK_vkGetDeviceQueue_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); +void CMockExpectParameters_vkGetDeviceQueue(CMOCK_vkGetDeviceQueue_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_queueFamilyIndex = queueFamilyIndex; + cmock_call_instance->IgnoreArg_queueFamilyIndex = 0; + cmock_call_instance->Expected_queueIndex = queueIndex; + cmock_call_instance->IgnoreArg_queueIndex = 0; + cmock_call_instance->Expected_pQueue = pQueue; + cmock_call_instance->IgnoreArg_pQueue = 0; + cmock_call_instance->ReturnThruPtr_pQueue_Used = 0; +} + +void vkGetDeviceQueue_CMockIgnore(void) +{ + Mock.vkGetDeviceQueue_IgnoreBool = (char)1; +} + +void vkGetDeviceQueue_CMockStopIgnore(void) +{ + Mock.vkGetDeviceQueue_IgnoreBool = (char)0; +} + +void vkGetDeviceQueue_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceQueue_CALL_INSTANCE)); + CMOCK_vkGetDeviceQueue_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceQueue_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceQueue_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceQueue_CallInstance, cmock_guts_index); + Mock.vkGetDeviceQueue_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDeviceQueue_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceQueue_CALL_INSTANCE)); + CMOCK_vkGetDeviceQueue_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceQueue_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceQueue_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceQueue_CallInstance, cmock_guts_index); + Mock.vkGetDeviceQueue_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDeviceQueue(cmock_call_instance, device, queueFamilyIndex, queueIndex, pQueue); +} + +void vkGetDeviceQueue_AddCallback(CMOCK_vkGetDeviceQueue_CALLBACK Callback) +{ + Mock.vkGetDeviceQueue_IgnoreBool = (char)0; + Mock.vkGetDeviceQueue_CallbackBool = (char)1; + Mock.vkGetDeviceQueue_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceQueue_Stub(CMOCK_vkGetDeviceQueue_CALLBACK Callback) +{ + Mock.vkGetDeviceQueue_IgnoreBool = (char)0; + Mock.vkGetDeviceQueue_CallbackBool = (char)0; + Mock.vkGetDeviceQueue_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceQueue_CMockReturnMemThruPtr_pQueue(UNITY_LINE_TYPE cmock_line, VkQueue const* pQueue, size_t cmock_size) +{ + CMOCK_vkGetDeviceQueue_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceQueue_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceQueue_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pQueue_Used = 1; + cmock_call_instance->ReturnThruPtr_pQueue_Val = pQueue; + cmock_call_instance->ReturnThruPtr_pQueue_Size = cmock_size; +} + +void vkGetDeviceQueue_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceQueue_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceQueue_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceQueue_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetDeviceQueue_CMockIgnoreArg_queueFamilyIndex(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceQueue_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceQueue_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceQueue_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queueFamilyIndex = 1; +} + +void vkGetDeviceQueue_CMockIgnoreArg_queueIndex(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceQueue_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceQueue_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceQueue_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queueIndex = 1; +} + +void vkGetDeviceQueue_CMockIgnoreArg_pQueue(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceQueue_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceQueue_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceQueue_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pQueue = 1; +} + +VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkQueueSubmit_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkQueueSubmit); + cmock_call_instance = (CMOCK_vkQueueSubmit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkQueueSubmit_CallInstance); + Mock.vkQueueSubmit_CallInstance = CMock_Guts_MemNext(Mock.vkQueueSubmit_CallInstance); + if (Mock.vkQueueSubmit_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkQueueSubmit_FinalReturn; + memcpy((void*)(&Mock.vkQueueSubmit_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkQueueSubmit_CallbackBool && + Mock.vkQueueSubmit_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkQueueSubmit_CallbackFunctionPointer(queue, submitCount, pSubmits, fence, Mock.vkQueueSubmit_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_queue) + { + UNITY_SET_DETAILS(CMockString_vkQueueSubmit,CMockString_queue); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queue), (void*)(&queue), sizeof(VkQueue), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_submitCount) + { + UNITY_SET_DETAILS(CMockString_vkQueueSubmit,CMockString_submitCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_submitCount, submitCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSubmits) + { + UNITY_SET_DETAILS(CMockString_vkQueueSubmit,CMockString_pSubmits); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSubmits), (void*)(pSubmits), sizeof(const VkSubmitInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_fence) + { + UNITY_SET_DETAILS(CMockString_vkQueueSubmit,CMockString_fence); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_fence), (void*)(&fence), sizeof(VkFence), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkQueueSubmit_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkQueueSubmit_CallbackFunctionPointer(queue, submitCount, pSubmits, fence, Mock.vkQueueSubmit_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkQueueSubmit(CMOCK_vkQueueSubmit_CALL_INSTANCE* cmock_call_instance, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence); +void CMockExpectParameters_vkQueueSubmit(CMOCK_vkQueueSubmit_CALL_INSTANCE* cmock_call_instance, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) +{ + memcpy((void*)(&cmock_call_instance->Expected_queue), (void*)(&queue), + sizeof(VkQueue[sizeof(queue) == sizeof(VkQueue) ? 1 : -1])); /* add VkQueue to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queue = 0; + cmock_call_instance->Expected_submitCount = submitCount; + cmock_call_instance->IgnoreArg_submitCount = 0; + cmock_call_instance->Expected_pSubmits = pSubmits; + cmock_call_instance->IgnoreArg_pSubmits = 0; + memcpy((void*)(&cmock_call_instance->Expected_fence), (void*)(&fence), + sizeof(VkFence[sizeof(fence) == sizeof(VkFence) ? 1 : -1])); /* add VkFence to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_fence = 0; +} + +void vkQueueSubmit_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkQueueSubmit_CALL_INSTANCE)); + CMOCK_vkQueueSubmit_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueSubmit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkQueueSubmit_CallInstance = CMock_Guts_MemChain(Mock.vkQueueSubmit_CallInstance, cmock_guts_index); + Mock.vkQueueSubmit_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkQueueSubmit_IgnoreBool = (char)1; +} + +void vkQueueSubmit_CMockStopIgnore(void) +{ + if(Mock.vkQueueSubmit_IgnoreBool) + Mock.vkQueueSubmit_CallInstance = CMock_Guts_MemNext(Mock.vkQueueSubmit_CallInstance); + Mock.vkQueueSubmit_IgnoreBool = (char)0; +} + +void vkQueueSubmit_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkQueueSubmit_CALL_INSTANCE)); + CMOCK_vkQueueSubmit_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueSubmit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkQueueSubmit_CallInstance = CMock_Guts_MemChain(Mock.vkQueueSubmit_CallInstance, cmock_guts_index); + Mock.vkQueueSubmit_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkQueueSubmit_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkQueueSubmit_CALL_INSTANCE)); + CMOCK_vkQueueSubmit_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueSubmit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkQueueSubmit_CallInstance = CMock_Guts_MemChain(Mock.vkQueueSubmit_CallInstance, cmock_guts_index); + Mock.vkQueueSubmit_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkQueueSubmit(cmock_call_instance, queue, submitCount, pSubmits, fence); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkQueueSubmit_AddCallback(CMOCK_vkQueueSubmit_CALLBACK Callback) +{ + Mock.vkQueueSubmit_IgnoreBool = (char)0; + Mock.vkQueueSubmit_CallbackBool = (char)1; + Mock.vkQueueSubmit_CallbackFunctionPointer = Callback; +} + +void vkQueueSubmit_Stub(CMOCK_vkQueueSubmit_CALLBACK Callback) +{ + Mock.vkQueueSubmit_IgnoreBool = (char)0; + Mock.vkQueueSubmit_CallbackBool = (char)0; + Mock.vkQueueSubmit_CallbackFunctionPointer = Callback; +} + +void vkQueueSubmit_CMockIgnoreArg_queue(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkQueueSubmit_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueSubmit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkQueueSubmit_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queue = 1; +} + +void vkQueueSubmit_CMockIgnoreArg_submitCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkQueueSubmit_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueSubmit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkQueueSubmit_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_submitCount = 1; +} + +void vkQueueSubmit_CMockIgnoreArg_pSubmits(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkQueueSubmit_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueSubmit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkQueueSubmit_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSubmits = 1; +} + +void vkQueueSubmit_CMockIgnoreArg_fence(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkQueueSubmit_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueSubmit_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkQueueSubmit_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_fence = 1; +} + +VkResult vkQueueWaitIdle(VkQueue queue) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkQueueWaitIdle_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkQueueWaitIdle); + cmock_call_instance = (CMOCK_vkQueueWaitIdle_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkQueueWaitIdle_CallInstance); + Mock.vkQueueWaitIdle_CallInstance = CMock_Guts_MemNext(Mock.vkQueueWaitIdle_CallInstance); + if (Mock.vkQueueWaitIdle_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkQueueWaitIdle_FinalReturn; + memcpy((void*)(&Mock.vkQueueWaitIdle_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkQueueWaitIdle_CallbackBool && + Mock.vkQueueWaitIdle_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkQueueWaitIdle_CallbackFunctionPointer(queue, Mock.vkQueueWaitIdle_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_queue) + { + UNITY_SET_DETAILS(CMockString_vkQueueWaitIdle,CMockString_queue); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queue), (void*)(&queue), sizeof(VkQueue), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkQueueWaitIdle_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkQueueWaitIdle_CallbackFunctionPointer(queue, Mock.vkQueueWaitIdle_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkQueueWaitIdle(CMOCK_vkQueueWaitIdle_CALL_INSTANCE* cmock_call_instance, VkQueue queue); +void CMockExpectParameters_vkQueueWaitIdle(CMOCK_vkQueueWaitIdle_CALL_INSTANCE* cmock_call_instance, VkQueue queue) +{ + memcpy((void*)(&cmock_call_instance->Expected_queue), (void*)(&queue), + sizeof(VkQueue[sizeof(queue) == sizeof(VkQueue) ? 1 : -1])); /* add VkQueue to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queue = 0; +} + +void vkQueueWaitIdle_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkQueueWaitIdle_CALL_INSTANCE)); + CMOCK_vkQueueWaitIdle_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueWaitIdle_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkQueueWaitIdle_CallInstance = CMock_Guts_MemChain(Mock.vkQueueWaitIdle_CallInstance, cmock_guts_index); + Mock.vkQueueWaitIdle_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkQueueWaitIdle_IgnoreBool = (char)1; +} + +void vkQueueWaitIdle_CMockStopIgnore(void) +{ + if(Mock.vkQueueWaitIdle_IgnoreBool) + Mock.vkQueueWaitIdle_CallInstance = CMock_Guts_MemNext(Mock.vkQueueWaitIdle_CallInstance); + Mock.vkQueueWaitIdle_IgnoreBool = (char)0; +} + +void vkQueueWaitIdle_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkQueueWaitIdle_CALL_INSTANCE)); + CMOCK_vkQueueWaitIdle_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueWaitIdle_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkQueueWaitIdle_CallInstance = CMock_Guts_MemChain(Mock.vkQueueWaitIdle_CallInstance, cmock_guts_index); + Mock.vkQueueWaitIdle_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkQueueWaitIdle_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkQueue queue, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkQueueWaitIdle_CALL_INSTANCE)); + CMOCK_vkQueueWaitIdle_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueWaitIdle_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkQueueWaitIdle_CallInstance = CMock_Guts_MemChain(Mock.vkQueueWaitIdle_CallInstance, cmock_guts_index); + Mock.vkQueueWaitIdle_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkQueueWaitIdle(cmock_call_instance, queue); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkQueueWaitIdle_AddCallback(CMOCK_vkQueueWaitIdle_CALLBACK Callback) +{ + Mock.vkQueueWaitIdle_IgnoreBool = (char)0; + Mock.vkQueueWaitIdle_CallbackBool = (char)1; + Mock.vkQueueWaitIdle_CallbackFunctionPointer = Callback; +} + +void vkQueueWaitIdle_Stub(CMOCK_vkQueueWaitIdle_CALLBACK Callback) +{ + Mock.vkQueueWaitIdle_IgnoreBool = (char)0; + Mock.vkQueueWaitIdle_CallbackBool = (char)0; + Mock.vkQueueWaitIdle_CallbackFunctionPointer = Callback; +} + +void vkQueueWaitIdle_CMockIgnoreArg_queue(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkQueueWaitIdle_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueWaitIdle_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkQueueWaitIdle_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queue = 1; +} + +VkResult vkDeviceWaitIdle(VkDevice device) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDeviceWaitIdle_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDeviceWaitIdle); + cmock_call_instance = (CMOCK_vkDeviceWaitIdle_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDeviceWaitIdle_CallInstance); + Mock.vkDeviceWaitIdle_CallInstance = CMock_Guts_MemNext(Mock.vkDeviceWaitIdle_CallInstance); + if (Mock.vkDeviceWaitIdle_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkDeviceWaitIdle_FinalReturn; + memcpy((void*)(&Mock.vkDeviceWaitIdle_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkDeviceWaitIdle_CallbackBool && + Mock.vkDeviceWaitIdle_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkDeviceWaitIdle_CallbackFunctionPointer(device, Mock.vkDeviceWaitIdle_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDeviceWaitIdle,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDeviceWaitIdle_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkDeviceWaitIdle_CallbackFunctionPointer(device, Mock.vkDeviceWaitIdle_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkDeviceWaitIdle(CMOCK_vkDeviceWaitIdle_CALL_INSTANCE* cmock_call_instance, VkDevice device); +void CMockExpectParameters_vkDeviceWaitIdle(CMOCK_vkDeviceWaitIdle_CALL_INSTANCE* cmock_call_instance, VkDevice device) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; +} + +void vkDeviceWaitIdle_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDeviceWaitIdle_CALL_INSTANCE)); + CMOCK_vkDeviceWaitIdle_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDeviceWaitIdle_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDeviceWaitIdle_CallInstance = CMock_Guts_MemChain(Mock.vkDeviceWaitIdle_CallInstance, cmock_guts_index); + Mock.vkDeviceWaitIdle_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkDeviceWaitIdle_IgnoreBool = (char)1; +} + +void vkDeviceWaitIdle_CMockStopIgnore(void) +{ + if(Mock.vkDeviceWaitIdle_IgnoreBool) + Mock.vkDeviceWaitIdle_CallInstance = CMock_Guts_MemNext(Mock.vkDeviceWaitIdle_CallInstance); + Mock.vkDeviceWaitIdle_IgnoreBool = (char)0; +} + +void vkDeviceWaitIdle_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDeviceWaitIdle_CALL_INSTANCE)); + CMOCK_vkDeviceWaitIdle_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDeviceWaitIdle_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDeviceWaitIdle_CallInstance = CMock_Guts_MemChain(Mock.vkDeviceWaitIdle_CallInstance, cmock_guts_index); + Mock.vkDeviceWaitIdle_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDeviceWaitIdle_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDeviceWaitIdle_CALL_INSTANCE)); + CMOCK_vkDeviceWaitIdle_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDeviceWaitIdle_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDeviceWaitIdle_CallInstance = CMock_Guts_MemChain(Mock.vkDeviceWaitIdle_CallInstance, cmock_guts_index); + Mock.vkDeviceWaitIdle_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDeviceWaitIdle(cmock_call_instance, device); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkDeviceWaitIdle_AddCallback(CMOCK_vkDeviceWaitIdle_CALLBACK Callback) +{ + Mock.vkDeviceWaitIdle_IgnoreBool = (char)0; + Mock.vkDeviceWaitIdle_CallbackBool = (char)1; + Mock.vkDeviceWaitIdle_CallbackFunctionPointer = Callback; +} + +void vkDeviceWaitIdle_Stub(CMOCK_vkDeviceWaitIdle_CALLBACK Callback) +{ + Mock.vkDeviceWaitIdle_IgnoreBool = (char)0; + Mock.vkDeviceWaitIdle_CallbackBool = (char)0; + Mock.vkDeviceWaitIdle_CallbackFunctionPointer = Callback; +} + +void vkDeviceWaitIdle_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDeviceWaitIdle_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDeviceWaitIdle_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDeviceWaitIdle_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +VkResult vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkAllocateMemory_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkAllocateMemory); + cmock_call_instance = (CMOCK_vkAllocateMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkAllocateMemory_CallInstance); + Mock.vkAllocateMemory_CallInstance = CMock_Guts_MemNext(Mock.vkAllocateMemory_CallInstance); + if (Mock.vkAllocateMemory_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkAllocateMemory_FinalReturn; + memcpy((void*)(&Mock.vkAllocateMemory_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkAllocateMemory_CallbackBool && + Mock.vkAllocateMemory_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkAllocateMemory_CallbackFunctionPointer(device, pAllocateInfo, pAllocator, pMemory, Mock.vkAllocateMemory_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkAllocateMemory,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocateInfo) + { + UNITY_SET_DETAILS(CMockString_vkAllocateMemory,CMockString_pAllocateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocateInfo), (void*)(pAllocateInfo), sizeof(const VkMemoryAllocateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkAllocateMemory,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMemory) + { + UNITY_SET_DETAILS(CMockString_vkAllocateMemory,CMockString_pMemory); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMemory), (void*)(pMemory), sizeof(VkDeviceMemory), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkAllocateMemory_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkAllocateMemory_CallbackFunctionPointer(device, pAllocateInfo, pAllocator, pMemory, Mock.vkAllocateMemory_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pMemory_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pMemory, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pMemory, (const void*)cmock_call_instance->ReturnThruPtr_pMemory_Val, + cmock_call_instance->ReturnThruPtr_pMemory_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkAllocateMemory(CMOCK_vkAllocateMemory_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory); +void CMockExpectParameters_vkAllocateMemory(CMOCK_vkAllocateMemory_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pAllocateInfo = pAllocateInfo; + cmock_call_instance->IgnoreArg_pAllocateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pMemory = pMemory; + cmock_call_instance->IgnoreArg_pMemory = 0; + cmock_call_instance->ReturnThruPtr_pMemory_Used = 0; +} + +void vkAllocateMemory_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkAllocateMemory_CALL_INSTANCE)); + CMOCK_vkAllocateMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAllocateMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkAllocateMemory_CallInstance = CMock_Guts_MemChain(Mock.vkAllocateMemory_CallInstance, cmock_guts_index); + Mock.vkAllocateMemory_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkAllocateMemory_IgnoreBool = (char)1; +} + +void vkAllocateMemory_CMockStopIgnore(void) +{ + if(Mock.vkAllocateMemory_IgnoreBool) + Mock.vkAllocateMemory_CallInstance = CMock_Guts_MemNext(Mock.vkAllocateMemory_CallInstance); + Mock.vkAllocateMemory_IgnoreBool = (char)0; +} + +void vkAllocateMemory_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkAllocateMemory_CALL_INSTANCE)); + CMOCK_vkAllocateMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAllocateMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkAllocateMemory_CallInstance = CMock_Guts_MemChain(Mock.vkAllocateMemory_CallInstance, cmock_guts_index); + Mock.vkAllocateMemory_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkAllocateMemory_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkAllocateMemory_CALL_INSTANCE)); + CMOCK_vkAllocateMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAllocateMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkAllocateMemory_CallInstance = CMock_Guts_MemChain(Mock.vkAllocateMemory_CallInstance, cmock_guts_index); + Mock.vkAllocateMemory_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkAllocateMemory(cmock_call_instance, device, pAllocateInfo, pAllocator, pMemory); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkAllocateMemory_AddCallback(CMOCK_vkAllocateMemory_CALLBACK Callback) +{ + Mock.vkAllocateMemory_IgnoreBool = (char)0; + Mock.vkAllocateMemory_CallbackBool = (char)1; + Mock.vkAllocateMemory_CallbackFunctionPointer = Callback; +} + +void vkAllocateMemory_Stub(CMOCK_vkAllocateMemory_CALLBACK Callback) +{ + Mock.vkAllocateMemory_IgnoreBool = (char)0; + Mock.vkAllocateMemory_CallbackBool = (char)0; + Mock.vkAllocateMemory_CallbackFunctionPointer = Callback; +} + +void vkAllocateMemory_CMockReturnMemThruPtr_pMemory(UNITY_LINE_TYPE cmock_line, VkDeviceMemory const* pMemory, size_t cmock_size) +{ + CMOCK_vkAllocateMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAllocateMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAllocateMemory_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pMemory_Used = 1; + cmock_call_instance->ReturnThruPtr_pMemory_Val = pMemory; + cmock_call_instance->ReturnThruPtr_pMemory_Size = cmock_size; +} + +void vkAllocateMemory_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkAllocateMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAllocateMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAllocateMemory_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkAllocateMemory_CMockIgnoreArg_pAllocateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkAllocateMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAllocateMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAllocateMemory_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocateInfo = 1; +} + +void vkAllocateMemory_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkAllocateMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAllocateMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAllocateMemory_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkAllocateMemory_CMockIgnoreArg_pMemory(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkAllocateMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAllocateMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAllocateMemory_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMemory = 1; +} + +void vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkFreeMemory_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkFreeMemory); + cmock_call_instance = (CMOCK_vkFreeMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkFreeMemory_CallInstance); + Mock.vkFreeMemory_CallInstance = CMock_Guts_MemNext(Mock.vkFreeMemory_CallInstance); + if (Mock.vkFreeMemory_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkFreeMemory_CallbackBool && + Mock.vkFreeMemory_CallbackFunctionPointer != NULL) + { + Mock.vkFreeMemory_CallbackFunctionPointer(device, memory, pAllocator, Mock.vkFreeMemory_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkFreeMemory,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_memory) + { + UNITY_SET_DETAILS(CMockString_vkFreeMemory,CMockString_memory); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_memory), (void*)(&memory), sizeof(VkDeviceMemory), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkFreeMemory,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkFreeMemory_CallbackFunctionPointer != NULL) + { + Mock.vkFreeMemory_CallbackFunctionPointer(device, memory, pAllocator, Mock.vkFreeMemory_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkFreeMemory(CMOCK_vkFreeMemory_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkFreeMemory(CMOCK_vkFreeMemory_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_memory), (void*)(&memory), + sizeof(VkDeviceMemory[sizeof(memory) == sizeof(VkDeviceMemory) ? 1 : -1])); /* add VkDeviceMemory to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_memory = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkFreeMemory_CMockIgnore(void) +{ + Mock.vkFreeMemory_IgnoreBool = (char)1; +} + +void vkFreeMemory_CMockStopIgnore(void) +{ + Mock.vkFreeMemory_IgnoreBool = (char)0; +} + +void vkFreeMemory_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkFreeMemory_CALL_INSTANCE)); + CMOCK_vkFreeMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkFreeMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkFreeMemory_CallInstance = CMock_Guts_MemChain(Mock.vkFreeMemory_CallInstance, cmock_guts_index); + Mock.vkFreeMemory_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkFreeMemory_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkFreeMemory_CALL_INSTANCE)); + CMOCK_vkFreeMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkFreeMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkFreeMemory_CallInstance = CMock_Guts_MemChain(Mock.vkFreeMemory_CallInstance, cmock_guts_index); + Mock.vkFreeMemory_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkFreeMemory(cmock_call_instance, device, memory, pAllocator); +} + +void vkFreeMemory_AddCallback(CMOCK_vkFreeMemory_CALLBACK Callback) +{ + Mock.vkFreeMemory_IgnoreBool = (char)0; + Mock.vkFreeMemory_CallbackBool = (char)1; + Mock.vkFreeMemory_CallbackFunctionPointer = Callback; +} + +void vkFreeMemory_Stub(CMOCK_vkFreeMemory_CALLBACK Callback) +{ + Mock.vkFreeMemory_IgnoreBool = (char)0; + Mock.vkFreeMemory_CallbackBool = (char)0; + Mock.vkFreeMemory_CallbackFunctionPointer = Callback; +} + +void vkFreeMemory_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkFreeMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkFreeMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkFreeMemory_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkFreeMemory_CMockIgnoreArg_memory(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkFreeMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkFreeMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkFreeMemory_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_memory = 1; +} + +void vkFreeMemory_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkFreeMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkFreeMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkFreeMemory_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +VkResult vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkMapMemory_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkMapMemory); + cmock_call_instance = (CMOCK_vkMapMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkMapMemory_CallInstance); + Mock.vkMapMemory_CallInstance = CMock_Guts_MemNext(Mock.vkMapMemory_CallInstance); + if (Mock.vkMapMemory_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkMapMemory_FinalReturn; + memcpy((void*)(&Mock.vkMapMemory_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkMapMemory_CallbackBool && + Mock.vkMapMemory_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkMapMemory_CallbackFunctionPointer(device, memory, offset, size, flags, ppData, Mock.vkMapMemory_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkMapMemory,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_memory) + { + UNITY_SET_DETAILS(CMockString_vkMapMemory,CMockString_memory); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_memory), (void*)(&memory), sizeof(VkDeviceMemory), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_offset) + { + UNITY_SET_DETAILS(CMockString_vkMapMemory,CMockString_offset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_size) + { + UNITY_SET_DETAILS(CMockString_vkMapMemory,CMockString_size); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_size), (void*)(&size), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_flags) + { + UNITY_SET_DETAILS(CMockString_vkMapMemory,CMockString_flags); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_flags), (void*)(&flags), sizeof(VkMemoryMapFlags), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_ppData) + { + UNITY_SET_DETAILS(CMockString_vkMapMemory,CMockString_ppData); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_ppData, ppData, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkMapMemory_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkMapMemory_CallbackFunctionPointer(device, memory, offset, size, flags, ppData, Mock.vkMapMemory_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_ppData_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(ppData, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)ppData, (const void*)cmock_call_instance->ReturnThruPtr_ppData_Val, + cmock_call_instance->ReturnThruPtr_ppData_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkMapMemory(CMOCK_vkMapMemory_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); +void CMockExpectParameters_vkMapMemory(CMOCK_vkMapMemory_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_memory), (void*)(&memory), + sizeof(VkDeviceMemory[sizeof(memory) == sizeof(VkDeviceMemory) ? 1 : -1])); /* add VkDeviceMemory to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_memory = 0; + memcpy((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), + sizeof(VkDeviceSize[sizeof(offset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_offset = 0; + memcpy((void*)(&cmock_call_instance->Expected_size), (void*)(&size), + sizeof(VkDeviceSize[sizeof(size) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_size = 0; + memcpy((void*)(&cmock_call_instance->Expected_flags), (void*)(&flags), + sizeof(VkMemoryMapFlags[sizeof(flags) == sizeof(VkMemoryMapFlags) ? 1 : -1])); /* add VkMemoryMapFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_flags = 0; + cmock_call_instance->Expected_ppData = ppData; + cmock_call_instance->IgnoreArg_ppData = 0; + cmock_call_instance->ReturnThruPtr_ppData_Used = 0; +} + +void vkMapMemory_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkMapMemory_CALL_INSTANCE)); + CMOCK_vkMapMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMapMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkMapMemory_CallInstance = CMock_Guts_MemChain(Mock.vkMapMemory_CallInstance, cmock_guts_index); + Mock.vkMapMemory_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkMapMemory_IgnoreBool = (char)1; +} + +void vkMapMemory_CMockStopIgnore(void) +{ + if(Mock.vkMapMemory_IgnoreBool) + Mock.vkMapMemory_CallInstance = CMock_Guts_MemNext(Mock.vkMapMemory_CallInstance); + Mock.vkMapMemory_IgnoreBool = (char)0; +} + +void vkMapMemory_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkMapMemory_CALL_INSTANCE)); + CMOCK_vkMapMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMapMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkMapMemory_CallInstance = CMock_Guts_MemChain(Mock.vkMapMemory_CallInstance, cmock_guts_index); + Mock.vkMapMemory_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkMapMemory_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkMapMemory_CALL_INSTANCE)); + CMOCK_vkMapMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMapMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkMapMemory_CallInstance = CMock_Guts_MemChain(Mock.vkMapMemory_CallInstance, cmock_guts_index); + Mock.vkMapMemory_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkMapMemory(cmock_call_instance, device, memory, offset, size, flags, ppData); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkMapMemory_AddCallback(CMOCK_vkMapMemory_CALLBACK Callback) +{ + Mock.vkMapMemory_IgnoreBool = (char)0; + Mock.vkMapMemory_CallbackBool = (char)1; + Mock.vkMapMemory_CallbackFunctionPointer = Callback; +} + +void vkMapMemory_Stub(CMOCK_vkMapMemory_CALLBACK Callback) +{ + Mock.vkMapMemory_IgnoreBool = (char)0; + Mock.vkMapMemory_CallbackBool = (char)0; + Mock.vkMapMemory_CallbackFunctionPointer = Callback; +} + +void vkMapMemory_CMockReturnMemThruPtr_ppData(UNITY_LINE_TYPE cmock_line, void* const* ppData, size_t cmock_size) +{ + CMOCK_vkMapMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMapMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkMapMemory_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_ppData_Used = 1; + cmock_call_instance->ReturnThruPtr_ppData_Val = ppData; + cmock_call_instance->ReturnThruPtr_ppData_Size = cmock_size; +} + +void vkMapMemory_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkMapMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMapMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkMapMemory_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkMapMemory_CMockIgnoreArg_memory(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkMapMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMapMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkMapMemory_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_memory = 1; +} + +void vkMapMemory_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkMapMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMapMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkMapMemory_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_offset = 1; +} + +void vkMapMemory_CMockIgnoreArg_size(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkMapMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMapMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkMapMemory_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_size = 1; +} + +void vkMapMemory_CMockIgnoreArg_flags(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkMapMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMapMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkMapMemory_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_flags = 1; +} + +void vkMapMemory_CMockIgnoreArg_ppData(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkMapMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMapMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkMapMemory_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_ppData = 1; +} + +void vkUnmapMemory(VkDevice device, VkDeviceMemory memory) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkUnmapMemory_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkUnmapMemory); + cmock_call_instance = (CMOCK_vkUnmapMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkUnmapMemory_CallInstance); + Mock.vkUnmapMemory_CallInstance = CMock_Guts_MemNext(Mock.vkUnmapMemory_CallInstance); + if (Mock.vkUnmapMemory_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkUnmapMemory_CallbackBool && + Mock.vkUnmapMemory_CallbackFunctionPointer != NULL) + { + Mock.vkUnmapMemory_CallbackFunctionPointer(device, memory, Mock.vkUnmapMemory_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkUnmapMemory,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_memory) + { + UNITY_SET_DETAILS(CMockString_vkUnmapMemory,CMockString_memory); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_memory), (void*)(&memory), sizeof(VkDeviceMemory), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkUnmapMemory_CallbackFunctionPointer != NULL) + { + Mock.vkUnmapMemory_CallbackFunctionPointer(device, memory, Mock.vkUnmapMemory_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkUnmapMemory(CMOCK_vkUnmapMemory_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeviceMemory memory); +void CMockExpectParameters_vkUnmapMemory(CMOCK_vkUnmapMemory_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeviceMemory memory) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_memory), (void*)(&memory), + sizeof(VkDeviceMemory[sizeof(memory) == sizeof(VkDeviceMemory) ? 1 : -1])); /* add VkDeviceMemory to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_memory = 0; +} + +void vkUnmapMemory_CMockIgnore(void) +{ + Mock.vkUnmapMemory_IgnoreBool = (char)1; +} + +void vkUnmapMemory_CMockStopIgnore(void) +{ + Mock.vkUnmapMemory_IgnoreBool = (char)0; +} + +void vkUnmapMemory_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkUnmapMemory_CALL_INSTANCE)); + CMOCK_vkUnmapMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUnmapMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkUnmapMemory_CallInstance = CMock_Guts_MemChain(Mock.vkUnmapMemory_CallInstance, cmock_guts_index); + Mock.vkUnmapMemory_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkUnmapMemory_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeviceMemory memory) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkUnmapMemory_CALL_INSTANCE)); + CMOCK_vkUnmapMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUnmapMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkUnmapMemory_CallInstance = CMock_Guts_MemChain(Mock.vkUnmapMemory_CallInstance, cmock_guts_index); + Mock.vkUnmapMemory_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkUnmapMemory(cmock_call_instance, device, memory); +} + +void vkUnmapMemory_AddCallback(CMOCK_vkUnmapMemory_CALLBACK Callback) +{ + Mock.vkUnmapMemory_IgnoreBool = (char)0; + Mock.vkUnmapMemory_CallbackBool = (char)1; + Mock.vkUnmapMemory_CallbackFunctionPointer = Callback; +} + +void vkUnmapMemory_Stub(CMOCK_vkUnmapMemory_CALLBACK Callback) +{ + Mock.vkUnmapMemory_IgnoreBool = (char)0; + Mock.vkUnmapMemory_CallbackBool = (char)0; + Mock.vkUnmapMemory_CallbackFunctionPointer = Callback; +} + +void vkUnmapMemory_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkUnmapMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUnmapMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkUnmapMemory_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkUnmapMemory_CMockIgnoreArg_memory(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkUnmapMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUnmapMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkUnmapMemory_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_memory = 1; +} + +VkResult vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkFlushMappedMemoryRanges_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkFlushMappedMemoryRanges); + cmock_call_instance = (CMOCK_vkFlushMappedMemoryRanges_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkFlushMappedMemoryRanges_CallInstance); + Mock.vkFlushMappedMemoryRanges_CallInstance = CMock_Guts_MemNext(Mock.vkFlushMappedMemoryRanges_CallInstance); + if (Mock.vkFlushMappedMemoryRanges_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkFlushMappedMemoryRanges_FinalReturn; + memcpy((void*)(&Mock.vkFlushMappedMemoryRanges_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkFlushMappedMemoryRanges_CallbackBool && + Mock.vkFlushMappedMemoryRanges_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkFlushMappedMemoryRanges_CallbackFunctionPointer(device, memoryRangeCount, pMemoryRanges, Mock.vkFlushMappedMemoryRanges_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkFlushMappedMemoryRanges,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_memoryRangeCount) + { + UNITY_SET_DETAILS(CMockString_vkFlushMappedMemoryRanges,CMockString_memoryRangeCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_memoryRangeCount, memoryRangeCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMemoryRanges) + { + UNITY_SET_DETAILS(CMockString_vkFlushMappedMemoryRanges,CMockString_pMemoryRanges); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMemoryRanges), (void*)(pMemoryRanges), sizeof(const VkMappedMemoryRange), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkFlushMappedMemoryRanges_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkFlushMappedMemoryRanges_CallbackFunctionPointer(device, memoryRangeCount, pMemoryRanges, Mock.vkFlushMappedMemoryRanges_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkFlushMappedMemoryRanges(CMOCK_vkFlushMappedMemoryRanges_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); +void CMockExpectParameters_vkFlushMappedMemoryRanges(CMOCK_vkFlushMappedMemoryRanges_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_memoryRangeCount = memoryRangeCount; + cmock_call_instance->IgnoreArg_memoryRangeCount = 0; + cmock_call_instance->Expected_pMemoryRanges = pMemoryRanges; + cmock_call_instance->IgnoreArg_pMemoryRanges = 0; +} + +void vkFlushMappedMemoryRanges_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkFlushMappedMemoryRanges_CALL_INSTANCE)); + CMOCK_vkFlushMappedMemoryRanges_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkFlushMappedMemoryRanges_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkFlushMappedMemoryRanges_CallInstance = CMock_Guts_MemChain(Mock.vkFlushMappedMemoryRanges_CallInstance, cmock_guts_index); + Mock.vkFlushMappedMemoryRanges_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkFlushMappedMemoryRanges_IgnoreBool = (char)1; +} + +void vkFlushMappedMemoryRanges_CMockStopIgnore(void) +{ + if(Mock.vkFlushMappedMemoryRanges_IgnoreBool) + Mock.vkFlushMappedMemoryRanges_CallInstance = CMock_Guts_MemNext(Mock.vkFlushMappedMemoryRanges_CallInstance); + Mock.vkFlushMappedMemoryRanges_IgnoreBool = (char)0; +} + +void vkFlushMappedMemoryRanges_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkFlushMappedMemoryRanges_CALL_INSTANCE)); + CMOCK_vkFlushMappedMemoryRanges_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkFlushMappedMemoryRanges_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkFlushMappedMemoryRanges_CallInstance = CMock_Guts_MemChain(Mock.vkFlushMappedMemoryRanges_CallInstance, cmock_guts_index); + Mock.vkFlushMappedMemoryRanges_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkFlushMappedMemoryRanges_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkFlushMappedMemoryRanges_CALL_INSTANCE)); + CMOCK_vkFlushMappedMemoryRanges_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkFlushMappedMemoryRanges_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkFlushMappedMemoryRanges_CallInstance = CMock_Guts_MemChain(Mock.vkFlushMappedMemoryRanges_CallInstance, cmock_guts_index); + Mock.vkFlushMappedMemoryRanges_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkFlushMappedMemoryRanges(cmock_call_instance, device, memoryRangeCount, pMemoryRanges); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkFlushMappedMemoryRanges_AddCallback(CMOCK_vkFlushMappedMemoryRanges_CALLBACK Callback) +{ + Mock.vkFlushMappedMemoryRanges_IgnoreBool = (char)0; + Mock.vkFlushMappedMemoryRanges_CallbackBool = (char)1; + Mock.vkFlushMappedMemoryRanges_CallbackFunctionPointer = Callback; +} + +void vkFlushMappedMemoryRanges_Stub(CMOCK_vkFlushMappedMemoryRanges_CALLBACK Callback) +{ + Mock.vkFlushMappedMemoryRanges_IgnoreBool = (char)0; + Mock.vkFlushMappedMemoryRanges_CallbackBool = (char)0; + Mock.vkFlushMappedMemoryRanges_CallbackFunctionPointer = Callback; +} + +void vkFlushMappedMemoryRanges_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkFlushMappedMemoryRanges_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkFlushMappedMemoryRanges_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkFlushMappedMemoryRanges_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkFlushMappedMemoryRanges_CMockIgnoreArg_memoryRangeCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkFlushMappedMemoryRanges_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkFlushMappedMemoryRanges_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkFlushMappedMemoryRanges_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_memoryRangeCount = 1; +} + +void vkFlushMappedMemoryRanges_CMockIgnoreArg_pMemoryRanges(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkFlushMappedMemoryRanges_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkFlushMappedMemoryRanges_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkFlushMappedMemoryRanges_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMemoryRanges = 1; +} + +VkResult vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkInvalidateMappedMemoryRanges_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkInvalidateMappedMemoryRanges); + cmock_call_instance = (CMOCK_vkInvalidateMappedMemoryRanges_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkInvalidateMappedMemoryRanges_CallInstance); + Mock.vkInvalidateMappedMemoryRanges_CallInstance = CMock_Guts_MemNext(Mock.vkInvalidateMappedMemoryRanges_CallInstance); + if (Mock.vkInvalidateMappedMemoryRanges_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkInvalidateMappedMemoryRanges_FinalReturn; + memcpy((void*)(&Mock.vkInvalidateMappedMemoryRanges_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkInvalidateMappedMemoryRanges_CallbackBool && + Mock.vkInvalidateMappedMemoryRanges_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkInvalidateMappedMemoryRanges_CallbackFunctionPointer(device, memoryRangeCount, pMemoryRanges, Mock.vkInvalidateMappedMemoryRanges_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkInvalidateMappedMemoryRanges,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_memoryRangeCount) + { + UNITY_SET_DETAILS(CMockString_vkInvalidateMappedMemoryRanges,CMockString_memoryRangeCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_memoryRangeCount, memoryRangeCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMemoryRanges) + { + UNITY_SET_DETAILS(CMockString_vkInvalidateMappedMemoryRanges,CMockString_pMemoryRanges); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMemoryRanges), (void*)(pMemoryRanges), sizeof(const VkMappedMemoryRange), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkInvalidateMappedMemoryRanges_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkInvalidateMappedMemoryRanges_CallbackFunctionPointer(device, memoryRangeCount, pMemoryRanges, Mock.vkInvalidateMappedMemoryRanges_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkInvalidateMappedMemoryRanges(CMOCK_vkInvalidateMappedMemoryRanges_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); +void CMockExpectParameters_vkInvalidateMappedMemoryRanges(CMOCK_vkInvalidateMappedMemoryRanges_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_memoryRangeCount = memoryRangeCount; + cmock_call_instance->IgnoreArg_memoryRangeCount = 0; + cmock_call_instance->Expected_pMemoryRanges = pMemoryRanges; + cmock_call_instance->IgnoreArg_pMemoryRanges = 0; +} + +void vkInvalidateMappedMemoryRanges_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkInvalidateMappedMemoryRanges_CALL_INSTANCE)); + CMOCK_vkInvalidateMappedMemoryRanges_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkInvalidateMappedMemoryRanges_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkInvalidateMappedMemoryRanges_CallInstance = CMock_Guts_MemChain(Mock.vkInvalidateMappedMemoryRanges_CallInstance, cmock_guts_index); + Mock.vkInvalidateMappedMemoryRanges_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkInvalidateMappedMemoryRanges_IgnoreBool = (char)1; +} + +void vkInvalidateMappedMemoryRanges_CMockStopIgnore(void) +{ + if(Mock.vkInvalidateMappedMemoryRanges_IgnoreBool) + Mock.vkInvalidateMappedMemoryRanges_CallInstance = CMock_Guts_MemNext(Mock.vkInvalidateMappedMemoryRanges_CallInstance); + Mock.vkInvalidateMappedMemoryRanges_IgnoreBool = (char)0; +} + +void vkInvalidateMappedMemoryRanges_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkInvalidateMappedMemoryRanges_CALL_INSTANCE)); + CMOCK_vkInvalidateMappedMemoryRanges_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkInvalidateMappedMemoryRanges_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkInvalidateMappedMemoryRanges_CallInstance = CMock_Guts_MemChain(Mock.vkInvalidateMappedMemoryRanges_CallInstance, cmock_guts_index); + Mock.vkInvalidateMappedMemoryRanges_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkInvalidateMappedMemoryRanges_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkInvalidateMappedMemoryRanges_CALL_INSTANCE)); + CMOCK_vkInvalidateMappedMemoryRanges_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkInvalidateMappedMemoryRanges_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkInvalidateMappedMemoryRanges_CallInstance = CMock_Guts_MemChain(Mock.vkInvalidateMappedMemoryRanges_CallInstance, cmock_guts_index); + Mock.vkInvalidateMappedMemoryRanges_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkInvalidateMappedMemoryRanges(cmock_call_instance, device, memoryRangeCount, pMemoryRanges); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkInvalidateMappedMemoryRanges_AddCallback(CMOCK_vkInvalidateMappedMemoryRanges_CALLBACK Callback) +{ + Mock.vkInvalidateMappedMemoryRanges_IgnoreBool = (char)0; + Mock.vkInvalidateMappedMemoryRanges_CallbackBool = (char)1; + Mock.vkInvalidateMappedMemoryRanges_CallbackFunctionPointer = Callback; +} + +void vkInvalidateMappedMemoryRanges_Stub(CMOCK_vkInvalidateMappedMemoryRanges_CALLBACK Callback) +{ + Mock.vkInvalidateMappedMemoryRanges_IgnoreBool = (char)0; + Mock.vkInvalidateMappedMemoryRanges_CallbackBool = (char)0; + Mock.vkInvalidateMappedMemoryRanges_CallbackFunctionPointer = Callback; +} + +void vkInvalidateMappedMemoryRanges_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkInvalidateMappedMemoryRanges_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkInvalidateMappedMemoryRanges_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkInvalidateMappedMemoryRanges_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkInvalidateMappedMemoryRanges_CMockIgnoreArg_memoryRangeCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkInvalidateMappedMemoryRanges_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkInvalidateMappedMemoryRanges_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkInvalidateMappedMemoryRanges_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_memoryRangeCount = 1; +} + +void vkInvalidateMappedMemoryRanges_CMockIgnoreArg_pMemoryRanges(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkInvalidateMappedMemoryRanges_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkInvalidateMappedMemoryRanges_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkInvalidateMappedMemoryRanges_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMemoryRanges = 1; +} + +void vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDeviceMemoryCommitment_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDeviceMemoryCommitment); + cmock_call_instance = (CMOCK_vkGetDeviceMemoryCommitment_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDeviceMemoryCommitment_CallInstance); + Mock.vkGetDeviceMemoryCommitment_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeviceMemoryCommitment_CallInstance); + if (Mock.vkGetDeviceMemoryCommitment_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetDeviceMemoryCommitment_CallbackBool && + Mock.vkGetDeviceMemoryCommitment_CallbackFunctionPointer != NULL) + { + Mock.vkGetDeviceMemoryCommitment_CallbackFunctionPointer(device, memory, pCommittedMemoryInBytes, Mock.vkGetDeviceMemoryCommitment_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceMemoryCommitment,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_memory) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceMemoryCommitment,CMockString_memory); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_memory), (void*)(&memory), sizeof(VkDeviceMemory), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCommittedMemoryInBytes) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceMemoryCommitment,CMockString_pCommittedMemoryInBytes); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCommittedMemoryInBytes), (void*)(pCommittedMemoryInBytes), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDeviceMemoryCommitment_CallbackFunctionPointer != NULL) + { + Mock.vkGetDeviceMemoryCommitment_CallbackFunctionPointer(device, memory, pCommittedMemoryInBytes, Mock.vkGetDeviceMemoryCommitment_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pCommittedMemoryInBytes_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pCommittedMemoryInBytes, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pCommittedMemoryInBytes, (const void*)cmock_call_instance->ReturnThruPtr_pCommittedMemoryInBytes_Val, + cmock_call_instance->ReturnThruPtr_pCommittedMemoryInBytes_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetDeviceMemoryCommitment(CMOCK_vkGetDeviceMemoryCommitment_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); +void CMockExpectParameters_vkGetDeviceMemoryCommitment(CMOCK_vkGetDeviceMemoryCommitment_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_memory), (void*)(&memory), + sizeof(VkDeviceMemory[sizeof(memory) == sizeof(VkDeviceMemory) ? 1 : -1])); /* add VkDeviceMemory to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_memory = 0; + cmock_call_instance->Expected_pCommittedMemoryInBytes = pCommittedMemoryInBytes; + cmock_call_instance->IgnoreArg_pCommittedMemoryInBytes = 0; + cmock_call_instance->ReturnThruPtr_pCommittedMemoryInBytes_Used = 0; +} + +void vkGetDeviceMemoryCommitment_CMockIgnore(void) +{ + Mock.vkGetDeviceMemoryCommitment_IgnoreBool = (char)1; +} + +void vkGetDeviceMemoryCommitment_CMockStopIgnore(void) +{ + Mock.vkGetDeviceMemoryCommitment_IgnoreBool = (char)0; +} + +void vkGetDeviceMemoryCommitment_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceMemoryCommitment_CALL_INSTANCE)); + CMOCK_vkGetDeviceMemoryCommitment_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceMemoryCommitment_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceMemoryCommitment_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceMemoryCommitment_CallInstance, cmock_guts_index); + Mock.vkGetDeviceMemoryCommitment_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDeviceMemoryCommitment_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceMemoryCommitment_CALL_INSTANCE)); + CMOCK_vkGetDeviceMemoryCommitment_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceMemoryCommitment_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceMemoryCommitment_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceMemoryCommitment_CallInstance, cmock_guts_index); + Mock.vkGetDeviceMemoryCommitment_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDeviceMemoryCommitment(cmock_call_instance, device, memory, pCommittedMemoryInBytes); +} + +void vkGetDeviceMemoryCommitment_AddCallback(CMOCK_vkGetDeviceMemoryCommitment_CALLBACK Callback) +{ + Mock.vkGetDeviceMemoryCommitment_IgnoreBool = (char)0; + Mock.vkGetDeviceMemoryCommitment_CallbackBool = (char)1; + Mock.vkGetDeviceMemoryCommitment_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceMemoryCommitment_Stub(CMOCK_vkGetDeviceMemoryCommitment_CALLBACK Callback) +{ + Mock.vkGetDeviceMemoryCommitment_IgnoreBool = (char)0; + Mock.vkGetDeviceMemoryCommitment_CallbackBool = (char)0; + Mock.vkGetDeviceMemoryCommitment_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceMemoryCommitment_CMockReturnMemThruPtr_pCommittedMemoryInBytes(UNITY_LINE_TYPE cmock_line, VkDeviceSize const* pCommittedMemoryInBytes, size_t cmock_size) +{ + CMOCK_vkGetDeviceMemoryCommitment_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceMemoryCommitment_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceMemoryCommitment_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pCommittedMemoryInBytes_Used = 1; + cmock_call_instance->ReturnThruPtr_pCommittedMemoryInBytes_Val = pCommittedMemoryInBytes; + cmock_call_instance->ReturnThruPtr_pCommittedMemoryInBytes_Size = cmock_size; +} + +void vkGetDeviceMemoryCommitment_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceMemoryCommitment_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceMemoryCommitment_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceMemoryCommitment_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetDeviceMemoryCommitment_CMockIgnoreArg_memory(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceMemoryCommitment_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceMemoryCommitment_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceMemoryCommitment_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_memory = 1; +} + +void vkGetDeviceMemoryCommitment_CMockIgnoreArg_pCommittedMemoryInBytes(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceMemoryCommitment_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceMemoryCommitment_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceMemoryCommitment_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCommittedMemoryInBytes = 1; +} + +VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkBindBufferMemory_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkBindBufferMemory); + cmock_call_instance = (CMOCK_vkBindBufferMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkBindBufferMemory_CallInstance); + Mock.vkBindBufferMemory_CallInstance = CMock_Guts_MemNext(Mock.vkBindBufferMemory_CallInstance); + if (Mock.vkBindBufferMemory_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkBindBufferMemory_FinalReturn; + memcpy((void*)(&Mock.vkBindBufferMemory_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkBindBufferMemory_CallbackBool && + Mock.vkBindBufferMemory_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkBindBufferMemory_CallbackFunctionPointer(device, buffer, memory, memoryOffset, Mock.vkBindBufferMemory_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkBindBufferMemory,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_buffer) + { + UNITY_SET_DETAILS(CMockString_vkBindBufferMemory,CMockString_buffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_memory) + { + UNITY_SET_DETAILS(CMockString_vkBindBufferMemory,CMockString_memory); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_memory), (void*)(&memory), sizeof(VkDeviceMemory), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_memoryOffset) + { + UNITY_SET_DETAILS(CMockString_vkBindBufferMemory,CMockString_memoryOffset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_memoryOffset), (void*)(&memoryOffset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkBindBufferMemory_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkBindBufferMemory_CallbackFunctionPointer(device, buffer, memory, memoryOffset, Mock.vkBindBufferMemory_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkBindBufferMemory(CMOCK_vkBindBufferMemory_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); +void CMockExpectParameters_vkBindBufferMemory(CMOCK_vkBindBufferMemory_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), + sizeof(VkBuffer[sizeof(buffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_buffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_memory), (void*)(&memory), + sizeof(VkDeviceMemory[sizeof(memory) == sizeof(VkDeviceMemory) ? 1 : -1])); /* add VkDeviceMemory to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_memory = 0; + memcpy((void*)(&cmock_call_instance->Expected_memoryOffset), (void*)(&memoryOffset), + sizeof(VkDeviceSize[sizeof(memoryOffset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_memoryOffset = 0; +} + +void vkBindBufferMemory_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBindBufferMemory_CALL_INSTANCE)); + CMOCK_vkBindBufferMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindBufferMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBindBufferMemory_CallInstance = CMock_Guts_MemChain(Mock.vkBindBufferMemory_CallInstance, cmock_guts_index); + Mock.vkBindBufferMemory_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkBindBufferMemory_IgnoreBool = (char)1; +} + +void vkBindBufferMemory_CMockStopIgnore(void) +{ + if(Mock.vkBindBufferMemory_IgnoreBool) + Mock.vkBindBufferMemory_CallInstance = CMock_Guts_MemNext(Mock.vkBindBufferMemory_CallInstance); + Mock.vkBindBufferMemory_IgnoreBool = (char)0; +} + +void vkBindBufferMemory_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBindBufferMemory_CALL_INSTANCE)); + CMOCK_vkBindBufferMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindBufferMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBindBufferMemory_CallInstance = CMock_Guts_MemChain(Mock.vkBindBufferMemory_CallInstance, cmock_guts_index); + Mock.vkBindBufferMemory_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkBindBufferMemory_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBindBufferMemory_CALL_INSTANCE)); + CMOCK_vkBindBufferMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindBufferMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBindBufferMemory_CallInstance = CMock_Guts_MemChain(Mock.vkBindBufferMemory_CallInstance, cmock_guts_index); + Mock.vkBindBufferMemory_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkBindBufferMemory(cmock_call_instance, device, buffer, memory, memoryOffset); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkBindBufferMemory_AddCallback(CMOCK_vkBindBufferMemory_CALLBACK Callback) +{ + Mock.vkBindBufferMemory_IgnoreBool = (char)0; + Mock.vkBindBufferMemory_CallbackBool = (char)1; + Mock.vkBindBufferMemory_CallbackFunctionPointer = Callback; +} + +void vkBindBufferMemory_Stub(CMOCK_vkBindBufferMemory_CALLBACK Callback) +{ + Mock.vkBindBufferMemory_IgnoreBool = (char)0; + Mock.vkBindBufferMemory_CallbackBool = (char)0; + Mock.vkBindBufferMemory_CallbackFunctionPointer = Callback; +} + +void vkBindBufferMemory_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindBufferMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindBufferMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindBufferMemory_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkBindBufferMemory_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindBufferMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindBufferMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindBufferMemory_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_buffer = 1; +} + +void vkBindBufferMemory_CMockIgnoreArg_memory(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindBufferMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindBufferMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindBufferMemory_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_memory = 1; +} + +void vkBindBufferMemory_CMockIgnoreArg_memoryOffset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindBufferMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindBufferMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindBufferMemory_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_memoryOffset = 1; +} + +VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkBindImageMemory_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkBindImageMemory); + cmock_call_instance = (CMOCK_vkBindImageMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkBindImageMemory_CallInstance); + Mock.vkBindImageMemory_CallInstance = CMock_Guts_MemNext(Mock.vkBindImageMemory_CallInstance); + if (Mock.vkBindImageMemory_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkBindImageMemory_FinalReturn; + memcpy((void*)(&Mock.vkBindImageMemory_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkBindImageMemory_CallbackBool && + Mock.vkBindImageMemory_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkBindImageMemory_CallbackFunctionPointer(device, image, memory, memoryOffset, Mock.vkBindImageMemory_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkBindImageMemory,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_image) + { + UNITY_SET_DETAILS(CMockString_vkBindImageMemory,CMockString_image); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_image), (void*)(&image), sizeof(VkImage), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_memory) + { + UNITY_SET_DETAILS(CMockString_vkBindImageMemory,CMockString_memory); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_memory), (void*)(&memory), sizeof(VkDeviceMemory), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_memoryOffset) + { + UNITY_SET_DETAILS(CMockString_vkBindImageMemory,CMockString_memoryOffset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_memoryOffset), (void*)(&memoryOffset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkBindImageMemory_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkBindImageMemory_CallbackFunctionPointer(device, image, memory, memoryOffset, Mock.vkBindImageMemory_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkBindImageMemory(CMOCK_vkBindImageMemory_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); +void CMockExpectParameters_vkBindImageMemory(CMOCK_vkBindImageMemory_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_image), (void*)(&image), + sizeof(VkImage[sizeof(image) == sizeof(VkImage) ? 1 : -1])); /* add VkImage to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_image = 0; + memcpy((void*)(&cmock_call_instance->Expected_memory), (void*)(&memory), + sizeof(VkDeviceMemory[sizeof(memory) == sizeof(VkDeviceMemory) ? 1 : -1])); /* add VkDeviceMemory to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_memory = 0; + memcpy((void*)(&cmock_call_instance->Expected_memoryOffset), (void*)(&memoryOffset), + sizeof(VkDeviceSize[sizeof(memoryOffset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_memoryOffset = 0; +} + +void vkBindImageMemory_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBindImageMemory_CALL_INSTANCE)); + CMOCK_vkBindImageMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindImageMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBindImageMemory_CallInstance = CMock_Guts_MemChain(Mock.vkBindImageMemory_CallInstance, cmock_guts_index); + Mock.vkBindImageMemory_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkBindImageMemory_IgnoreBool = (char)1; +} + +void vkBindImageMemory_CMockStopIgnore(void) +{ + if(Mock.vkBindImageMemory_IgnoreBool) + Mock.vkBindImageMemory_CallInstance = CMock_Guts_MemNext(Mock.vkBindImageMemory_CallInstance); + Mock.vkBindImageMemory_IgnoreBool = (char)0; +} + +void vkBindImageMemory_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBindImageMemory_CALL_INSTANCE)); + CMOCK_vkBindImageMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindImageMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBindImageMemory_CallInstance = CMock_Guts_MemChain(Mock.vkBindImageMemory_CallInstance, cmock_guts_index); + Mock.vkBindImageMemory_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkBindImageMemory_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBindImageMemory_CALL_INSTANCE)); + CMOCK_vkBindImageMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindImageMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBindImageMemory_CallInstance = CMock_Guts_MemChain(Mock.vkBindImageMemory_CallInstance, cmock_guts_index); + Mock.vkBindImageMemory_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkBindImageMemory(cmock_call_instance, device, image, memory, memoryOffset); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkBindImageMemory_AddCallback(CMOCK_vkBindImageMemory_CALLBACK Callback) +{ + Mock.vkBindImageMemory_IgnoreBool = (char)0; + Mock.vkBindImageMemory_CallbackBool = (char)1; + Mock.vkBindImageMemory_CallbackFunctionPointer = Callback; +} + +void vkBindImageMemory_Stub(CMOCK_vkBindImageMemory_CALLBACK Callback) +{ + Mock.vkBindImageMemory_IgnoreBool = (char)0; + Mock.vkBindImageMemory_CallbackBool = (char)0; + Mock.vkBindImageMemory_CallbackFunctionPointer = Callback; +} + +void vkBindImageMemory_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindImageMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindImageMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindImageMemory_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkBindImageMemory_CMockIgnoreArg_image(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindImageMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindImageMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindImageMemory_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_image = 1; +} + +void vkBindImageMemory_CMockIgnoreArg_memory(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindImageMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindImageMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindImageMemory_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_memory = 1; +} + +void vkBindImageMemory_CMockIgnoreArg_memoryOffset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindImageMemory_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindImageMemory_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindImageMemory_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_memoryOffset = 1; +} + +void vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetBufferMemoryRequirements_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetBufferMemoryRequirements); + cmock_call_instance = (CMOCK_vkGetBufferMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetBufferMemoryRequirements_CallInstance); + Mock.vkGetBufferMemoryRequirements_CallInstance = CMock_Guts_MemNext(Mock.vkGetBufferMemoryRequirements_CallInstance); + if (Mock.vkGetBufferMemoryRequirements_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetBufferMemoryRequirements_CallbackBool && + Mock.vkGetBufferMemoryRequirements_CallbackFunctionPointer != NULL) + { + Mock.vkGetBufferMemoryRequirements_CallbackFunctionPointer(device, buffer, pMemoryRequirements, Mock.vkGetBufferMemoryRequirements_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetBufferMemoryRequirements,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_buffer) + { + UNITY_SET_DETAILS(CMockString_vkGetBufferMemoryRequirements,CMockString_buffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMemoryRequirements) + { + UNITY_SET_DETAILS(CMockString_vkGetBufferMemoryRequirements,CMockString_pMemoryRequirements); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMemoryRequirements), (void*)(pMemoryRequirements), sizeof(VkMemoryRequirements), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetBufferMemoryRequirements_CallbackFunctionPointer != NULL) + { + Mock.vkGetBufferMemoryRequirements_CallbackFunctionPointer(device, buffer, pMemoryRequirements, Mock.vkGetBufferMemoryRequirements_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pMemoryRequirements, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pMemoryRequirements, (const void*)cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Val, + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetBufferMemoryRequirements(CMOCK_vkGetBufferMemoryRequirements_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); +void CMockExpectParameters_vkGetBufferMemoryRequirements(CMOCK_vkGetBufferMemoryRequirements_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), + sizeof(VkBuffer[sizeof(buffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_buffer = 0; + cmock_call_instance->Expected_pMemoryRequirements = pMemoryRequirements; + cmock_call_instance->IgnoreArg_pMemoryRequirements = 0; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used = 0; +} + +void vkGetBufferMemoryRequirements_CMockIgnore(void) +{ + Mock.vkGetBufferMemoryRequirements_IgnoreBool = (char)1; +} + +void vkGetBufferMemoryRequirements_CMockStopIgnore(void) +{ + Mock.vkGetBufferMemoryRequirements_IgnoreBool = (char)0; +} + +void vkGetBufferMemoryRequirements_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetBufferMemoryRequirements_CALL_INSTANCE)); + CMOCK_vkGetBufferMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetBufferMemoryRequirements_CallInstance = CMock_Guts_MemChain(Mock.vkGetBufferMemoryRequirements_CallInstance, cmock_guts_index); + Mock.vkGetBufferMemoryRequirements_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetBufferMemoryRequirements_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetBufferMemoryRequirements_CALL_INSTANCE)); + CMOCK_vkGetBufferMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetBufferMemoryRequirements_CallInstance = CMock_Guts_MemChain(Mock.vkGetBufferMemoryRequirements_CallInstance, cmock_guts_index); + Mock.vkGetBufferMemoryRequirements_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetBufferMemoryRequirements(cmock_call_instance, device, buffer, pMemoryRequirements); +} + +void vkGetBufferMemoryRequirements_AddCallback(CMOCK_vkGetBufferMemoryRequirements_CALLBACK Callback) +{ + Mock.vkGetBufferMemoryRequirements_IgnoreBool = (char)0; + Mock.vkGetBufferMemoryRequirements_CallbackBool = (char)1; + Mock.vkGetBufferMemoryRequirements_CallbackFunctionPointer = Callback; +} + +void vkGetBufferMemoryRequirements_Stub(CMOCK_vkGetBufferMemoryRequirements_CALLBACK Callback) +{ + Mock.vkGetBufferMemoryRequirements_IgnoreBool = (char)0; + Mock.vkGetBufferMemoryRequirements_CallbackBool = (char)0; + Mock.vkGetBufferMemoryRequirements_CallbackFunctionPointer = Callback; +} + +void vkGetBufferMemoryRequirements_CMockReturnMemThruPtr_pMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkMemoryRequirements const* pMemoryRequirements, size_t cmock_size) +{ + CMOCK_vkGetBufferMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetBufferMemoryRequirements_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used = 1; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Val = pMemoryRequirements; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Size = cmock_size; +} + +void vkGetBufferMemoryRequirements_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetBufferMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetBufferMemoryRequirements_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetBufferMemoryRequirements_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetBufferMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetBufferMemoryRequirements_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_buffer = 1; +} + +void vkGetBufferMemoryRequirements_CMockIgnoreArg_pMemoryRequirements(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetBufferMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetBufferMemoryRequirements_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMemoryRequirements = 1; +} + +void vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetImageMemoryRequirements_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetImageMemoryRequirements); + cmock_call_instance = (CMOCK_vkGetImageMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetImageMemoryRequirements_CallInstance); + Mock.vkGetImageMemoryRequirements_CallInstance = CMock_Guts_MemNext(Mock.vkGetImageMemoryRequirements_CallInstance); + if (Mock.vkGetImageMemoryRequirements_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetImageMemoryRequirements_CallbackBool && + Mock.vkGetImageMemoryRequirements_CallbackFunctionPointer != NULL) + { + Mock.vkGetImageMemoryRequirements_CallbackFunctionPointer(device, image, pMemoryRequirements, Mock.vkGetImageMemoryRequirements_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetImageMemoryRequirements,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_image) + { + UNITY_SET_DETAILS(CMockString_vkGetImageMemoryRequirements,CMockString_image); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_image), (void*)(&image), sizeof(VkImage), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMemoryRequirements) + { + UNITY_SET_DETAILS(CMockString_vkGetImageMemoryRequirements,CMockString_pMemoryRequirements); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMemoryRequirements), (void*)(pMemoryRequirements), sizeof(VkMemoryRequirements), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetImageMemoryRequirements_CallbackFunctionPointer != NULL) + { + Mock.vkGetImageMemoryRequirements_CallbackFunctionPointer(device, image, pMemoryRequirements, Mock.vkGetImageMemoryRequirements_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pMemoryRequirements, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pMemoryRequirements, (const void*)cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Val, + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetImageMemoryRequirements(CMOCK_vkGetImageMemoryRequirements_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); +void CMockExpectParameters_vkGetImageMemoryRequirements(CMOCK_vkGetImageMemoryRequirements_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_image), (void*)(&image), + sizeof(VkImage[sizeof(image) == sizeof(VkImage) ? 1 : -1])); /* add VkImage to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_image = 0; + cmock_call_instance->Expected_pMemoryRequirements = pMemoryRequirements; + cmock_call_instance->IgnoreArg_pMemoryRequirements = 0; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used = 0; +} + +void vkGetImageMemoryRequirements_CMockIgnore(void) +{ + Mock.vkGetImageMemoryRequirements_IgnoreBool = (char)1; +} + +void vkGetImageMemoryRequirements_CMockStopIgnore(void) +{ + Mock.vkGetImageMemoryRequirements_IgnoreBool = (char)0; +} + +void vkGetImageMemoryRequirements_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageMemoryRequirements_CALL_INSTANCE)); + CMOCK_vkGetImageMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageMemoryRequirements_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageMemoryRequirements_CallInstance, cmock_guts_index); + Mock.vkGetImageMemoryRequirements_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetImageMemoryRequirements_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageMemoryRequirements_CALL_INSTANCE)); + CMOCK_vkGetImageMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageMemoryRequirements_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageMemoryRequirements_CallInstance, cmock_guts_index); + Mock.vkGetImageMemoryRequirements_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetImageMemoryRequirements(cmock_call_instance, device, image, pMemoryRequirements); +} + +void vkGetImageMemoryRequirements_AddCallback(CMOCK_vkGetImageMemoryRequirements_CALLBACK Callback) +{ + Mock.vkGetImageMemoryRequirements_IgnoreBool = (char)0; + Mock.vkGetImageMemoryRequirements_CallbackBool = (char)1; + Mock.vkGetImageMemoryRequirements_CallbackFunctionPointer = Callback; +} + +void vkGetImageMemoryRequirements_Stub(CMOCK_vkGetImageMemoryRequirements_CALLBACK Callback) +{ + Mock.vkGetImageMemoryRequirements_IgnoreBool = (char)0; + Mock.vkGetImageMemoryRequirements_CallbackBool = (char)0; + Mock.vkGetImageMemoryRequirements_CallbackFunctionPointer = Callback; +} + +void vkGetImageMemoryRequirements_CMockReturnMemThruPtr_pMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkMemoryRequirements const* pMemoryRequirements, size_t cmock_size) +{ + CMOCK_vkGetImageMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageMemoryRequirements_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used = 1; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Val = pMemoryRequirements; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Size = cmock_size; +} + +void vkGetImageMemoryRequirements_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageMemoryRequirements_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetImageMemoryRequirements_CMockIgnoreArg_image(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageMemoryRequirements_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_image = 1; +} + +void vkGetImageMemoryRequirements_CMockIgnoreArg_pMemoryRequirements(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageMemoryRequirements_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMemoryRequirements = 1; +} + +void vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetImageSparseMemoryRequirements_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetImageSparseMemoryRequirements); + cmock_call_instance = (CMOCK_vkGetImageSparseMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetImageSparseMemoryRequirements_CallInstance); + Mock.vkGetImageSparseMemoryRequirements_CallInstance = CMock_Guts_MemNext(Mock.vkGetImageSparseMemoryRequirements_CallInstance); + if (Mock.vkGetImageSparseMemoryRequirements_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetImageSparseMemoryRequirements_CallbackBool && + Mock.vkGetImageSparseMemoryRequirements_CallbackFunctionPointer != NULL) + { + Mock.vkGetImageSparseMemoryRequirements_CallbackFunctionPointer(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements, Mock.vkGetImageSparseMemoryRequirements_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetImageSparseMemoryRequirements,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_image) + { + UNITY_SET_DETAILS(CMockString_vkGetImageSparseMemoryRequirements,CMockString_image); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_image), (void*)(&image), sizeof(VkImage), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSparseMemoryRequirementCount) + { + UNITY_SET_DETAILS(CMockString_vkGetImageSparseMemoryRequirements,CMockString_pSparseMemoryRequirementCount); + if (cmock_call_instance->Expected_pSparseMemoryRequirementCount == NULL) + { UNITY_TEST_ASSERT_NULL(pSparseMemoryRequirementCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pSparseMemoryRequirementCount, pSparseMemoryRequirementCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pSparseMemoryRequirements) + { + UNITY_SET_DETAILS(CMockString_vkGetImageSparseMemoryRequirements,CMockString_pSparseMemoryRequirements); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSparseMemoryRequirements), (void*)(pSparseMemoryRequirements), sizeof(VkSparseImageMemoryRequirements), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetImageSparseMemoryRequirements_CallbackFunctionPointer != NULL) + { + Mock.vkGetImageSparseMemoryRequirements_CallbackFunctionPointer(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements, Mock.vkGetImageSparseMemoryRequirements_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSparseMemoryRequirementCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSparseMemoryRequirementCount, (const void*)cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Val, + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSparseMemoryRequirements, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSparseMemoryRequirements, (const void*)cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Val, + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetImageSparseMemoryRequirements(CMOCK_vkGetImageSparseMemoryRequirements_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements); +void CMockExpectParameters_vkGetImageSparseMemoryRequirements(CMOCK_vkGetImageSparseMemoryRequirements_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_image), (void*)(&image), + sizeof(VkImage[sizeof(image) == sizeof(VkImage) ? 1 : -1])); /* add VkImage to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_image = 0; + cmock_call_instance->Expected_pSparseMemoryRequirementCount = pSparseMemoryRequirementCount; + cmock_call_instance->IgnoreArg_pSparseMemoryRequirementCount = 0; + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Used = 0; + cmock_call_instance->Expected_pSparseMemoryRequirements = pSparseMemoryRequirements; + cmock_call_instance->IgnoreArg_pSparseMemoryRequirements = 0; + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Used = 0; +} + +void vkGetImageSparseMemoryRequirements_CMockIgnore(void) +{ + Mock.vkGetImageSparseMemoryRequirements_IgnoreBool = (char)1; +} + +void vkGetImageSparseMemoryRequirements_CMockStopIgnore(void) +{ + Mock.vkGetImageSparseMemoryRequirements_IgnoreBool = (char)0; +} + +void vkGetImageSparseMemoryRequirements_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageSparseMemoryRequirements_CALL_INSTANCE)); + CMOCK_vkGetImageSparseMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSparseMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageSparseMemoryRequirements_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageSparseMemoryRequirements_CallInstance, cmock_guts_index); + Mock.vkGetImageSparseMemoryRequirements_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetImageSparseMemoryRequirements_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageSparseMemoryRequirements_CALL_INSTANCE)); + CMOCK_vkGetImageSparseMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSparseMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageSparseMemoryRequirements_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageSparseMemoryRequirements_CallInstance, cmock_guts_index); + Mock.vkGetImageSparseMemoryRequirements_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetImageSparseMemoryRequirements(cmock_call_instance, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); +} + +void vkGetImageSparseMemoryRequirements_AddCallback(CMOCK_vkGetImageSparseMemoryRequirements_CALLBACK Callback) +{ + Mock.vkGetImageSparseMemoryRequirements_IgnoreBool = (char)0; + Mock.vkGetImageSparseMemoryRequirements_CallbackBool = (char)1; + Mock.vkGetImageSparseMemoryRequirements_CallbackFunctionPointer = Callback; +} + +void vkGetImageSparseMemoryRequirements_Stub(CMOCK_vkGetImageSparseMemoryRequirements_CALLBACK Callback) +{ + Mock.vkGetImageSparseMemoryRequirements_IgnoreBool = (char)0; + Mock.vkGetImageSparseMemoryRequirements_CallbackBool = (char)0; + Mock.vkGetImageSparseMemoryRequirements_CallbackFunctionPointer = Callback; +} + +void vkGetImageSparseMemoryRequirements_CMockReturnMemThruPtr_pSparseMemoryRequirementCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pSparseMemoryRequirementCount, size_t cmock_size) +{ + CMOCK_vkGetImageSparseMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSparseMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageSparseMemoryRequirements_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Val = pSparseMemoryRequirementCount; + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Size = cmock_size; +} + +void vkGetImageSparseMemoryRequirements_CMockReturnMemThruPtr_pSparseMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkSparseImageMemoryRequirements const* pSparseMemoryRequirements, size_t cmock_size) +{ + CMOCK_vkGetImageSparseMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSparseMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageSparseMemoryRequirements_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Used = 1; + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Val = pSparseMemoryRequirements; + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Size = cmock_size; +} + +void vkGetImageSparseMemoryRequirements_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageSparseMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSparseMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageSparseMemoryRequirements_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetImageSparseMemoryRequirements_CMockIgnoreArg_image(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageSparseMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSparseMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageSparseMemoryRequirements_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_image = 1; +} + +void vkGetImageSparseMemoryRequirements_CMockIgnoreArg_pSparseMemoryRequirementCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageSparseMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSparseMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageSparseMemoryRequirements_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSparseMemoryRequirementCount = 1; +} + +void vkGetImageSparseMemoryRequirements_CMockIgnoreArg_pSparseMemoryRequirements(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageSparseMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSparseMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageSparseMemoryRequirements_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSparseMemoryRequirements = 1; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceSparseImageFormatProperties); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceSparseImageFormatProperties_CallInstance); + Mock.vkGetPhysicalDeviceSparseImageFormatProperties_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceSparseImageFormatProperties_CallInstance); + if (Mock.vkGetPhysicalDeviceSparseImageFormatProperties_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetPhysicalDeviceSparseImageFormatProperties_CallbackBool && + Mock.vkGetPhysicalDeviceSparseImageFormatProperties_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceSparseImageFormatProperties_CallbackFunctionPointer(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties, Mock.vkGetPhysicalDeviceSparseImageFormatProperties_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSparseImageFormatProperties,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_format) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSparseImageFormatProperties,CMockString_format); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_format), (void*)(&format), sizeof(VkFormat), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_type) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSparseImageFormatProperties,CMockString_type); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_type), (void*)(&type), sizeof(VkImageType), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_samples) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSparseImageFormatProperties,CMockString_samples); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_samples), (void*)(&samples), sizeof(VkSampleCountFlagBits), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_usage) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSparseImageFormatProperties,CMockString_usage); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_usage), (void*)(&usage), sizeof(VkImageUsageFlags), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_tiling) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSparseImageFormatProperties,CMockString_tiling); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_tiling), (void*)(&tiling), sizeof(VkImageTiling), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPropertyCount) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSparseImageFormatProperties,CMockString_pPropertyCount); + if (cmock_call_instance->Expected_pPropertyCount == NULL) + { UNITY_TEST_ASSERT_NULL(pPropertyCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pPropertyCount, pPropertyCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSparseImageFormatProperties,CMockString_pProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pProperties), (void*)(pProperties), sizeof(VkSparseImageFormatProperties), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceSparseImageFormatProperties_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceSparseImageFormatProperties_CallbackFunctionPointer(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties, Mock.vkGetPhysicalDeviceSparseImageFormatProperties_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPropertyCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPropertyCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPropertyCount, (const void*)cmock_call_instance->ReturnThruPtr_pPropertyCount_Val, + cmock_call_instance->ReturnThruPtr_pPropertyCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pProperties, (const void*)cmock_call_instance->ReturnThruPtr_pProperties_Val, + cmock_call_instance->ReturnThruPtr_pProperties_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetPhysicalDeviceSparseImageFormatProperties(CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties); +void CMockExpectParameters_vkGetPhysicalDeviceSparseImageFormatProperties(CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + memcpy((void*)(&cmock_call_instance->Expected_format), (void*)(&format), + sizeof(VkFormat[sizeof(format) == sizeof(VkFormat) ? 1 : -1])); /* add VkFormat to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_format = 0; + memcpy((void*)(&cmock_call_instance->Expected_type), (void*)(&type), + sizeof(VkImageType[sizeof(type) == sizeof(VkImageType) ? 1 : -1])); /* add VkImageType to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_type = 0; + memcpy((void*)(&cmock_call_instance->Expected_samples), (void*)(&samples), + sizeof(VkSampleCountFlagBits[sizeof(samples) == sizeof(VkSampleCountFlagBits) ? 1 : -1])); /* add VkSampleCountFlagBits to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_samples = 0; + memcpy((void*)(&cmock_call_instance->Expected_usage), (void*)(&usage), + sizeof(VkImageUsageFlags[sizeof(usage) == sizeof(VkImageUsageFlags) ? 1 : -1])); /* add VkImageUsageFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_usage = 0; + memcpy((void*)(&cmock_call_instance->Expected_tiling), (void*)(&tiling), + sizeof(VkImageTiling[sizeof(tiling) == sizeof(VkImageTiling) ? 1 : -1])); /* add VkImageTiling to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_tiling = 0; + cmock_call_instance->Expected_pPropertyCount = pPropertyCount; + cmock_call_instance->IgnoreArg_pPropertyCount = 0; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Used = 0; + cmock_call_instance->Expected_pProperties = pProperties; + cmock_call_instance->IgnoreArg_pProperties = 0; + cmock_call_instance->ReturnThruPtr_pProperties_Used = 0; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties_CMockIgnore(void) +{ + Mock.vkGetPhysicalDeviceSparseImageFormatProperties_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties_CMockStopIgnore(void) +{ + Mock.vkGetPhysicalDeviceSparseImageFormatProperties_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceSparseImageFormatProperties_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceSparseImageFormatProperties_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceSparseImageFormatProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceSparseImageFormatProperties_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceSparseImageFormatProperties_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceSparseImageFormatProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceSparseImageFormatProperties(cmock_call_instance, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); +} + +void vkGetPhysicalDeviceSparseImageFormatProperties_AddCallback(CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceSparseImageFormatProperties_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceSparseImageFormatProperties_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceSparseImageFormatProperties_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties_Stub(CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceSparseImageFormatProperties_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceSparseImageFormatProperties_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceSparseImageFormatProperties_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties_CMockReturnMemThruPtr_pPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPropertyCount, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSparseImageFormatProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPropertyCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Val = pPropertyCount; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Size = cmock_size; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkSparseImageFormatProperties const* pProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSparseImageFormatProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pProperties_Val = pProperties; + cmock_call_instance->ReturnThruPtr_pProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSparseImageFormatProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties_CMockIgnoreArg_format(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSparseImageFormatProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_format = 1; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties_CMockIgnoreArg_type(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSparseImageFormatProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_type = 1; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties_CMockIgnoreArg_samples(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSparseImageFormatProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_samples = 1; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties_CMockIgnoreArg_usage(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSparseImageFormatProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_usage = 1; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties_CMockIgnoreArg_tiling(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSparseImageFormatProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_tiling = 1; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties_CMockIgnoreArg_pPropertyCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSparseImageFormatProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPropertyCount = 1; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSparseImageFormatProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pProperties = 1; +} + +VkResult vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkQueueBindSparse_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkQueueBindSparse); + cmock_call_instance = (CMOCK_vkQueueBindSparse_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkQueueBindSparse_CallInstance); + Mock.vkQueueBindSparse_CallInstance = CMock_Guts_MemNext(Mock.vkQueueBindSparse_CallInstance); + if (Mock.vkQueueBindSparse_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkQueueBindSparse_FinalReturn; + memcpy((void*)(&Mock.vkQueueBindSparse_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkQueueBindSparse_CallbackBool && + Mock.vkQueueBindSparse_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkQueueBindSparse_CallbackFunctionPointer(queue, bindInfoCount, pBindInfo, fence, Mock.vkQueueBindSparse_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_queue) + { + UNITY_SET_DETAILS(CMockString_vkQueueBindSparse,CMockString_queue); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queue), (void*)(&queue), sizeof(VkQueue), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_bindInfoCount) + { + UNITY_SET_DETAILS(CMockString_vkQueueBindSparse,CMockString_bindInfoCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_bindInfoCount, bindInfoCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pBindInfo) + { + UNITY_SET_DETAILS(CMockString_vkQueueBindSparse,CMockString_pBindInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pBindInfo), (void*)(pBindInfo), sizeof(const VkBindSparseInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_fence) + { + UNITY_SET_DETAILS(CMockString_vkQueueBindSparse,CMockString_fence); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_fence), (void*)(&fence), sizeof(VkFence), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkQueueBindSparse_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkQueueBindSparse_CallbackFunctionPointer(queue, bindInfoCount, pBindInfo, fence, Mock.vkQueueBindSparse_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkQueueBindSparse(CMOCK_vkQueueBindSparse_CALL_INSTANCE* cmock_call_instance, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence); +void CMockExpectParameters_vkQueueBindSparse(CMOCK_vkQueueBindSparse_CALL_INSTANCE* cmock_call_instance, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) +{ + memcpy((void*)(&cmock_call_instance->Expected_queue), (void*)(&queue), + sizeof(VkQueue[sizeof(queue) == sizeof(VkQueue) ? 1 : -1])); /* add VkQueue to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queue = 0; + cmock_call_instance->Expected_bindInfoCount = bindInfoCount; + cmock_call_instance->IgnoreArg_bindInfoCount = 0; + cmock_call_instance->Expected_pBindInfo = pBindInfo; + cmock_call_instance->IgnoreArg_pBindInfo = 0; + memcpy((void*)(&cmock_call_instance->Expected_fence), (void*)(&fence), + sizeof(VkFence[sizeof(fence) == sizeof(VkFence) ? 1 : -1])); /* add VkFence to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_fence = 0; +} + +void vkQueueBindSparse_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkQueueBindSparse_CALL_INSTANCE)); + CMOCK_vkQueueBindSparse_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueBindSparse_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkQueueBindSparse_CallInstance = CMock_Guts_MemChain(Mock.vkQueueBindSparse_CallInstance, cmock_guts_index); + Mock.vkQueueBindSparse_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkQueueBindSparse_IgnoreBool = (char)1; +} + +void vkQueueBindSparse_CMockStopIgnore(void) +{ + if(Mock.vkQueueBindSparse_IgnoreBool) + Mock.vkQueueBindSparse_CallInstance = CMock_Guts_MemNext(Mock.vkQueueBindSparse_CallInstance); + Mock.vkQueueBindSparse_IgnoreBool = (char)0; +} + +void vkQueueBindSparse_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkQueueBindSparse_CALL_INSTANCE)); + CMOCK_vkQueueBindSparse_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueBindSparse_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkQueueBindSparse_CallInstance = CMock_Guts_MemChain(Mock.vkQueueBindSparse_CallInstance, cmock_guts_index); + Mock.vkQueueBindSparse_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkQueueBindSparse_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkQueueBindSparse_CALL_INSTANCE)); + CMOCK_vkQueueBindSparse_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueBindSparse_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkQueueBindSparse_CallInstance = CMock_Guts_MemChain(Mock.vkQueueBindSparse_CallInstance, cmock_guts_index); + Mock.vkQueueBindSparse_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkQueueBindSparse(cmock_call_instance, queue, bindInfoCount, pBindInfo, fence); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkQueueBindSparse_AddCallback(CMOCK_vkQueueBindSparse_CALLBACK Callback) +{ + Mock.vkQueueBindSparse_IgnoreBool = (char)0; + Mock.vkQueueBindSparse_CallbackBool = (char)1; + Mock.vkQueueBindSparse_CallbackFunctionPointer = Callback; +} + +void vkQueueBindSparse_Stub(CMOCK_vkQueueBindSparse_CALLBACK Callback) +{ + Mock.vkQueueBindSparse_IgnoreBool = (char)0; + Mock.vkQueueBindSparse_CallbackBool = (char)0; + Mock.vkQueueBindSparse_CallbackFunctionPointer = Callback; +} + +void vkQueueBindSparse_CMockIgnoreArg_queue(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkQueueBindSparse_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueBindSparse_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkQueueBindSparse_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queue = 1; +} + +void vkQueueBindSparse_CMockIgnoreArg_bindInfoCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkQueueBindSparse_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueBindSparse_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkQueueBindSparse_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_bindInfoCount = 1; +} + +void vkQueueBindSparse_CMockIgnoreArg_pBindInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkQueueBindSparse_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueBindSparse_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkQueueBindSparse_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pBindInfo = 1; +} + +void vkQueueBindSparse_CMockIgnoreArg_fence(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkQueueBindSparse_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueBindSparse_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkQueueBindSparse_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_fence = 1; +} + +VkResult vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateFence_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateFence); + cmock_call_instance = (CMOCK_vkCreateFence_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateFence_CallInstance); + Mock.vkCreateFence_CallInstance = CMock_Guts_MemNext(Mock.vkCreateFence_CallInstance); + if (Mock.vkCreateFence_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateFence_FinalReturn; + memcpy((void*)(&Mock.vkCreateFence_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateFence_CallbackBool && + Mock.vkCreateFence_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateFence_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pFence, Mock.vkCreateFence_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateFence,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateFence,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkFenceCreateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateFence,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pFence) + { + UNITY_SET_DETAILS(CMockString_vkCreateFence,CMockString_pFence); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pFence), (void*)(pFence), sizeof(VkFence), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateFence_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateFence_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pFence, Mock.vkCreateFence_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pFence_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pFence, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pFence, (const void*)cmock_call_instance->ReturnThruPtr_pFence_Val, + cmock_call_instance->ReturnThruPtr_pFence_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateFence(CMOCK_vkCreateFence_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); +void CMockExpectParameters_vkCreateFence(CMOCK_vkCreateFence_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pFence = pFence; + cmock_call_instance->IgnoreArg_pFence = 0; + cmock_call_instance->ReturnThruPtr_pFence_Used = 0; +} + +void vkCreateFence_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateFence_CALL_INSTANCE)); + CMOCK_vkCreateFence_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateFence_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateFence_CallInstance = CMock_Guts_MemChain(Mock.vkCreateFence_CallInstance, cmock_guts_index); + Mock.vkCreateFence_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateFence_IgnoreBool = (char)1; +} + +void vkCreateFence_CMockStopIgnore(void) +{ + if(Mock.vkCreateFence_IgnoreBool) + Mock.vkCreateFence_CallInstance = CMock_Guts_MemNext(Mock.vkCreateFence_CallInstance); + Mock.vkCreateFence_IgnoreBool = (char)0; +} + +void vkCreateFence_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateFence_CALL_INSTANCE)); + CMOCK_vkCreateFence_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateFence_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateFence_CallInstance = CMock_Guts_MemChain(Mock.vkCreateFence_CallInstance, cmock_guts_index); + Mock.vkCreateFence_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateFence_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateFence_CALL_INSTANCE)); + CMOCK_vkCreateFence_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateFence_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateFence_CallInstance = CMock_Guts_MemChain(Mock.vkCreateFence_CallInstance, cmock_guts_index); + Mock.vkCreateFence_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateFence(cmock_call_instance, device, pCreateInfo, pAllocator, pFence); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateFence_AddCallback(CMOCK_vkCreateFence_CALLBACK Callback) +{ + Mock.vkCreateFence_IgnoreBool = (char)0; + Mock.vkCreateFence_CallbackBool = (char)1; + Mock.vkCreateFence_CallbackFunctionPointer = Callback; +} + +void vkCreateFence_Stub(CMOCK_vkCreateFence_CALLBACK Callback) +{ + Mock.vkCreateFence_IgnoreBool = (char)0; + Mock.vkCreateFence_CallbackBool = (char)0; + Mock.vkCreateFence_CallbackFunctionPointer = Callback; +} + +void vkCreateFence_CMockReturnMemThruPtr_pFence(UNITY_LINE_TYPE cmock_line, VkFence const* pFence, size_t cmock_size) +{ + CMOCK_vkCreateFence_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateFence_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateFence_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pFence_Used = 1; + cmock_call_instance->ReturnThruPtr_pFence_Val = pFence; + cmock_call_instance->ReturnThruPtr_pFence_Size = cmock_size; +} + +void vkCreateFence_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateFence_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateFence_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateFence_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateFence_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateFence_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateFence_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateFence_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateFence_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateFence_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateFence_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateFence_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateFence_CMockIgnoreArg_pFence(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateFence_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateFence_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateFence_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pFence = 1; +} + +void vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyFence_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyFence); + cmock_call_instance = (CMOCK_vkDestroyFence_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyFence_CallInstance); + Mock.vkDestroyFence_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyFence_CallInstance); + if (Mock.vkDestroyFence_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyFence_CallbackBool && + Mock.vkDestroyFence_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyFence_CallbackFunctionPointer(device, fence, pAllocator, Mock.vkDestroyFence_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyFence,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_fence) + { + UNITY_SET_DETAILS(CMockString_vkDestroyFence,CMockString_fence); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_fence), (void*)(&fence), sizeof(VkFence), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyFence,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyFence_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyFence_CallbackFunctionPointer(device, fence, pAllocator, Mock.vkDestroyFence_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyFence(CMOCK_vkDestroyFence_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyFence(CMOCK_vkDestroyFence_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_fence), (void*)(&fence), + sizeof(VkFence[sizeof(fence) == sizeof(VkFence) ? 1 : -1])); /* add VkFence to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_fence = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyFence_CMockIgnore(void) +{ + Mock.vkDestroyFence_IgnoreBool = (char)1; +} + +void vkDestroyFence_CMockStopIgnore(void) +{ + Mock.vkDestroyFence_IgnoreBool = (char)0; +} + +void vkDestroyFence_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyFence_CALL_INSTANCE)); + CMOCK_vkDestroyFence_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyFence_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyFence_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyFence_CallInstance, cmock_guts_index); + Mock.vkDestroyFence_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyFence_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyFence_CALL_INSTANCE)); + CMOCK_vkDestroyFence_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyFence_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyFence_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyFence_CallInstance, cmock_guts_index); + Mock.vkDestroyFence_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyFence(cmock_call_instance, device, fence, pAllocator); +} + +void vkDestroyFence_AddCallback(CMOCK_vkDestroyFence_CALLBACK Callback) +{ + Mock.vkDestroyFence_IgnoreBool = (char)0; + Mock.vkDestroyFence_CallbackBool = (char)1; + Mock.vkDestroyFence_CallbackFunctionPointer = Callback; +} + +void vkDestroyFence_Stub(CMOCK_vkDestroyFence_CALLBACK Callback) +{ + Mock.vkDestroyFence_IgnoreBool = (char)0; + Mock.vkDestroyFence_CallbackBool = (char)0; + Mock.vkDestroyFence_CallbackFunctionPointer = Callback; +} + +void vkDestroyFence_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyFence_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyFence_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyFence_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyFence_CMockIgnoreArg_fence(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyFence_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyFence_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyFence_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_fence = 1; +} + +void vkDestroyFence_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyFence_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyFence_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyFence_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +VkResult vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkResetFences_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkResetFences); + cmock_call_instance = (CMOCK_vkResetFences_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkResetFences_CallInstance); + Mock.vkResetFences_CallInstance = CMock_Guts_MemNext(Mock.vkResetFences_CallInstance); + if (Mock.vkResetFences_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkResetFences_FinalReturn; + memcpy((void*)(&Mock.vkResetFences_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkResetFences_CallbackBool && + Mock.vkResetFences_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkResetFences_CallbackFunctionPointer(device, fenceCount, pFences, Mock.vkResetFences_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkResetFences,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_fenceCount) + { + UNITY_SET_DETAILS(CMockString_vkResetFences,CMockString_fenceCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_fenceCount, fenceCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pFences) + { + UNITY_SET_DETAILS(CMockString_vkResetFences,CMockString_pFences); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pFences), (void*)(pFences), sizeof(const VkFence), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkResetFences_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkResetFences_CallbackFunctionPointer(device, fenceCount, pFences, Mock.vkResetFences_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkResetFences(CMOCK_vkResetFences_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t fenceCount, const VkFence* pFences); +void CMockExpectParameters_vkResetFences(CMOCK_vkResetFences_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t fenceCount, const VkFence* pFences) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_fenceCount = fenceCount; + cmock_call_instance->IgnoreArg_fenceCount = 0; + cmock_call_instance->Expected_pFences = pFences; + cmock_call_instance->IgnoreArg_pFences = 0; +} + +void vkResetFences_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkResetFences_CALL_INSTANCE)); + CMOCK_vkResetFences_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetFences_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkResetFences_CallInstance = CMock_Guts_MemChain(Mock.vkResetFences_CallInstance, cmock_guts_index); + Mock.vkResetFences_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkResetFences_IgnoreBool = (char)1; +} + +void vkResetFences_CMockStopIgnore(void) +{ + if(Mock.vkResetFences_IgnoreBool) + Mock.vkResetFences_CallInstance = CMock_Guts_MemNext(Mock.vkResetFences_CallInstance); + Mock.vkResetFences_IgnoreBool = (char)0; +} + +void vkResetFences_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkResetFences_CALL_INSTANCE)); + CMOCK_vkResetFences_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetFences_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkResetFences_CallInstance = CMock_Guts_MemChain(Mock.vkResetFences_CallInstance, cmock_guts_index); + Mock.vkResetFences_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkResetFences_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkResetFences_CALL_INSTANCE)); + CMOCK_vkResetFences_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetFences_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkResetFences_CallInstance = CMock_Guts_MemChain(Mock.vkResetFences_CallInstance, cmock_guts_index); + Mock.vkResetFences_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkResetFences(cmock_call_instance, device, fenceCount, pFences); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkResetFences_AddCallback(CMOCK_vkResetFences_CALLBACK Callback) +{ + Mock.vkResetFences_IgnoreBool = (char)0; + Mock.vkResetFences_CallbackBool = (char)1; + Mock.vkResetFences_CallbackFunctionPointer = Callback; +} + +void vkResetFences_Stub(CMOCK_vkResetFences_CALLBACK Callback) +{ + Mock.vkResetFences_IgnoreBool = (char)0; + Mock.vkResetFences_CallbackBool = (char)0; + Mock.vkResetFences_CallbackFunctionPointer = Callback; +} + +void vkResetFences_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkResetFences_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetFences_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkResetFences_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkResetFences_CMockIgnoreArg_fenceCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkResetFences_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetFences_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkResetFences_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_fenceCount = 1; +} + +void vkResetFences_CMockIgnoreArg_pFences(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkResetFences_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetFences_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkResetFences_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pFences = 1; +} + +VkResult vkGetFenceStatus(VkDevice device, VkFence fence) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetFenceStatus_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetFenceStatus); + cmock_call_instance = (CMOCK_vkGetFenceStatus_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetFenceStatus_CallInstance); + Mock.vkGetFenceStatus_CallInstance = CMock_Guts_MemNext(Mock.vkGetFenceStatus_CallInstance); + if (Mock.vkGetFenceStatus_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetFenceStatus_FinalReturn; + memcpy((void*)(&Mock.vkGetFenceStatus_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetFenceStatus_CallbackBool && + Mock.vkGetFenceStatus_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetFenceStatus_CallbackFunctionPointer(device, fence, Mock.vkGetFenceStatus_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetFenceStatus,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_fence) + { + UNITY_SET_DETAILS(CMockString_vkGetFenceStatus,CMockString_fence); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_fence), (void*)(&fence), sizeof(VkFence), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetFenceStatus_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetFenceStatus_CallbackFunctionPointer(device, fence, Mock.vkGetFenceStatus_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetFenceStatus(CMOCK_vkGetFenceStatus_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkFence fence); +void CMockExpectParameters_vkGetFenceStatus(CMOCK_vkGetFenceStatus_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkFence fence) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_fence), (void*)(&fence), + sizeof(VkFence[sizeof(fence) == sizeof(VkFence) ? 1 : -1])); /* add VkFence to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_fence = 0; +} + +void vkGetFenceStatus_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetFenceStatus_CALL_INSTANCE)); + CMOCK_vkGetFenceStatus_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetFenceStatus_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetFenceStatus_CallInstance = CMock_Guts_MemChain(Mock.vkGetFenceStatus_CallInstance, cmock_guts_index); + Mock.vkGetFenceStatus_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetFenceStatus_IgnoreBool = (char)1; +} + +void vkGetFenceStatus_CMockStopIgnore(void) +{ + if(Mock.vkGetFenceStatus_IgnoreBool) + Mock.vkGetFenceStatus_CallInstance = CMock_Guts_MemNext(Mock.vkGetFenceStatus_CallInstance); + Mock.vkGetFenceStatus_IgnoreBool = (char)0; +} + +void vkGetFenceStatus_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetFenceStatus_CALL_INSTANCE)); + CMOCK_vkGetFenceStatus_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetFenceStatus_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetFenceStatus_CallInstance = CMock_Guts_MemChain(Mock.vkGetFenceStatus_CallInstance, cmock_guts_index); + Mock.vkGetFenceStatus_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetFenceStatus_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkFence fence, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetFenceStatus_CALL_INSTANCE)); + CMOCK_vkGetFenceStatus_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetFenceStatus_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetFenceStatus_CallInstance = CMock_Guts_MemChain(Mock.vkGetFenceStatus_CallInstance, cmock_guts_index); + Mock.vkGetFenceStatus_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetFenceStatus(cmock_call_instance, device, fence); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetFenceStatus_AddCallback(CMOCK_vkGetFenceStatus_CALLBACK Callback) +{ + Mock.vkGetFenceStatus_IgnoreBool = (char)0; + Mock.vkGetFenceStatus_CallbackBool = (char)1; + Mock.vkGetFenceStatus_CallbackFunctionPointer = Callback; +} + +void vkGetFenceStatus_Stub(CMOCK_vkGetFenceStatus_CALLBACK Callback) +{ + Mock.vkGetFenceStatus_IgnoreBool = (char)0; + Mock.vkGetFenceStatus_CallbackBool = (char)0; + Mock.vkGetFenceStatus_CallbackFunctionPointer = Callback; +} + +void vkGetFenceStatus_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetFenceStatus_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetFenceStatus_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetFenceStatus_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetFenceStatus_CMockIgnoreArg_fence(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetFenceStatus_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetFenceStatus_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetFenceStatus_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_fence = 1; +} + +VkResult vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkWaitForFences_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkWaitForFences); + cmock_call_instance = (CMOCK_vkWaitForFences_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkWaitForFences_CallInstance); + Mock.vkWaitForFences_CallInstance = CMock_Guts_MemNext(Mock.vkWaitForFences_CallInstance); + if (Mock.vkWaitForFences_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkWaitForFences_FinalReturn; + memcpy((void*)(&Mock.vkWaitForFences_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkWaitForFences_CallbackBool && + Mock.vkWaitForFences_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkWaitForFences_CallbackFunctionPointer(device, fenceCount, pFences, waitAll, timeout, Mock.vkWaitForFences_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkWaitForFences,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_fenceCount) + { + UNITY_SET_DETAILS(CMockString_vkWaitForFences,CMockString_fenceCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_fenceCount, fenceCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pFences) + { + UNITY_SET_DETAILS(CMockString_vkWaitForFences,CMockString_pFences); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pFences), (void*)(pFences), sizeof(const VkFence), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_waitAll) + { + UNITY_SET_DETAILS(CMockString_vkWaitForFences,CMockString_waitAll); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_waitAll), (void*)(&waitAll), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_timeout) + { + UNITY_SET_DETAILS(CMockString_vkWaitForFences,CMockString_timeout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_timeout), (void*)(&timeout), sizeof(uint64_t), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkWaitForFences_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkWaitForFences_CallbackFunctionPointer(device, fenceCount, pFences, waitAll, timeout, Mock.vkWaitForFences_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkWaitForFences(CMOCK_vkWaitForFences_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); +void CMockExpectParameters_vkWaitForFences(CMOCK_vkWaitForFences_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_fenceCount = fenceCount; + cmock_call_instance->IgnoreArg_fenceCount = 0; + cmock_call_instance->Expected_pFences = pFences; + cmock_call_instance->IgnoreArg_pFences = 0; + memcpy((void*)(&cmock_call_instance->Expected_waitAll), (void*)(&waitAll), + sizeof(VkBool32[sizeof(waitAll) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_waitAll = 0; + memcpy((void*)(&cmock_call_instance->Expected_timeout), (void*)(&timeout), + sizeof(uint64_t[sizeof(timeout) == sizeof(uint64_t) ? 1 : -1])); /* add uint64_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_timeout = 0; +} + +void vkWaitForFences_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkWaitForFences_CALL_INSTANCE)); + CMOCK_vkWaitForFences_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWaitForFences_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkWaitForFences_CallInstance = CMock_Guts_MemChain(Mock.vkWaitForFences_CallInstance, cmock_guts_index); + Mock.vkWaitForFences_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkWaitForFences_IgnoreBool = (char)1; +} + +void vkWaitForFences_CMockStopIgnore(void) +{ + if(Mock.vkWaitForFences_IgnoreBool) + Mock.vkWaitForFences_CallInstance = CMock_Guts_MemNext(Mock.vkWaitForFences_CallInstance); + Mock.vkWaitForFences_IgnoreBool = (char)0; +} + +void vkWaitForFences_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkWaitForFences_CALL_INSTANCE)); + CMOCK_vkWaitForFences_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWaitForFences_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkWaitForFences_CallInstance = CMock_Guts_MemChain(Mock.vkWaitForFences_CallInstance, cmock_guts_index); + Mock.vkWaitForFences_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkWaitForFences_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkWaitForFences_CALL_INSTANCE)); + CMOCK_vkWaitForFences_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWaitForFences_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkWaitForFences_CallInstance = CMock_Guts_MemChain(Mock.vkWaitForFences_CallInstance, cmock_guts_index); + Mock.vkWaitForFences_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkWaitForFences(cmock_call_instance, device, fenceCount, pFences, waitAll, timeout); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkWaitForFences_AddCallback(CMOCK_vkWaitForFences_CALLBACK Callback) +{ + Mock.vkWaitForFences_IgnoreBool = (char)0; + Mock.vkWaitForFences_CallbackBool = (char)1; + Mock.vkWaitForFences_CallbackFunctionPointer = Callback; +} + +void vkWaitForFences_Stub(CMOCK_vkWaitForFences_CALLBACK Callback) +{ + Mock.vkWaitForFences_IgnoreBool = (char)0; + Mock.vkWaitForFences_CallbackBool = (char)0; + Mock.vkWaitForFences_CallbackFunctionPointer = Callback; +} + +void vkWaitForFences_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkWaitForFences_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWaitForFences_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWaitForFences_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkWaitForFences_CMockIgnoreArg_fenceCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkWaitForFences_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWaitForFences_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWaitForFences_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_fenceCount = 1; +} + +void vkWaitForFences_CMockIgnoreArg_pFences(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkWaitForFences_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWaitForFences_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWaitForFences_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pFences = 1; +} + +void vkWaitForFences_CMockIgnoreArg_waitAll(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkWaitForFences_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWaitForFences_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWaitForFences_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_waitAll = 1; +} + +void vkWaitForFences_CMockIgnoreArg_timeout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkWaitForFences_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWaitForFences_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWaitForFences_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_timeout = 1; +} + +VkResult vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateSemaphore_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateSemaphore); + cmock_call_instance = (CMOCK_vkCreateSemaphore_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateSemaphore_CallInstance); + Mock.vkCreateSemaphore_CallInstance = CMock_Guts_MemNext(Mock.vkCreateSemaphore_CallInstance); + if (Mock.vkCreateSemaphore_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateSemaphore_FinalReturn; + memcpy((void*)(&Mock.vkCreateSemaphore_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateSemaphore_CallbackBool && + Mock.vkCreateSemaphore_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateSemaphore_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pSemaphore, Mock.vkCreateSemaphore_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateSemaphore,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateSemaphore,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkSemaphoreCreateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateSemaphore,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSemaphore) + { + UNITY_SET_DETAILS(CMockString_vkCreateSemaphore,CMockString_pSemaphore); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSemaphore), (void*)(pSemaphore), sizeof(VkSemaphore), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateSemaphore_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateSemaphore_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pSemaphore, Mock.vkCreateSemaphore_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pSemaphore_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSemaphore, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSemaphore, (const void*)cmock_call_instance->ReturnThruPtr_pSemaphore_Val, + cmock_call_instance->ReturnThruPtr_pSemaphore_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateSemaphore(CMOCK_vkCreateSemaphore_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore); +void CMockExpectParameters_vkCreateSemaphore(CMOCK_vkCreateSemaphore_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pSemaphore = pSemaphore; + cmock_call_instance->IgnoreArg_pSemaphore = 0; + cmock_call_instance->ReturnThruPtr_pSemaphore_Used = 0; +} + +void vkCreateSemaphore_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateSemaphore_CALL_INSTANCE)); + CMOCK_vkCreateSemaphore_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSemaphore_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateSemaphore_CallInstance = CMock_Guts_MemChain(Mock.vkCreateSemaphore_CallInstance, cmock_guts_index); + Mock.vkCreateSemaphore_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateSemaphore_IgnoreBool = (char)1; +} + +void vkCreateSemaphore_CMockStopIgnore(void) +{ + if(Mock.vkCreateSemaphore_IgnoreBool) + Mock.vkCreateSemaphore_CallInstance = CMock_Guts_MemNext(Mock.vkCreateSemaphore_CallInstance); + Mock.vkCreateSemaphore_IgnoreBool = (char)0; +} + +void vkCreateSemaphore_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateSemaphore_CALL_INSTANCE)); + CMOCK_vkCreateSemaphore_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSemaphore_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateSemaphore_CallInstance = CMock_Guts_MemChain(Mock.vkCreateSemaphore_CallInstance, cmock_guts_index); + Mock.vkCreateSemaphore_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateSemaphore_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateSemaphore_CALL_INSTANCE)); + CMOCK_vkCreateSemaphore_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSemaphore_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateSemaphore_CallInstance = CMock_Guts_MemChain(Mock.vkCreateSemaphore_CallInstance, cmock_guts_index); + Mock.vkCreateSemaphore_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateSemaphore(cmock_call_instance, device, pCreateInfo, pAllocator, pSemaphore); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateSemaphore_AddCallback(CMOCK_vkCreateSemaphore_CALLBACK Callback) +{ + Mock.vkCreateSemaphore_IgnoreBool = (char)0; + Mock.vkCreateSemaphore_CallbackBool = (char)1; + Mock.vkCreateSemaphore_CallbackFunctionPointer = Callback; +} + +void vkCreateSemaphore_Stub(CMOCK_vkCreateSemaphore_CALLBACK Callback) +{ + Mock.vkCreateSemaphore_IgnoreBool = (char)0; + Mock.vkCreateSemaphore_CallbackBool = (char)0; + Mock.vkCreateSemaphore_CallbackFunctionPointer = Callback; +} + +void vkCreateSemaphore_CMockReturnMemThruPtr_pSemaphore(UNITY_LINE_TYPE cmock_line, VkSemaphore const* pSemaphore, size_t cmock_size) +{ + CMOCK_vkCreateSemaphore_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSemaphore_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSemaphore_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSemaphore_Used = 1; + cmock_call_instance->ReturnThruPtr_pSemaphore_Val = pSemaphore; + cmock_call_instance->ReturnThruPtr_pSemaphore_Size = cmock_size; +} + +void vkCreateSemaphore_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateSemaphore_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSemaphore_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSemaphore_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateSemaphore_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateSemaphore_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSemaphore_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSemaphore_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateSemaphore_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateSemaphore_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSemaphore_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSemaphore_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateSemaphore_CMockIgnoreArg_pSemaphore(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateSemaphore_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSemaphore_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSemaphore_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSemaphore = 1; +} + +void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroySemaphore_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroySemaphore); + cmock_call_instance = (CMOCK_vkDestroySemaphore_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroySemaphore_CallInstance); + Mock.vkDestroySemaphore_CallInstance = CMock_Guts_MemNext(Mock.vkDestroySemaphore_CallInstance); + if (Mock.vkDestroySemaphore_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroySemaphore_CallbackBool && + Mock.vkDestroySemaphore_CallbackFunctionPointer != NULL) + { + Mock.vkDestroySemaphore_CallbackFunctionPointer(device, semaphore, pAllocator, Mock.vkDestroySemaphore_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroySemaphore,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_semaphore) + { + UNITY_SET_DETAILS(CMockString_vkDestroySemaphore,CMockString_semaphore); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_semaphore), (void*)(&semaphore), sizeof(VkSemaphore), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroySemaphore,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroySemaphore_CallbackFunctionPointer != NULL) + { + Mock.vkDestroySemaphore_CallbackFunctionPointer(device, semaphore, pAllocator, Mock.vkDestroySemaphore_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroySemaphore(CMOCK_vkDestroySemaphore_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroySemaphore(CMOCK_vkDestroySemaphore_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_semaphore), (void*)(&semaphore), + sizeof(VkSemaphore[sizeof(semaphore) == sizeof(VkSemaphore) ? 1 : -1])); /* add VkSemaphore to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_semaphore = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroySemaphore_CMockIgnore(void) +{ + Mock.vkDestroySemaphore_IgnoreBool = (char)1; +} + +void vkDestroySemaphore_CMockStopIgnore(void) +{ + Mock.vkDestroySemaphore_IgnoreBool = (char)0; +} + +void vkDestroySemaphore_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroySemaphore_CALL_INSTANCE)); + CMOCK_vkDestroySemaphore_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroySemaphore_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroySemaphore_CallInstance = CMock_Guts_MemChain(Mock.vkDestroySemaphore_CallInstance, cmock_guts_index); + Mock.vkDestroySemaphore_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroySemaphore_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroySemaphore_CALL_INSTANCE)); + CMOCK_vkDestroySemaphore_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroySemaphore_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroySemaphore_CallInstance = CMock_Guts_MemChain(Mock.vkDestroySemaphore_CallInstance, cmock_guts_index); + Mock.vkDestroySemaphore_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroySemaphore(cmock_call_instance, device, semaphore, pAllocator); +} + +void vkDestroySemaphore_AddCallback(CMOCK_vkDestroySemaphore_CALLBACK Callback) +{ + Mock.vkDestroySemaphore_IgnoreBool = (char)0; + Mock.vkDestroySemaphore_CallbackBool = (char)1; + Mock.vkDestroySemaphore_CallbackFunctionPointer = Callback; +} + +void vkDestroySemaphore_Stub(CMOCK_vkDestroySemaphore_CALLBACK Callback) +{ + Mock.vkDestroySemaphore_IgnoreBool = (char)0; + Mock.vkDestroySemaphore_CallbackBool = (char)0; + Mock.vkDestroySemaphore_CallbackFunctionPointer = Callback; +} + +void vkDestroySemaphore_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroySemaphore_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroySemaphore_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroySemaphore_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroySemaphore_CMockIgnoreArg_semaphore(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroySemaphore_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroySemaphore_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroySemaphore_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_semaphore = 1; +} + +void vkDestroySemaphore_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroySemaphore_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroySemaphore_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroySemaphore_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateEvent_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateEvent); + cmock_call_instance = (CMOCK_vkCreateEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateEvent_CallInstance); + Mock.vkCreateEvent_CallInstance = CMock_Guts_MemNext(Mock.vkCreateEvent_CallInstance); + if (Mock.vkCreateEvent_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateEvent_FinalReturn; + memcpy((void*)(&Mock.vkCreateEvent_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateEvent_CallbackBool && + Mock.vkCreateEvent_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateEvent_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pEvent, Mock.vkCreateEvent_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateEvent,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateEvent,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkEventCreateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateEvent,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pEvent) + { + UNITY_SET_DETAILS(CMockString_vkCreateEvent,CMockString_pEvent); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pEvent), (void*)(pEvent), sizeof(VkEvent), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateEvent_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateEvent_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pEvent, Mock.vkCreateEvent_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pEvent_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pEvent, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pEvent, (const void*)cmock_call_instance->ReturnThruPtr_pEvent_Val, + cmock_call_instance->ReturnThruPtr_pEvent_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateEvent(CMOCK_vkCreateEvent_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent); +void CMockExpectParameters_vkCreateEvent(CMOCK_vkCreateEvent_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pEvent = pEvent; + cmock_call_instance->IgnoreArg_pEvent = 0; + cmock_call_instance->ReturnThruPtr_pEvent_Used = 0; +} + +void vkCreateEvent_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateEvent_CALL_INSTANCE)); + CMOCK_vkCreateEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateEvent_CallInstance = CMock_Guts_MemChain(Mock.vkCreateEvent_CallInstance, cmock_guts_index); + Mock.vkCreateEvent_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateEvent_IgnoreBool = (char)1; +} + +void vkCreateEvent_CMockStopIgnore(void) +{ + if(Mock.vkCreateEvent_IgnoreBool) + Mock.vkCreateEvent_CallInstance = CMock_Guts_MemNext(Mock.vkCreateEvent_CallInstance); + Mock.vkCreateEvent_IgnoreBool = (char)0; +} + +void vkCreateEvent_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateEvent_CALL_INSTANCE)); + CMOCK_vkCreateEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateEvent_CallInstance = CMock_Guts_MemChain(Mock.vkCreateEvent_CallInstance, cmock_guts_index); + Mock.vkCreateEvent_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateEvent_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateEvent_CALL_INSTANCE)); + CMOCK_vkCreateEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateEvent_CallInstance = CMock_Guts_MemChain(Mock.vkCreateEvent_CallInstance, cmock_guts_index); + Mock.vkCreateEvent_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateEvent(cmock_call_instance, device, pCreateInfo, pAllocator, pEvent); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateEvent_AddCallback(CMOCK_vkCreateEvent_CALLBACK Callback) +{ + Mock.vkCreateEvent_IgnoreBool = (char)0; + Mock.vkCreateEvent_CallbackBool = (char)1; + Mock.vkCreateEvent_CallbackFunctionPointer = Callback; +} + +void vkCreateEvent_Stub(CMOCK_vkCreateEvent_CALLBACK Callback) +{ + Mock.vkCreateEvent_IgnoreBool = (char)0; + Mock.vkCreateEvent_CallbackBool = (char)0; + Mock.vkCreateEvent_CallbackFunctionPointer = Callback; +} + +void vkCreateEvent_CMockReturnMemThruPtr_pEvent(UNITY_LINE_TYPE cmock_line, VkEvent const* pEvent, size_t cmock_size) +{ + CMOCK_vkCreateEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateEvent_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pEvent_Used = 1; + cmock_call_instance->ReturnThruPtr_pEvent_Val = pEvent; + cmock_call_instance->ReturnThruPtr_pEvent_Size = cmock_size; +} + +void vkCreateEvent_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateEvent_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateEvent_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateEvent_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateEvent_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateEvent_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateEvent_CMockIgnoreArg_pEvent(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateEvent_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pEvent = 1; +} + +void vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyEvent_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyEvent); + cmock_call_instance = (CMOCK_vkDestroyEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyEvent_CallInstance); + Mock.vkDestroyEvent_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyEvent_CallInstance); + if (Mock.vkDestroyEvent_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyEvent_CallbackBool && + Mock.vkDestroyEvent_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyEvent_CallbackFunctionPointer(device, event, pAllocator, Mock.vkDestroyEvent_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyEvent,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_event) + { + UNITY_SET_DETAILS(CMockString_vkDestroyEvent,CMockString_event); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_event), (void*)(&event), sizeof(VkEvent), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyEvent,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyEvent_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyEvent_CallbackFunctionPointer(device, event, pAllocator, Mock.vkDestroyEvent_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyEvent(CMOCK_vkDestroyEvent_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyEvent(CMOCK_vkDestroyEvent_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_event), (void*)(&event), + sizeof(VkEvent[sizeof(event) == sizeof(VkEvent) ? 1 : -1])); /* add VkEvent to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_event = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyEvent_CMockIgnore(void) +{ + Mock.vkDestroyEvent_IgnoreBool = (char)1; +} + +void vkDestroyEvent_CMockStopIgnore(void) +{ + Mock.vkDestroyEvent_IgnoreBool = (char)0; +} + +void vkDestroyEvent_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyEvent_CALL_INSTANCE)); + CMOCK_vkDestroyEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyEvent_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyEvent_CallInstance, cmock_guts_index); + Mock.vkDestroyEvent_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyEvent_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyEvent_CALL_INSTANCE)); + CMOCK_vkDestroyEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyEvent_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyEvent_CallInstance, cmock_guts_index); + Mock.vkDestroyEvent_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyEvent(cmock_call_instance, device, event, pAllocator); +} + +void vkDestroyEvent_AddCallback(CMOCK_vkDestroyEvent_CALLBACK Callback) +{ + Mock.vkDestroyEvent_IgnoreBool = (char)0; + Mock.vkDestroyEvent_CallbackBool = (char)1; + Mock.vkDestroyEvent_CallbackFunctionPointer = Callback; +} + +void vkDestroyEvent_Stub(CMOCK_vkDestroyEvent_CALLBACK Callback) +{ + Mock.vkDestroyEvent_IgnoreBool = (char)0; + Mock.vkDestroyEvent_CallbackBool = (char)0; + Mock.vkDestroyEvent_CallbackFunctionPointer = Callback; +} + +void vkDestroyEvent_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyEvent_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyEvent_CMockIgnoreArg_event(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyEvent_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_event = 1; +} + +void vkDestroyEvent_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyEvent_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +VkResult vkGetEventStatus(VkDevice device, VkEvent event) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetEventStatus_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetEventStatus); + cmock_call_instance = (CMOCK_vkGetEventStatus_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetEventStatus_CallInstance); + Mock.vkGetEventStatus_CallInstance = CMock_Guts_MemNext(Mock.vkGetEventStatus_CallInstance); + if (Mock.vkGetEventStatus_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetEventStatus_FinalReturn; + memcpy((void*)(&Mock.vkGetEventStatus_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetEventStatus_CallbackBool && + Mock.vkGetEventStatus_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetEventStatus_CallbackFunctionPointer(device, event, Mock.vkGetEventStatus_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetEventStatus,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_event) + { + UNITY_SET_DETAILS(CMockString_vkGetEventStatus,CMockString_event); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_event), (void*)(&event), sizeof(VkEvent), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetEventStatus_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetEventStatus_CallbackFunctionPointer(device, event, Mock.vkGetEventStatus_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetEventStatus(CMOCK_vkGetEventStatus_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkEvent event); +void CMockExpectParameters_vkGetEventStatus(CMOCK_vkGetEventStatus_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkEvent event) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_event), (void*)(&event), + sizeof(VkEvent[sizeof(event) == sizeof(VkEvent) ? 1 : -1])); /* add VkEvent to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_event = 0; +} + +void vkGetEventStatus_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetEventStatus_CALL_INSTANCE)); + CMOCK_vkGetEventStatus_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetEventStatus_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetEventStatus_CallInstance = CMock_Guts_MemChain(Mock.vkGetEventStatus_CallInstance, cmock_guts_index); + Mock.vkGetEventStatus_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetEventStatus_IgnoreBool = (char)1; +} + +void vkGetEventStatus_CMockStopIgnore(void) +{ + if(Mock.vkGetEventStatus_IgnoreBool) + Mock.vkGetEventStatus_CallInstance = CMock_Guts_MemNext(Mock.vkGetEventStatus_CallInstance); + Mock.vkGetEventStatus_IgnoreBool = (char)0; +} + +void vkGetEventStatus_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetEventStatus_CALL_INSTANCE)); + CMOCK_vkGetEventStatus_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetEventStatus_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetEventStatus_CallInstance = CMock_Guts_MemChain(Mock.vkGetEventStatus_CallInstance, cmock_guts_index); + Mock.vkGetEventStatus_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetEventStatus_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkEvent event, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetEventStatus_CALL_INSTANCE)); + CMOCK_vkGetEventStatus_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetEventStatus_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetEventStatus_CallInstance = CMock_Guts_MemChain(Mock.vkGetEventStatus_CallInstance, cmock_guts_index); + Mock.vkGetEventStatus_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetEventStatus(cmock_call_instance, device, event); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetEventStatus_AddCallback(CMOCK_vkGetEventStatus_CALLBACK Callback) +{ + Mock.vkGetEventStatus_IgnoreBool = (char)0; + Mock.vkGetEventStatus_CallbackBool = (char)1; + Mock.vkGetEventStatus_CallbackFunctionPointer = Callback; +} + +void vkGetEventStatus_Stub(CMOCK_vkGetEventStatus_CALLBACK Callback) +{ + Mock.vkGetEventStatus_IgnoreBool = (char)0; + Mock.vkGetEventStatus_CallbackBool = (char)0; + Mock.vkGetEventStatus_CallbackFunctionPointer = Callback; +} + +void vkGetEventStatus_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetEventStatus_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetEventStatus_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetEventStatus_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetEventStatus_CMockIgnoreArg_event(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetEventStatus_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetEventStatus_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetEventStatus_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_event = 1; +} + +VkResult vkSetEvent(VkDevice device, VkEvent event) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkSetEvent_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkSetEvent); + cmock_call_instance = (CMOCK_vkSetEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkSetEvent_CallInstance); + Mock.vkSetEvent_CallInstance = CMock_Guts_MemNext(Mock.vkSetEvent_CallInstance); + if (Mock.vkSetEvent_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkSetEvent_FinalReturn; + memcpy((void*)(&Mock.vkSetEvent_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkSetEvent_CallbackBool && + Mock.vkSetEvent_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkSetEvent_CallbackFunctionPointer(device, event, Mock.vkSetEvent_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkSetEvent,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_event) + { + UNITY_SET_DETAILS(CMockString_vkSetEvent,CMockString_event); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_event), (void*)(&event), sizeof(VkEvent), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkSetEvent_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkSetEvent_CallbackFunctionPointer(device, event, Mock.vkSetEvent_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkSetEvent(CMOCK_vkSetEvent_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkEvent event); +void CMockExpectParameters_vkSetEvent(CMOCK_vkSetEvent_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkEvent event) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_event), (void*)(&event), + sizeof(VkEvent[sizeof(event) == sizeof(VkEvent) ? 1 : -1])); /* add VkEvent to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_event = 0; +} + +void vkSetEvent_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkSetEvent_CALL_INSTANCE)); + CMOCK_vkSetEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkSetEvent_CallInstance = CMock_Guts_MemChain(Mock.vkSetEvent_CallInstance, cmock_guts_index); + Mock.vkSetEvent_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkSetEvent_IgnoreBool = (char)1; +} + +void vkSetEvent_CMockStopIgnore(void) +{ + if(Mock.vkSetEvent_IgnoreBool) + Mock.vkSetEvent_CallInstance = CMock_Guts_MemNext(Mock.vkSetEvent_CallInstance); + Mock.vkSetEvent_IgnoreBool = (char)0; +} + +void vkSetEvent_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkSetEvent_CALL_INSTANCE)); + CMOCK_vkSetEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkSetEvent_CallInstance = CMock_Guts_MemChain(Mock.vkSetEvent_CallInstance, cmock_guts_index); + Mock.vkSetEvent_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkSetEvent_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkEvent event, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkSetEvent_CALL_INSTANCE)); + CMOCK_vkSetEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkSetEvent_CallInstance = CMock_Guts_MemChain(Mock.vkSetEvent_CallInstance, cmock_guts_index); + Mock.vkSetEvent_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkSetEvent(cmock_call_instance, device, event); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkSetEvent_AddCallback(CMOCK_vkSetEvent_CALLBACK Callback) +{ + Mock.vkSetEvent_IgnoreBool = (char)0; + Mock.vkSetEvent_CallbackBool = (char)1; + Mock.vkSetEvent_CallbackFunctionPointer = Callback; +} + +void vkSetEvent_Stub(CMOCK_vkSetEvent_CALLBACK Callback) +{ + Mock.vkSetEvent_IgnoreBool = (char)0; + Mock.vkSetEvent_CallbackBool = (char)0; + Mock.vkSetEvent_CallbackFunctionPointer = Callback; +} + +void vkSetEvent_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSetEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSetEvent_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkSetEvent_CMockIgnoreArg_event(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSetEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSetEvent_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_event = 1; +} + +VkResult vkResetEvent(VkDevice device, VkEvent event) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkResetEvent_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkResetEvent); + cmock_call_instance = (CMOCK_vkResetEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkResetEvent_CallInstance); + Mock.vkResetEvent_CallInstance = CMock_Guts_MemNext(Mock.vkResetEvent_CallInstance); + if (Mock.vkResetEvent_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkResetEvent_FinalReturn; + memcpy((void*)(&Mock.vkResetEvent_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkResetEvent_CallbackBool && + Mock.vkResetEvent_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkResetEvent_CallbackFunctionPointer(device, event, Mock.vkResetEvent_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkResetEvent,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_event) + { + UNITY_SET_DETAILS(CMockString_vkResetEvent,CMockString_event); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_event), (void*)(&event), sizeof(VkEvent), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkResetEvent_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkResetEvent_CallbackFunctionPointer(device, event, Mock.vkResetEvent_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkResetEvent(CMOCK_vkResetEvent_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkEvent event); +void CMockExpectParameters_vkResetEvent(CMOCK_vkResetEvent_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkEvent event) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_event), (void*)(&event), + sizeof(VkEvent[sizeof(event) == sizeof(VkEvent) ? 1 : -1])); /* add VkEvent to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_event = 0; +} + +void vkResetEvent_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkResetEvent_CALL_INSTANCE)); + CMOCK_vkResetEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkResetEvent_CallInstance = CMock_Guts_MemChain(Mock.vkResetEvent_CallInstance, cmock_guts_index); + Mock.vkResetEvent_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkResetEvent_IgnoreBool = (char)1; +} + +void vkResetEvent_CMockStopIgnore(void) +{ + if(Mock.vkResetEvent_IgnoreBool) + Mock.vkResetEvent_CallInstance = CMock_Guts_MemNext(Mock.vkResetEvent_CallInstance); + Mock.vkResetEvent_IgnoreBool = (char)0; +} + +void vkResetEvent_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkResetEvent_CALL_INSTANCE)); + CMOCK_vkResetEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkResetEvent_CallInstance = CMock_Guts_MemChain(Mock.vkResetEvent_CallInstance, cmock_guts_index); + Mock.vkResetEvent_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkResetEvent_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkEvent event, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkResetEvent_CALL_INSTANCE)); + CMOCK_vkResetEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkResetEvent_CallInstance = CMock_Guts_MemChain(Mock.vkResetEvent_CallInstance, cmock_guts_index); + Mock.vkResetEvent_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkResetEvent(cmock_call_instance, device, event); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkResetEvent_AddCallback(CMOCK_vkResetEvent_CALLBACK Callback) +{ + Mock.vkResetEvent_IgnoreBool = (char)0; + Mock.vkResetEvent_CallbackBool = (char)1; + Mock.vkResetEvent_CallbackFunctionPointer = Callback; +} + +void vkResetEvent_Stub(CMOCK_vkResetEvent_CALLBACK Callback) +{ + Mock.vkResetEvent_IgnoreBool = (char)0; + Mock.vkResetEvent_CallbackBool = (char)0; + Mock.vkResetEvent_CallbackFunctionPointer = Callback; +} + +void vkResetEvent_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkResetEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkResetEvent_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkResetEvent_CMockIgnoreArg_event(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkResetEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkResetEvent_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_event = 1; +} + +VkResult vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateQueryPool_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateQueryPool); + cmock_call_instance = (CMOCK_vkCreateQueryPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateQueryPool_CallInstance); + Mock.vkCreateQueryPool_CallInstance = CMock_Guts_MemNext(Mock.vkCreateQueryPool_CallInstance); + if (Mock.vkCreateQueryPool_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateQueryPool_FinalReturn; + memcpy((void*)(&Mock.vkCreateQueryPool_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateQueryPool_CallbackBool && + Mock.vkCreateQueryPool_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateQueryPool_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pQueryPool, Mock.vkCreateQueryPool_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateQueryPool,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateQueryPool,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkQueryPoolCreateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateQueryPool,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pQueryPool) + { + UNITY_SET_DETAILS(CMockString_vkCreateQueryPool,CMockString_pQueryPool); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pQueryPool), (void*)(pQueryPool), sizeof(VkQueryPool), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateQueryPool_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateQueryPool_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pQueryPool, Mock.vkCreateQueryPool_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pQueryPool_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pQueryPool, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pQueryPool, (const void*)cmock_call_instance->ReturnThruPtr_pQueryPool_Val, + cmock_call_instance->ReturnThruPtr_pQueryPool_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateQueryPool(CMOCK_vkCreateQueryPool_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool); +void CMockExpectParameters_vkCreateQueryPool(CMOCK_vkCreateQueryPool_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pQueryPool = pQueryPool; + cmock_call_instance->IgnoreArg_pQueryPool = 0; + cmock_call_instance->ReturnThruPtr_pQueryPool_Used = 0; +} + +void vkCreateQueryPool_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateQueryPool_CALL_INSTANCE)); + CMOCK_vkCreateQueryPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateQueryPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateQueryPool_CallInstance = CMock_Guts_MemChain(Mock.vkCreateQueryPool_CallInstance, cmock_guts_index); + Mock.vkCreateQueryPool_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateQueryPool_IgnoreBool = (char)1; +} + +void vkCreateQueryPool_CMockStopIgnore(void) +{ + if(Mock.vkCreateQueryPool_IgnoreBool) + Mock.vkCreateQueryPool_CallInstance = CMock_Guts_MemNext(Mock.vkCreateQueryPool_CallInstance); + Mock.vkCreateQueryPool_IgnoreBool = (char)0; +} + +void vkCreateQueryPool_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateQueryPool_CALL_INSTANCE)); + CMOCK_vkCreateQueryPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateQueryPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateQueryPool_CallInstance = CMock_Guts_MemChain(Mock.vkCreateQueryPool_CallInstance, cmock_guts_index); + Mock.vkCreateQueryPool_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateQueryPool_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateQueryPool_CALL_INSTANCE)); + CMOCK_vkCreateQueryPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateQueryPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateQueryPool_CallInstance = CMock_Guts_MemChain(Mock.vkCreateQueryPool_CallInstance, cmock_guts_index); + Mock.vkCreateQueryPool_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateQueryPool(cmock_call_instance, device, pCreateInfo, pAllocator, pQueryPool); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateQueryPool_AddCallback(CMOCK_vkCreateQueryPool_CALLBACK Callback) +{ + Mock.vkCreateQueryPool_IgnoreBool = (char)0; + Mock.vkCreateQueryPool_CallbackBool = (char)1; + Mock.vkCreateQueryPool_CallbackFunctionPointer = Callback; +} + +void vkCreateQueryPool_Stub(CMOCK_vkCreateQueryPool_CALLBACK Callback) +{ + Mock.vkCreateQueryPool_IgnoreBool = (char)0; + Mock.vkCreateQueryPool_CallbackBool = (char)0; + Mock.vkCreateQueryPool_CallbackFunctionPointer = Callback; +} + +void vkCreateQueryPool_CMockReturnMemThruPtr_pQueryPool(UNITY_LINE_TYPE cmock_line, VkQueryPool const* pQueryPool, size_t cmock_size) +{ + CMOCK_vkCreateQueryPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateQueryPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateQueryPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pQueryPool_Used = 1; + cmock_call_instance->ReturnThruPtr_pQueryPool_Val = pQueryPool; + cmock_call_instance->ReturnThruPtr_pQueryPool_Size = cmock_size; +} + +void vkCreateQueryPool_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateQueryPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateQueryPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateQueryPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateQueryPool_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateQueryPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateQueryPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateQueryPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateQueryPool_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateQueryPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateQueryPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateQueryPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateQueryPool_CMockIgnoreArg_pQueryPool(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateQueryPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateQueryPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateQueryPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pQueryPool = 1; +} + +void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyQueryPool_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyQueryPool); + cmock_call_instance = (CMOCK_vkDestroyQueryPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyQueryPool_CallInstance); + Mock.vkDestroyQueryPool_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyQueryPool_CallInstance); + if (Mock.vkDestroyQueryPool_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyQueryPool_CallbackBool && + Mock.vkDestroyQueryPool_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyQueryPool_CallbackFunctionPointer(device, queryPool, pAllocator, Mock.vkDestroyQueryPool_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyQueryPool,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queryPool) + { + UNITY_SET_DETAILS(CMockString_vkDestroyQueryPool,CMockString_queryPool); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), sizeof(VkQueryPool), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyQueryPool,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyQueryPool_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyQueryPool_CallbackFunctionPointer(device, queryPool, pAllocator, Mock.vkDestroyQueryPool_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyQueryPool(CMOCK_vkDestroyQueryPool_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyQueryPool(CMOCK_vkDestroyQueryPool_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), + sizeof(VkQueryPool[sizeof(queryPool) == sizeof(VkQueryPool) ? 1 : -1])); /* add VkQueryPool to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queryPool = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyQueryPool_CMockIgnore(void) +{ + Mock.vkDestroyQueryPool_IgnoreBool = (char)1; +} + +void vkDestroyQueryPool_CMockStopIgnore(void) +{ + Mock.vkDestroyQueryPool_IgnoreBool = (char)0; +} + +void vkDestroyQueryPool_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyQueryPool_CALL_INSTANCE)); + CMOCK_vkDestroyQueryPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyQueryPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyQueryPool_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyQueryPool_CallInstance, cmock_guts_index); + Mock.vkDestroyQueryPool_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyQueryPool_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyQueryPool_CALL_INSTANCE)); + CMOCK_vkDestroyQueryPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyQueryPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyQueryPool_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyQueryPool_CallInstance, cmock_guts_index); + Mock.vkDestroyQueryPool_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyQueryPool(cmock_call_instance, device, queryPool, pAllocator); +} + +void vkDestroyQueryPool_AddCallback(CMOCK_vkDestroyQueryPool_CALLBACK Callback) +{ + Mock.vkDestroyQueryPool_IgnoreBool = (char)0; + Mock.vkDestroyQueryPool_CallbackBool = (char)1; + Mock.vkDestroyQueryPool_CallbackFunctionPointer = Callback; +} + +void vkDestroyQueryPool_Stub(CMOCK_vkDestroyQueryPool_CALLBACK Callback) +{ + Mock.vkDestroyQueryPool_IgnoreBool = (char)0; + Mock.vkDestroyQueryPool_CallbackBool = (char)0; + Mock.vkDestroyQueryPool_CallbackFunctionPointer = Callback; +} + +void vkDestroyQueryPool_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyQueryPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyQueryPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyQueryPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyQueryPool_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyQueryPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyQueryPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyQueryPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queryPool = 1; +} + +void vkDestroyQueryPool_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyQueryPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyQueryPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyQueryPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +VkResult vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetQueryPoolResults_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetQueryPoolResults); + cmock_call_instance = (CMOCK_vkGetQueryPoolResults_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetQueryPoolResults_CallInstance); + Mock.vkGetQueryPoolResults_CallInstance = CMock_Guts_MemNext(Mock.vkGetQueryPoolResults_CallInstance); + if (Mock.vkGetQueryPoolResults_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetQueryPoolResults_FinalReturn; + memcpy((void*)(&Mock.vkGetQueryPoolResults_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetQueryPoolResults_CallbackBool && + Mock.vkGetQueryPoolResults_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetQueryPoolResults_CallbackFunctionPointer(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags, Mock.vkGetQueryPoolResults_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetQueryPoolResults,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queryPool) + { + UNITY_SET_DETAILS(CMockString_vkGetQueryPoolResults,CMockString_queryPool); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), sizeof(VkQueryPool), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstQuery) + { + UNITY_SET_DETAILS(CMockString_vkGetQueryPoolResults,CMockString_firstQuery); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstQuery, firstQuery, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queryCount) + { + UNITY_SET_DETAILS(CMockString_vkGetQueryPoolResults,CMockString_queryCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_queryCount, queryCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dataSize) + { + UNITY_SET_DETAILS(CMockString_vkGetQueryPoolResults,CMockString_dataSize); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dataSize), (void*)(&dataSize), sizeof(size_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pData) + { + UNITY_SET_DETAILS(CMockString_vkGetQueryPoolResults,CMockString_pData); + if (cmock_call_instance->Expected_pData == NULL) + { UNITY_TEST_ASSERT_NULL(pData, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(cmock_call_instance->Expected_pData, pData, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_stride) + { + UNITY_SET_DETAILS(CMockString_vkGetQueryPoolResults,CMockString_stride); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_stride), (void*)(&stride), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_flags) + { + UNITY_SET_DETAILS(CMockString_vkGetQueryPoolResults,CMockString_flags); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_flags), (void*)(&flags), sizeof(VkQueryResultFlags), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetQueryPoolResults_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetQueryPoolResults_CallbackFunctionPointer(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags, Mock.vkGetQueryPoolResults_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pData_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pData, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pData, (const void*)cmock_call_instance->ReturnThruPtr_pData_Val, + cmock_call_instance->ReturnThruPtr_pData_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetQueryPoolResults(CMOCK_vkGetQueryPoolResults_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags); +void CMockExpectParameters_vkGetQueryPoolResults(CMOCK_vkGetQueryPoolResults_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), + sizeof(VkQueryPool[sizeof(queryPool) == sizeof(VkQueryPool) ? 1 : -1])); /* add VkQueryPool to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queryPool = 0; + cmock_call_instance->Expected_firstQuery = firstQuery; + cmock_call_instance->IgnoreArg_firstQuery = 0; + cmock_call_instance->Expected_queryCount = queryCount; + cmock_call_instance->IgnoreArg_queryCount = 0; + memcpy((void*)(&cmock_call_instance->Expected_dataSize), (void*)(&dataSize), + sizeof(size_t[sizeof(dataSize) == sizeof(size_t) ? 1 : -1])); /* add size_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dataSize = 0; + cmock_call_instance->Expected_pData = pData; + cmock_call_instance->IgnoreArg_pData = 0; + cmock_call_instance->ReturnThruPtr_pData_Used = 0; + memcpy((void*)(&cmock_call_instance->Expected_stride), (void*)(&stride), + sizeof(VkDeviceSize[sizeof(stride) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_stride = 0; + memcpy((void*)(&cmock_call_instance->Expected_flags), (void*)(&flags), + sizeof(VkQueryResultFlags[sizeof(flags) == sizeof(VkQueryResultFlags) ? 1 : -1])); /* add VkQueryResultFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_flags = 0; +} + +void vkGetQueryPoolResults_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetQueryPoolResults_CALL_INSTANCE)); + CMOCK_vkGetQueryPoolResults_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetQueryPoolResults_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetQueryPoolResults_CallInstance = CMock_Guts_MemChain(Mock.vkGetQueryPoolResults_CallInstance, cmock_guts_index); + Mock.vkGetQueryPoolResults_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetQueryPoolResults_IgnoreBool = (char)1; +} + +void vkGetQueryPoolResults_CMockStopIgnore(void) +{ + if(Mock.vkGetQueryPoolResults_IgnoreBool) + Mock.vkGetQueryPoolResults_CallInstance = CMock_Guts_MemNext(Mock.vkGetQueryPoolResults_CallInstance); + Mock.vkGetQueryPoolResults_IgnoreBool = (char)0; +} + +void vkGetQueryPoolResults_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetQueryPoolResults_CALL_INSTANCE)); + CMOCK_vkGetQueryPoolResults_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetQueryPoolResults_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetQueryPoolResults_CallInstance = CMock_Guts_MemChain(Mock.vkGetQueryPoolResults_CallInstance, cmock_guts_index); + Mock.vkGetQueryPoolResults_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetQueryPoolResults_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetQueryPoolResults_CALL_INSTANCE)); + CMOCK_vkGetQueryPoolResults_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetQueryPoolResults_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetQueryPoolResults_CallInstance = CMock_Guts_MemChain(Mock.vkGetQueryPoolResults_CallInstance, cmock_guts_index); + Mock.vkGetQueryPoolResults_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetQueryPoolResults(cmock_call_instance, device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetQueryPoolResults_AddCallback(CMOCK_vkGetQueryPoolResults_CALLBACK Callback) +{ + Mock.vkGetQueryPoolResults_IgnoreBool = (char)0; + Mock.vkGetQueryPoolResults_CallbackBool = (char)1; + Mock.vkGetQueryPoolResults_CallbackFunctionPointer = Callback; +} + +void vkGetQueryPoolResults_Stub(CMOCK_vkGetQueryPoolResults_CALLBACK Callback) +{ + Mock.vkGetQueryPoolResults_IgnoreBool = (char)0; + Mock.vkGetQueryPoolResults_CallbackBool = (char)0; + Mock.vkGetQueryPoolResults_CallbackFunctionPointer = Callback; +} + +void vkGetQueryPoolResults_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, void const* pData, size_t cmock_size) +{ + CMOCK_vkGetQueryPoolResults_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetQueryPoolResults_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetQueryPoolResults_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pData_Used = 1; + cmock_call_instance->ReturnThruPtr_pData_Val = pData; + cmock_call_instance->ReturnThruPtr_pData_Size = cmock_size; +} + +void vkGetQueryPoolResults_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetQueryPoolResults_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetQueryPoolResults_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetQueryPoolResults_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetQueryPoolResults_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetQueryPoolResults_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetQueryPoolResults_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetQueryPoolResults_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queryPool = 1; +} + +void vkGetQueryPoolResults_CMockIgnoreArg_firstQuery(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetQueryPoolResults_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetQueryPoolResults_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetQueryPoolResults_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstQuery = 1; +} + +void vkGetQueryPoolResults_CMockIgnoreArg_queryCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetQueryPoolResults_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetQueryPoolResults_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetQueryPoolResults_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queryCount = 1; +} + +void vkGetQueryPoolResults_CMockIgnoreArg_dataSize(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetQueryPoolResults_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetQueryPoolResults_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetQueryPoolResults_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dataSize = 1; +} + +void vkGetQueryPoolResults_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetQueryPoolResults_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetQueryPoolResults_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetQueryPoolResults_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pData = 1; +} + +void vkGetQueryPoolResults_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetQueryPoolResults_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetQueryPoolResults_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetQueryPoolResults_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stride = 1; +} + +void vkGetQueryPoolResults_CMockIgnoreArg_flags(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetQueryPoolResults_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetQueryPoolResults_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetQueryPoolResults_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_flags = 1; +} + +VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateBuffer_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateBuffer); + cmock_call_instance = (CMOCK_vkCreateBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateBuffer_CallInstance); + Mock.vkCreateBuffer_CallInstance = CMock_Guts_MemNext(Mock.vkCreateBuffer_CallInstance); + if (Mock.vkCreateBuffer_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateBuffer_FinalReturn; + memcpy((void*)(&Mock.vkCreateBuffer_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateBuffer_CallbackBool && + Mock.vkCreateBuffer_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateBuffer_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pBuffer, Mock.vkCreateBuffer_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateBuffer,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateBuffer,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkBufferCreateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateBuffer,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCreateBuffer,CMockString_pBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pBuffer), (void*)(pBuffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateBuffer_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateBuffer_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pBuffer, Mock.vkCreateBuffer_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pBuffer_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pBuffer, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pBuffer, (const void*)cmock_call_instance->ReturnThruPtr_pBuffer_Val, + cmock_call_instance->ReturnThruPtr_pBuffer_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateBuffer(CMOCK_vkCreateBuffer_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer); +void CMockExpectParameters_vkCreateBuffer(CMOCK_vkCreateBuffer_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pBuffer = pBuffer; + cmock_call_instance->IgnoreArg_pBuffer = 0; + cmock_call_instance->ReturnThruPtr_pBuffer_Used = 0; +} + +void vkCreateBuffer_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateBuffer_CALL_INSTANCE)); + CMOCK_vkCreateBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateBuffer_CallInstance = CMock_Guts_MemChain(Mock.vkCreateBuffer_CallInstance, cmock_guts_index); + Mock.vkCreateBuffer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateBuffer_IgnoreBool = (char)1; +} + +void vkCreateBuffer_CMockStopIgnore(void) +{ + if(Mock.vkCreateBuffer_IgnoreBool) + Mock.vkCreateBuffer_CallInstance = CMock_Guts_MemNext(Mock.vkCreateBuffer_CallInstance); + Mock.vkCreateBuffer_IgnoreBool = (char)0; +} + +void vkCreateBuffer_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateBuffer_CALL_INSTANCE)); + CMOCK_vkCreateBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateBuffer_CallInstance = CMock_Guts_MemChain(Mock.vkCreateBuffer_CallInstance, cmock_guts_index); + Mock.vkCreateBuffer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateBuffer_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateBuffer_CALL_INSTANCE)); + CMOCK_vkCreateBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateBuffer_CallInstance = CMock_Guts_MemChain(Mock.vkCreateBuffer_CallInstance, cmock_guts_index); + Mock.vkCreateBuffer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateBuffer(cmock_call_instance, device, pCreateInfo, pAllocator, pBuffer); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateBuffer_AddCallback(CMOCK_vkCreateBuffer_CALLBACK Callback) +{ + Mock.vkCreateBuffer_IgnoreBool = (char)0; + Mock.vkCreateBuffer_CallbackBool = (char)1; + Mock.vkCreateBuffer_CallbackFunctionPointer = Callback; +} + +void vkCreateBuffer_Stub(CMOCK_vkCreateBuffer_CALLBACK Callback) +{ + Mock.vkCreateBuffer_IgnoreBool = (char)0; + Mock.vkCreateBuffer_CallbackBool = (char)0; + Mock.vkCreateBuffer_CallbackFunctionPointer = Callback; +} + +void vkCreateBuffer_CMockReturnMemThruPtr_pBuffer(UNITY_LINE_TYPE cmock_line, VkBuffer const* pBuffer, size_t cmock_size) +{ + CMOCK_vkCreateBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pBuffer_Used = 1; + cmock_call_instance->ReturnThruPtr_pBuffer_Val = pBuffer; + cmock_call_instance->ReturnThruPtr_pBuffer_Size = cmock_size; +} + +void vkCreateBuffer_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateBuffer_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateBuffer_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateBuffer_CMockIgnoreArg_pBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pBuffer = 1; +} + +void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyBuffer_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyBuffer); + cmock_call_instance = (CMOCK_vkDestroyBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyBuffer_CallInstance); + Mock.vkDestroyBuffer_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyBuffer_CallInstance); + if (Mock.vkDestroyBuffer_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyBuffer_CallbackBool && + Mock.vkDestroyBuffer_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyBuffer_CallbackFunctionPointer(device, buffer, pAllocator, Mock.vkDestroyBuffer_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyBuffer,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_buffer) + { + UNITY_SET_DETAILS(CMockString_vkDestroyBuffer,CMockString_buffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyBuffer,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyBuffer_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyBuffer_CallbackFunctionPointer(device, buffer, pAllocator, Mock.vkDestroyBuffer_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyBuffer(CMOCK_vkDestroyBuffer_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyBuffer(CMOCK_vkDestroyBuffer_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), + sizeof(VkBuffer[sizeof(buffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_buffer = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyBuffer_CMockIgnore(void) +{ + Mock.vkDestroyBuffer_IgnoreBool = (char)1; +} + +void vkDestroyBuffer_CMockStopIgnore(void) +{ + Mock.vkDestroyBuffer_IgnoreBool = (char)0; +} + +void vkDestroyBuffer_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyBuffer_CALL_INSTANCE)); + CMOCK_vkDestroyBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyBuffer_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyBuffer_CallInstance, cmock_guts_index); + Mock.vkDestroyBuffer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyBuffer_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyBuffer_CALL_INSTANCE)); + CMOCK_vkDestroyBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyBuffer_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyBuffer_CallInstance, cmock_guts_index); + Mock.vkDestroyBuffer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyBuffer(cmock_call_instance, device, buffer, pAllocator); +} + +void vkDestroyBuffer_AddCallback(CMOCK_vkDestroyBuffer_CALLBACK Callback) +{ + Mock.vkDestroyBuffer_IgnoreBool = (char)0; + Mock.vkDestroyBuffer_CallbackBool = (char)1; + Mock.vkDestroyBuffer_CallbackFunctionPointer = Callback; +} + +void vkDestroyBuffer_Stub(CMOCK_vkDestroyBuffer_CALLBACK Callback) +{ + Mock.vkDestroyBuffer_IgnoreBool = (char)0; + Mock.vkDestroyBuffer_CallbackBool = (char)0; + Mock.vkDestroyBuffer_CallbackFunctionPointer = Callback; +} + +void vkDestroyBuffer_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyBuffer_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_buffer = 1; +} + +void vkDestroyBuffer_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +VkResult vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateBufferView_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateBufferView); + cmock_call_instance = (CMOCK_vkCreateBufferView_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateBufferView_CallInstance); + Mock.vkCreateBufferView_CallInstance = CMock_Guts_MemNext(Mock.vkCreateBufferView_CallInstance); + if (Mock.vkCreateBufferView_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateBufferView_FinalReturn; + memcpy((void*)(&Mock.vkCreateBufferView_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateBufferView_CallbackBool && + Mock.vkCreateBufferView_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateBufferView_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pView, Mock.vkCreateBufferView_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateBufferView,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateBufferView,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkBufferViewCreateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateBufferView,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pView) + { + UNITY_SET_DETAILS(CMockString_vkCreateBufferView,CMockString_pView); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pView), (void*)(pView), sizeof(VkBufferView), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateBufferView_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateBufferView_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pView, Mock.vkCreateBufferView_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pView_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pView, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pView, (const void*)cmock_call_instance->ReturnThruPtr_pView_Val, + cmock_call_instance->ReturnThruPtr_pView_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateBufferView(CMOCK_vkCreateBufferView_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView); +void CMockExpectParameters_vkCreateBufferView(CMOCK_vkCreateBufferView_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pView = pView; + cmock_call_instance->IgnoreArg_pView = 0; + cmock_call_instance->ReturnThruPtr_pView_Used = 0; +} + +void vkCreateBufferView_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateBufferView_CALL_INSTANCE)); + CMOCK_vkCreateBufferView_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateBufferView_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateBufferView_CallInstance = CMock_Guts_MemChain(Mock.vkCreateBufferView_CallInstance, cmock_guts_index); + Mock.vkCreateBufferView_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateBufferView_IgnoreBool = (char)1; +} + +void vkCreateBufferView_CMockStopIgnore(void) +{ + if(Mock.vkCreateBufferView_IgnoreBool) + Mock.vkCreateBufferView_CallInstance = CMock_Guts_MemNext(Mock.vkCreateBufferView_CallInstance); + Mock.vkCreateBufferView_IgnoreBool = (char)0; +} + +void vkCreateBufferView_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateBufferView_CALL_INSTANCE)); + CMOCK_vkCreateBufferView_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateBufferView_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateBufferView_CallInstance = CMock_Guts_MemChain(Mock.vkCreateBufferView_CallInstance, cmock_guts_index); + Mock.vkCreateBufferView_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateBufferView_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateBufferView_CALL_INSTANCE)); + CMOCK_vkCreateBufferView_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateBufferView_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateBufferView_CallInstance = CMock_Guts_MemChain(Mock.vkCreateBufferView_CallInstance, cmock_guts_index); + Mock.vkCreateBufferView_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateBufferView(cmock_call_instance, device, pCreateInfo, pAllocator, pView); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateBufferView_AddCallback(CMOCK_vkCreateBufferView_CALLBACK Callback) +{ + Mock.vkCreateBufferView_IgnoreBool = (char)0; + Mock.vkCreateBufferView_CallbackBool = (char)1; + Mock.vkCreateBufferView_CallbackFunctionPointer = Callback; +} + +void vkCreateBufferView_Stub(CMOCK_vkCreateBufferView_CALLBACK Callback) +{ + Mock.vkCreateBufferView_IgnoreBool = (char)0; + Mock.vkCreateBufferView_CallbackBool = (char)0; + Mock.vkCreateBufferView_CallbackFunctionPointer = Callback; +} + +void vkCreateBufferView_CMockReturnMemThruPtr_pView(UNITY_LINE_TYPE cmock_line, VkBufferView const* pView, size_t cmock_size) +{ + CMOCK_vkCreateBufferView_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateBufferView_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateBufferView_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pView_Used = 1; + cmock_call_instance->ReturnThruPtr_pView_Val = pView; + cmock_call_instance->ReturnThruPtr_pView_Size = cmock_size; +} + +void vkCreateBufferView_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateBufferView_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateBufferView_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateBufferView_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateBufferView_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateBufferView_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateBufferView_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateBufferView_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateBufferView_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateBufferView_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateBufferView_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateBufferView_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateBufferView_CMockIgnoreArg_pView(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateBufferView_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateBufferView_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateBufferView_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pView = 1; +} + +void vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyBufferView_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyBufferView); + cmock_call_instance = (CMOCK_vkDestroyBufferView_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyBufferView_CallInstance); + Mock.vkDestroyBufferView_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyBufferView_CallInstance); + if (Mock.vkDestroyBufferView_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyBufferView_CallbackBool && + Mock.vkDestroyBufferView_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyBufferView_CallbackFunctionPointer(device, bufferView, pAllocator, Mock.vkDestroyBufferView_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyBufferView,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_bufferView) + { + UNITY_SET_DETAILS(CMockString_vkDestroyBufferView,CMockString_bufferView); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_bufferView), (void*)(&bufferView), sizeof(VkBufferView), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyBufferView,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyBufferView_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyBufferView_CallbackFunctionPointer(device, bufferView, pAllocator, Mock.vkDestroyBufferView_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyBufferView(CMOCK_vkDestroyBufferView_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyBufferView(CMOCK_vkDestroyBufferView_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_bufferView), (void*)(&bufferView), + sizeof(VkBufferView[sizeof(bufferView) == sizeof(VkBufferView) ? 1 : -1])); /* add VkBufferView to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_bufferView = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyBufferView_CMockIgnore(void) +{ + Mock.vkDestroyBufferView_IgnoreBool = (char)1; +} + +void vkDestroyBufferView_CMockStopIgnore(void) +{ + Mock.vkDestroyBufferView_IgnoreBool = (char)0; +} + +void vkDestroyBufferView_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyBufferView_CALL_INSTANCE)); + CMOCK_vkDestroyBufferView_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyBufferView_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyBufferView_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyBufferView_CallInstance, cmock_guts_index); + Mock.vkDestroyBufferView_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyBufferView_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyBufferView_CALL_INSTANCE)); + CMOCK_vkDestroyBufferView_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyBufferView_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyBufferView_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyBufferView_CallInstance, cmock_guts_index); + Mock.vkDestroyBufferView_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyBufferView(cmock_call_instance, device, bufferView, pAllocator); +} + +void vkDestroyBufferView_AddCallback(CMOCK_vkDestroyBufferView_CALLBACK Callback) +{ + Mock.vkDestroyBufferView_IgnoreBool = (char)0; + Mock.vkDestroyBufferView_CallbackBool = (char)1; + Mock.vkDestroyBufferView_CallbackFunctionPointer = Callback; +} + +void vkDestroyBufferView_Stub(CMOCK_vkDestroyBufferView_CALLBACK Callback) +{ + Mock.vkDestroyBufferView_IgnoreBool = (char)0; + Mock.vkDestroyBufferView_CallbackBool = (char)0; + Mock.vkDestroyBufferView_CallbackFunctionPointer = Callback; +} + +void vkDestroyBufferView_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyBufferView_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyBufferView_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyBufferView_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyBufferView_CMockIgnoreArg_bufferView(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyBufferView_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyBufferView_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyBufferView_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_bufferView = 1; +} + +void vkDestroyBufferView_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyBufferView_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyBufferView_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyBufferView_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateImage_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateImage); + cmock_call_instance = (CMOCK_vkCreateImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateImage_CallInstance); + Mock.vkCreateImage_CallInstance = CMock_Guts_MemNext(Mock.vkCreateImage_CallInstance); + if (Mock.vkCreateImage_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateImage_FinalReturn; + memcpy((void*)(&Mock.vkCreateImage_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateImage_CallbackBool && + Mock.vkCreateImage_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateImage_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pImage, Mock.vkCreateImage_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateImage,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateImage,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkImageCreateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateImage,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pImage) + { + UNITY_SET_DETAILS(CMockString_vkCreateImage,CMockString_pImage); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pImage), (void*)(pImage), sizeof(VkImage), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateImage_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateImage_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pImage, Mock.vkCreateImage_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pImage_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pImage, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pImage, (const void*)cmock_call_instance->ReturnThruPtr_pImage_Val, + cmock_call_instance->ReturnThruPtr_pImage_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateImage(CMOCK_vkCreateImage_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage); +void CMockExpectParameters_vkCreateImage(CMOCK_vkCreateImage_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pImage = pImage; + cmock_call_instance->IgnoreArg_pImage = 0; + cmock_call_instance->ReturnThruPtr_pImage_Used = 0; +} + +void vkCreateImage_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateImage_CALL_INSTANCE)); + CMOCK_vkCreateImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateImage_CallInstance = CMock_Guts_MemChain(Mock.vkCreateImage_CallInstance, cmock_guts_index); + Mock.vkCreateImage_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateImage_IgnoreBool = (char)1; +} + +void vkCreateImage_CMockStopIgnore(void) +{ + if(Mock.vkCreateImage_IgnoreBool) + Mock.vkCreateImage_CallInstance = CMock_Guts_MemNext(Mock.vkCreateImage_CallInstance); + Mock.vkCreateImage_IgnoreBool = (char)0; +} + +void vkCreateImage_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateImage_CALL_INSTANCE)); + CMOCK_vkCreateImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateImage_CallInstance = CMock_Guts_MemChain(Mock.vkCreateImage_CallInstance, cmock_guts_index); + Mock.vkCreateImage_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateImage_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateImage_CALL_INSTANCE)); + CMOCK_vkCreateImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateImage_CallInstance = CMock_Guts_MemChain(Mock.vkCreateImage_CallInstance, cmock_guts_index); + Mock.vkCreateImage_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateImage(cmock_call_instance, device, pCreateInfo, pAllocator, pImage); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateImage_AddCallback(CMOCK_vkCreateImage_CALLBACK Callback) +{ + Mock.vkCreateImage_IgnoreBool = (char)0; + Mock.vkCreateImage_CallbackBool = (char)1; + Mock.vkCreateImage_CallbackFunctionPointer = Callback; +} + +void vkCreateImage_Stub(CMOCK_vkCreateImage_CALLBACK Callback) +{ + Mock.vkCreateImage_IgnoreBool = (char)0; + Mock.vkCreateImage_CallbackBool = (char)0; + Mock.vkCreateImage_CallbackFunctionPointer = Callback; +} + +void vkCreateImage_CMockReturnMemThruPtr_pImage(UNITY_LINE_TYPE cmock_line, VkImage const* pImage, size_t cmock_size) +{ + CMOCK_vkCreateImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pImage_Used = 1; + cmock_call_instance->ReturnThruPtr_pImage_Val = pImage; + cmock_call_instance->ReturnThruPtr_pImage_Size = cmock_size; +} + +void vkCreateImage_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateImage_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateImage_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateImage_CMockIgnoreArg_pImage(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pImage = 1; +} + +void vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyImage_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyImage); + cmock_call_instance = (CMOCK_vkDestroyImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyImage_CallInstance); + Mock.vkDestroyImage_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyImage_CallInstance); + if (Mock.vkDestroyImage_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyImage_CallbackBool && + Mock.vkDestroyImage_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyImage_CallbackFunctionPointer(device, image, pAllocator, Mock.vkDestroyImage_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyImage,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_image) + { + UNITY_SET_DETAILS(CMockString_vkDestroyImage,CMockString_image); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_image), (void*)(&image), sizeof(VkImage), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyImage,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyImage_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyImage_CallbackFunctionPointer(device, image, pAllocator, Mock.vkDestroyImage_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyImage(CMOCK_vkDestroyImage_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyImage(CMOCK_vkDestroyImage_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_image), (void*)(&image), + sizeof(VkImage[sizeof(image) == sizeof(VkImage) ? 1 : -1])); /* add VkImage to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_image = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyImage_CMockIgnore(void) +{ + Mock.vkDestroyImage_IgnoreBool = (char)1; +} + +void vkDestroyImage_CMockStopIgnore(void) +{ + Mock.vkDestroyImage_IgnoreBool = (char)0; +} + +void vkDestroyImage_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyImage_CALL_INSTANCE)); + CMOCK_vkDestroyImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyImage_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyImage_CallInstance, cmock_guts_index); + Mock.vkDestroyImage_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyImage_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyImage_CALL_INSTANCE)); + CMOCK_vkDestroyImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyImage_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyImage_CallInstance, cmock_guts_index); + Mock.vkDestroyImage_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyImage(cmock_call_instance, device, image, pAllocator); +} + +void vkDestroyImage_AddCallback(CMOCK_vkDestroyImage_CALLBACK Callback) +{ + Mock.vkDestroyImage_IgnoreBool = (char)0; + Mock.vkDestroyImage_CallbackBool = (char)1; + Mock.vkDestroyImage_CallbackFunctionPointer = Callback; +} + +void vkDestroyImage_Stub(CMOCK_vkDestroyImage_CALLBACK Callback) +{ + Mock.vkDestroyImage_IgnoreBool = (char)0; + Mock.vkDestroyImage_CallbackBool = (char)0; + Mock.vkDestroyImage_CallbackFunctionPointer = Callback; +} + +void vkDestroyImage_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyImage_CMockIgnoreArg_image(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_image = 1; +} + +void vkDestroyImage_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetImageSubresourceLayout_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetImageSubresourceLayout); + cmock_call_instance = (CMOCK_vkGetImageSubresourceLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetImageSubresourceLayout_CallInstance); + Mock.vkGetImageSubresourceLayout_CallInstance = CMock_Guts_MemNext(Mock.vkGetImageSubresourceLayout_CallInstance); + if (Mock.vkGetImageSubresourceLayout_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetImageSubresourceLayout_CallbackBool && + Mock.vkGetImageSubresourceLayout_CallbackFunctionPointer != NULL) + { + Mock.vkGetImageSubresourceLayout_CallbackFunctionPointer(device, image, pSubresource, pLayout, Mock.vkGetImageSubresourceLayout_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetImageSubresourceLayout,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_image) + { + UNITY_SET_DETAILS(CMockString_vkGetImageSubresourceLayout,CMockString_image); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_image), (void*)(&image), sizeof(VkImage), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSubresource) + { + UNITY_SET_DETAILS(CMockString_vkGetImageSubresourceLayout,CMockString_pSubresource); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSubresource), (void*)(pSubresource), sizeof(const VkImageSubresource), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pLayout) + { + UNITY_SET_DETAILS(CMockString_vkGetImageSubresourceLayout,CMockString_pLayout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pLayout), (void*)(pLayout), sizeof(VkSubresourceLayout), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetImageSubresourceLayout_CallbackFunctionPointer != NULL) + { + Mock.vkGetImageSubresourceLayout_CallbackFunctionPointer(device, image, pSubresource, pLayout, Mock.vkGetImageSubresourceLayout_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pLayout_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pLayout, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pLayout, (const void*)cmock_call_instance->ReturnThruPtr_pLayout_Val, + cmock_call_instance->ReturnThruPtr_pLayout_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetImageSubresourceLayout(CMOCK_vkGetImageSubresourceLayout_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); +void CMockExpectParameters_vkGetImageSubresourceLayout(CMOCK_vkGetImageSubresourceLayout_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_image), (void*)(&image), + sizeof(VkImage[sizeof(image) == sizeof(VkImage) ? 1 : -1])); /* add VkImage to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_image = 0; + cmock_call_instance->Expected_pSubresource = pSubresource; + cmock_call_instance->IgnoreArg_pSubresource = 0; + cmock_call_instance->Expected_pLayout = pLayout; + cmock_call_instance->IgnoreArg_pLayout = 0; + cmock_call_instance->ReturnThruPtr_pLayout_Used = 0; +} + +void vkGetImageSubresourceLayout_CMockIgnore(void) +{ + Mock.vkGetImageSubresourceLayout_IgnoreBool = (char)1; +} + +void vkGetImageSubresourceLayout_CMockStopIgnore(void) +{ + Mock.vkGetImageSubresourceLayout_IgnoreBool = (char)0; +} + +void vkGetImageSubresourceLayout_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageSubresourceLayout_CALL_INSTANCE)); + CMOCK_vkGetImageSubresourceLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSubresourceLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageSubresourceLayout_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageSubresourceLayout_CallInstance, cmock_guts_index); + Mock.vkGetImageSubresourceLayout_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetImageSubresourceLayout_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageSubresourceLayout_CALL_INSTANCE)); + CMOCK_vkGetImageSubresourceLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSubresourceLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageSubresourceLayout_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageSubresourceLayout_CallInstance, cmock_guts_index); + Mock.vkGetImageSubresourceLayout_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetImageSubresourceLayout(cmock_call_instance, device, image, pSubresource, pLayout); +} + +void vkGetImageSubresourceLayout_AddCallback(CMOCK_vkGetImageSubresourceLayout_CALLBACK Callback) +{ + Mock.vkGetImageSubresourceLayout_IgnoreBool = (char)0; + Mock.vkGetImageSubresourceLayout_CallbackBool = (char)1; + Mock.vkGetImageSubresourceLayout_CallbackFunctionPointer = Callback; +} + +void vkGetImageSubresourceLayout_Stub(CMOCK_vkGetImageSubresourceLayout_CALLBACK Callback) +{ + Mock.vkGetImageSubresourceLayout_IgnoreBool = (char)0; + Mock.vkGetImageSubresourceLayout_CallbackBool = (char)0; + Mock.vkGetImageSubresourceLayout_CallbackFunctionPointer = Callback; +} + +void vkGetImageSubresourceLayout_CMockReturnMemThruPtr_pLayout(UNITY_LINE_TYPE cmock_line, VkSubresourceLayout const* pLayout, size_t cmock_size) +{ + CMOCK_vkGetImageSubresourceLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSubresourceLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageSubresourceLayout_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pLayout_Used = 1; + cmock_call_instance->ReturnThruPtr_pLayout_Val = pLayout; + cmock_call_instance->ReturnThruPtr_pLayout_Size = cmock_size; +} + +void vkGetImageSubresourceLayout_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageSubresourceLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSubresourceLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageSubresourceLayout_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetImageSubresourceLayout_CMockIgnoreArg_image(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageSubresourceLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSubresourceLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageSubresourceLayout_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_image = 1; +} + +void vkGetImageSubresourceLayout_CMockIgnoreArg_pSubresource(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageSubresourceLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSubresourceLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageSubresourceLayout_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSubresource = 1; +} + +void vkGetImageSubresourceLayout_CMockIgnoreArg_pLayout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageSubresourceLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSubresourceLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageSubresourceLayout_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pLayout = 1; +} + +VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateImageView_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateImageView); + cmock_call_instance = (CMOCK_vkCreateImageView_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateImageView_CallInstance); + Mock.vkCreateImageView_CallInstance = CMock_Guts_MemNext(Mock.vkCreateImageView_CallInstance); + if (Mock.vkCreateImageView_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateImageView_FinalReturn; + memcpy((void*)(&Mock.vkCreateImageView_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateImageView_CallbackBool && + Mock.vkCreateImageView_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateImageView_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pView, Mock.vkCreateImageView_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateImageView,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateImageView,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkImageViewCreateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateImageView,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pView) + { + UNITY_SET_DETAILS(CMockString_vkCreateImageView,CMockString_pView); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pView), (void*)(pView), sizeof(VkImageView), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateImageView_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateImageView_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pView, Mock.vkCreateImageView_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pView_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pView, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pView, (const void*)cmock_call_instance->ReturnThruPtr_pView_Val, + cmock_call_instance->ReturnThruPtr_pView_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateImageView(CMOCK_vkCreateImageView_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView); +void CMockExpectParameters_vkCreateImageView(CMOCK_vkCreateImageView_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pView = pView; + cmock_call_instance->IgnoreArg_pView = 0; + cmock_call_instance->ReturnThruPtr_pView_Used = 0; +} + +void vkCreateImageView_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateImageView_CALL_INSTANCE)); + CMOCK_vkCreateImageView_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateImageView_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateImageView_CallInstance = CMock_Guts_MemChain(Mock.vkCreateImageView_CallInstance, cmock_guts_index); + Mock.vkCreateImageView_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateImageView_IgnoreBool = (char)1; +} + +void vkCreateImageView_CMockStopIgnore(void) +{ + if(Mock.vkCreateImageView_IgnoreBool) + Mock.vkCreateImageView_CallInstance = CMock_Guts_MemNext(Mock.vkCreateImageView_CallInstance); + Mock.vkCreateImageView_IgnoreBool = (char)0; +} + +void vkCreateImageView_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateImageView_CALL_INSTANCE)); + CMOCK_vkCreateImageView_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateImageView_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateImageView_CallInstance = CMock_Guts_MemChain(Mock.vkCreateImageView_CallInstance, cmock_guts_index); + Mock.vkCreateImageView_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateImageView_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateImageView_CALL_INSTANCE)); + CMOCK_vkCreateImageView_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateImageView_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateImageView_CallInstance = CMock_Guts_MemChain(Mock.vkCreateImageView_CallInstance, cmock_guts_index); + Mock.vkCreateImageView_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateImageView(cmock_call_instance, device, pCreateInfo, pAllocator, pView); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateImageView_AddCallback(CMOCK_vkCreateImageView_CALLBACK Callback) +{ + Mock.vkCreateImageView_IgnoreBool = (char)0; + Mock.vkCreateImageView_CallbackBool = (char)1; + Mock.vkCreateImageView_CallbackFunctionPointer = Callback; +} + +void vkCreateImageView_Stub(CMOCK_vkCreateImageView_CALLBACK Callback) +{ + Mock.vkCreateImageView_IgnoreBool = (char)0; + Mock.vkCreateImageView_CallbackBool = (char)0; + Mock.vkCreateImageView_CallbackFunctionPointer = Callback; +} + +void vkCreateImageView_CMockReturnMemThruPtr_pView(UNITY_LINE_TYPE cmock_line, VkImageView const* pView, size_t cmock_size) +{ + CMOCK_vkCreateImageView_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateImageView_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateImageView_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pView_Used = 1; + cmock_call_instance->ReturnThruPtr_pView_Val = pView; + cmock_call_instance->ReturnThruPtr_pView_Size = cmock_size; +} + +void vkCreateImageView_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateImageView_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateImageView_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateImageView_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateImageView_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateImageView_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateImageView_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateImageView_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateImageView_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateImageView_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateImageView_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateImageView_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateImageView_CMockIgnoreArg_pView(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateImageView_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateImageView_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateImageView_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pView = 1; +} + +void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyImageView_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyImageView); + cmock_call_instance = (CMOCK_vkDestroyImageView_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyImageView_CallInstance); + Mock.vkDestroyImageView_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyImageView_CallInstance); + if (Mock.vkDestroyImageView_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyImageView_CallbackBool && + Mock.vkDestroyImageView_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyImageView_CallbackFunctionPointer(device, imageView, pAllocator, Mock.vkDestroyImageView_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyImageView,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_imageView) + { + UNITY_SET_DETAILS(CMockString_vkDestroyImageView,CMockString_imageView); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_imageView), (void*)(&imageView), sizeof(VkImageView), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyImageView,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyImageView_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyImageView_CallbackFunctionPointer(device, imageView, pAllocator, Mock.vkDestroyImageView_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyImageView(CMOCK_vkDestroyImageView_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyImageView(CMOCK_vkDestroyImageView_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_imageView), (void*)(&imageView), + sizeof(VkImageView[sizeof(imageView) == sizeof(VkImageView) ? 1 : -1])); /* add VkImageView to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_imageView = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyImageView_CMockIgnore(void) +{ + Mock.vkDestroyImageView_IgnoreBool = (char)1; +} + +void vkDestroyImageView_CMockStopIgnore(void) +{ + Mock.vkDestroyImageView_IgnoreBool = (char)0; +} + +void vkDestroyImageView_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyImageView_CALL_INSTANCE)); + CMOCK_vkDestroyImageView_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyImageView_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyImageView_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyImageView_CallInstance, cmock_guts_index); + Mock.vkDestroyImageView_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyImageView_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyImageView_CALL_INSTANCE)); + CMOCK_vkDestroyImageView_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyImageView_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyImageView_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyImageView_CallInstance, cmock_guts_index); + Mock.vkDestroyImageView_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyImageView(cmock_call_instance, device, imageView, pAllocator); +} + +void vkDestroyImageView_AddCallback(CMOCK_vkDestroyImageView_CALLBACK Callback) +{ + Mock.vkDestroyImageView_IgnoreBool = (char)0; + Mock.vkDestroyImageView_CallbackBool = (char)1; + Mock.vkDestroyImageView_CallbackFunctionPointer = Callback; +} + +void vkDestroyImageView_Stub(CMOCK_vkDestroyImageView_CALLBACK Callback) +{ + Mock.vkDestroyImageView_IgnoreBool = (char)0; + Mock.vkDestroyImageView_CallbackBool = (char)0; + Mock.vkDestroyImageView_CallbackFunctionPointer = Callback; +} + +void vkDestroyImageView_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyImageView_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyImageView_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyImageView_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyImageView_CMockIgnoreArg_imageView(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyImageView_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyImageView_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyImageView_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_imageView = 1; +} + +void vkDestroyImageView_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyImageView_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyImageView_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyImageView_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +VkResult vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateShaderModule_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateShaderModule); + cmock_call_instance = (CMOCK_vkCreateShaderModule_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateShaderModule_CallInstance); + Mock.vkCreateShaderModule_CallInstance = CMock_Guts_MemNext(Mock.vkCreateShaderModule_CallInstance); + if (Mock.vkCreateShaderModule_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateShaderModule_FinalReturn; + memcpy((void*)(&Mock.vkCreateShaderModule_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateShaderModule_CallbackBool && + Mock.vkCreateShaderModule_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateShaderModule_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pShaderModule, Mock.vkCreateShaderModule_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateShaderModule,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateShaderModule,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkShaderModuleCreateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateShaderModule,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pShaderModule) + { + UNITY_SET_DETAILS(CMockString_vkCreateShaderModule,CMockString_pShaderModule); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pShaderModule), (void*)(pShaderModule), sizeof(VkShaderModule), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateShaderModule_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateShaderModule_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pShaderModule, Mock.vkCreateShaderModule_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pShaderModule_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pShaderModule, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pShaderModule, (const void*)cmock_call_instance->ReturnThruPtr_pShaderModule_Val, + cmock_call_instance->ReturnThruPtr_pShaderModule_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateShaderModule(CMOCK_vkCreateShaderModule_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule); +void CMockExpectParameters_vkCreateShaderModule(CMOCK_vkCreateShaderModule_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pShaderModule = pShaderModule; + cmock_call_instance->IgnoreArg_pShaderModule = 0; + cmock_call_instance->ReturnThruPtr_pShaderModule_Used = 0; +} + +void vkCreateShaderModule_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateShaderModule_CALL_INSTANCE)); + CMOCK_vkCreateShaderModule_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateShaderModule_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateShaderModule_CallInstance = CMock_Guts_MemChain(Mock.vkCreateShaderModule_CallInstance, cmock_guts_index); + Mock.vkCreateShaderModule_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateShaderModule_IgnoreBool = (char)1; +} + +void vkCreateShaderModule_CMockStopIgnore(void) +{ + if(Mock.vkCreateShaderModule_IgnoreBool) + Mock.vkCreateShaderModule_CallInstance = CMock_Guts_MemNext(Mock.vkCreateShaderModule_CallInstance); + Mock.vkCreateShaderModule_IgnoreBool = (char)0; +} + +void vkCreateShaderModule_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateShaderModule_CALL_INSTANCE)); + CMOCK_vkCreateShaderModule_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateShaderModule_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateShaderModule_CallInstance = CMock_Guts_MemChain(Mock.vkCreateShaderModule_CallInstance, cmock_guts_index); + Mock.vkCreateShaderModule_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateShaderModule_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateShaderModule_CALL_INSTANCE)); + CMOCK_vkCreateShaderModule_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateShaderModule_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateShaderModule_CallInstance = CMock_Guts_MemChain(Mock.vkCreateShaderModule_CallInstance, cmock_guts_index); + Mock.vkCreateShaderModule_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateShaderModule(cmock_call_instance, device, pCreateInfo, pAllocator, pShaderModule); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateShaderModule_AddCallback(CMOCK_vkCreateShaderModule_CALLBACK Callback) +{ + Mock.vkCreateShaderModule_IgnoreBool = (char)0; + Mock.vkCreateShaderModule_CallbackBool = (char)1; + Mock.vkCreateShaderModule_CallbackFunctionPointer = Callback; +} + +void vkCreateShaderModule_Stub(CMOCK_vkCreateShaderModule_CALLBACK Callback) +{ + Mock.vkCreateShaderModule_IgnoreBool = (char)0; + Mock.vkCreateShaderModule_CallbackBool = (char)0; + Mock.vkCreateShaderModule_CallbackFunctionPointer = Callback; +} + +void vkCreateShaderModule_CMockReturnMemThruPtr_pShaderModule(UNITY_LINE_TYPE cmock_line, VkShaderModule const* pShaderModule, size_t cmock_size) +{ + CMOCK_vkCreateShaderModule_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateShaderModule_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateShaderModule_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pShaderModule_Used = 1; + cmock_call_instance->ReturnThruPtr_pShaderModule_Val = pShaderModule; + cmock_call_instance->ReturnThruPtr_pShaderModule_Size = cmock_size; +} + +void vkCreateShaderModule_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateShaderModule_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateShaderModule_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateShaderModule_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateShaderModule_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateShaderModule_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateShaderModule_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateShaderModule_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateShaderModule_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateShaderModule_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateShaderModule_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateShaderModule_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateShaderModule_CMockIgnoreArg_pShaderModule(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateShaderModule_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateShaderModule_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateShaderModule_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pShaderModule = 1; +} + +void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyShaderModule_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyShaderModule); + cmock_call_instance = (CMOCK_vkDestroyShaderModule_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyShaderModule_CallInstance); + Mock.vkDestroyShaderModule_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyShaderModule_CallInstance); + if (Mock.vkDestroyShaderModule_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyShaderModule_CallbackBool && + Mock.vkDestroyShaderModule_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyShaderModule_CallbackFunctionPointer(device, shaderModule, pAllocator, Mock.vkDestroyShaderModule_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyShaderModule,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_shaderModule) + { + UNITY_SET_DETAILS(CMockString_vkDestroyShaderModule,CMockString_shaderModule); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_shaderModule), (void*)(&shaderModule), sizeof(VkShaderModule), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyShaderModule,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyShaderModule_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyShaderModule_CallbackFunctionPointer(device, shaderModule, pAllocator, Mock.vkDestroyShaderModule_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyShaderModule(CMOCK_vkDestroyShaderModule_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyShaderModule(CMOCK_vkDestroyShaderModule_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_shaderModule), (void*)(&shaderModule), + sizeof(VkShaderModule[sizeof(shaderModule) == sizeof(VkShaderModule) ? 1 : -1])); /* add VkShaderModule to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_shaderModule = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyShaderModule_CMockIgnore(void) +{ + Mock.vkDestroyShaderModule_IgnoreBool = (char)1; +} + +void vkDestroyShaderModule_CMockStopIgnore(void) +{ + Mock.vkDestroyShaderModule_IgnoreBool = (char)0; +} + +void vkDestroyShaderModule_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyShaderModule_CALL_INSTANCE)); + CMOCK_vkDestroyShaderModule_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyShaderModule_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyShaderModule_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyShaderModule_CallInstance, cmock_guts_index); + Mock.vkDestroyShaderModule_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyShaderModule_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyShaderModule_CALL_INSTANCE)); + CMOCK_vkDestroyShaderModule_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyShaderModule_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyShaderModule_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyShaderModule_CallInstance, cmock_guts_index); + Mock.vkDestroyShaderModule_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyShaderModule(cmock_call_instance, device, shaderModule, pAllocator); +} + +void vkDestroyShaderModule_AddCallback(CMOCK_vkDestroyShaderModule_CALLBACK Callback) +{ + Mock.vkDestroyShaderModule_IgnoreBool = (char)0; + Mock.vkDestroyShaderModule_CallbackBool = (char)1; + Mock.vkDestroyShaderModule_CallbackFunctionPointer = Callback; +} + +void vkDestroyShaderModule_Stub(CMOCK_vkDestroyShaderModule_CALLBACK Callback) +{ + Mock.vkDestroyShaderModule_IgnoreBool = (char)0; + Mock.vkDestroyShaderModule_CallbackBool = (char)0; + Mock.vkDestroyShaderModule_CallbackFunctionPointer = Callback; +} + +void vkDestroyShaderModule_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyShaderModule_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyShaderModule_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyShaderModule_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyShaderModule_CMockIgnoreArg_shaderModule(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyShaderModule_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyShaderModule_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyShaderModule_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_shaderModule = 1; +} + +void vkDestroyShaderModule_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyShaderModule_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyShaderModule_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyShaderModule_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +VkResult vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreatePipelineCache_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreatePipelineCache); + cmock_call_instance = (CMOCK_vkCreatePipelineCache_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreatePipelineCache_CallInstance); + Mock.vkCreatePipelineCache_CallInstance = CMock_Guts_MemNext(Mock.vkCreatePipelineCache_CallInstance); + if (Mock.vkCreatePipelineCache_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreatePipelineCache_FinalReturn; + memcpy((void*)(&Mock.vkCreatePipelineCache_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreatePipelineCache_CallbackBool && + Mock.vkCreatePipelineCache_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreatePipelineCache_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pPipelineCache, Mock.vkCreatePipelineCache_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreatePipelineCache,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreatePipelineCache,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkPipelineCacheCreateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreatePipelineCache,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPipelineCache) + { + UNITY_SET_DETAILS(CMockString_vkCreatePipelineCache,CMockString_pPipelineCache); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pPipelineCache), (void*)(pPipelineCache), sizeof(VkPipelineCache), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreatePipelineCache_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreatePipelineCache_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pPipelineCache, Mock.vkCreatePipelineCache_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPipelineCache_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPipelineCache, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPipelineCache, (const void*)cmock_call_instance->ReturnThruPtr_pPipelineCache_Val, + cmock_call_instance->ReturnThruPtr_pPipelineCache_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreatePipelineCache(CMOCK_vkCreatePipelineCache_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache); +void CMockExpectParameters_vkCreatePipelineCache(CMOCK_vkCreatePipelineCache_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pPipelineCache = pPipelineCache; + cmock_call_instance->IgnoreArg_pPipelineCache = 0; + cmock_call_instance->ReturnThruPtr_pPipelineCache_Used = 0; +} + +void vkCreatePipelineCache_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreatePipelineCache_CALL_INSTANCE)); + CMOCK_vkCreatePipelineCache_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePipelineCache_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreatePipelineCache_CallInstance = CMock_Guts_MemChain(Mock.vkCreatePipelineCache_CallInstance, cmock_guts_index); + Mock.vkCreatePipelineCache_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreatePipelineCache_IgnoreBool = (char)1; +} + +void vkCreatePipelineCache_CMockStopIgnore(void) +{ + if(Mock.vkCreatePipelineCache_IgnoreBool) + Mock.vkCreatePipelineCache_CallInstance = CMock_Guts_MemNext(Mock.vkCreatePipelineCache_CallInstance); + Mock.vkCreatePipelineCache_IgnoreBool = (char)0; +} + +void vkCreatePipelineCache_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreatePipelineCache_CALL_INSTANCE)); + CMOCK_vkCreatePipelineCache_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePipelineCache_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreatePipelineCache_CallInstance = CMock_Guts_MemChain(Mock.vkCreatePipelineCache_CallInstance, cmock_guts_index); + Mock.vkCreatePipelineCache_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreatePipelineCache_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreatePipelineCache_CALL_INSTANCE)); + CMOCK_vkCreatePipelineCache_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePipelineCache_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreatePipelineCache_CallInstance = CMock_Guts_MemChain(Mock.vkCreatePipelineCache_CallInstance, cmock_guts_index); + Mock.vkCreatePipelineCache_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreatePipelineCache(cmock_call_instance, device, pCreateInfo, pAllocator, pPipelineCache); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreatePipelineCache_AddCallback(CMOCK_vkCreatePipelineCache_CALLBACK Callback) +{ + Mock.vkCreatePipelineCache_IgnoreBool = (char)0; + Mock.vkCreatePipelineCache_CallbackBool = (char)1; + Mock.vkCreatePipelineCache_CallbackFunctionPointer = Callback; +} + +void vkCreatePipelineCache_Stub(CMOCK_vkCreatePipelineCache_CALLBACK Callback) +{ + Mock.vkCreatePipelineCache_IgnoreBool = (char)0; + Mock.vkCreatePipelineCache_CallbackBool = (char)0; + Mock.vkCreatePipelineCache_CallbackFunctionPointer = Callback; +} + +void vkCreatePipelineCache_CMockReturnMemThruPtr_pPipelineCache(UNITY_LINE_TYPE cmock_line, VkPipelineCache const* pPipelineCache, size_t cmock_size) +{ + CMOCK_vkCreatePipelineCache_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePipelineCache_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreatePipelineCache_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPipelineCache_Used = 1; + cmock_call_instance->ReturnThruPtr_pPipelineCache_Val = pPipelineCache; + cmock_call_instance->ReturnThruPtr_pPipelineCache_Size = cmock_size; +} + +void vkCreatePipelineCache_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreatePipelineCache_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePipelineCache_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreatePipelineCache_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreatePipelineCache_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreatePipelineCache_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePipelineCache_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreatePipelineCache_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreatePipelineCache_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreatePipelineCache_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePipelineCache_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreatePipelineCache_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreatePipelineCache_CMockIgnoreArg_pPipelineCache(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreatePipelineCache_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePipelineCache_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreatePipelineCache_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPipelineCache = 1; +} + +void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyPipelineCache_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyPipelineCache); + cmock_call_instance = (CMOCK_vkDestroyPipelineCache_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyPipelineCache_CallInstance); + Mock.vkDestroyPipelineCache_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyPipelineCache_CallInstance); + if (Mock.vkDestroyPipelineCache_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyPipelineCache_CallbackBool && + Mock.vkDestroyPipelineCache_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyPipelineCache_CallbackFunctionPointer(device, pipelineCache, pAllocator, Mock.vkDestroyPipelineCache_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyPipelineCache,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pipelineCache) + { + UNITY_SET_DETAILS(CMockString_vkDestroyPipelineCache,CMockString_pipelineCache); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_pipelineCache), (void*)(&pipelineCache), sizeof(VkPipelineCache), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyPipelineCache,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyPipelineCache_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyPipelineCache_CallbackFunctionPointer(device, pipelineCache, pAllocator, Mock.vkDestroyPipelineCache_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyPipelineCache(CMOCK_vkDestroyPipelineCache_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyPipelineCache(CMOCK_vkDestroyPipelineCache_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_pipelineCache), (void*)(&pipelineCache), + sizeof(VkPipelineCache[sizeof(pipelineCache) == sizeof(VkPipelineCache) ? 1 : -1])); /* add VkPipelineCache to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_pipelineCache = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyPipelineCache_CMockIgnore(void) +{ + Mock.vkDestroyPipelineCache_IgnoreBool = (char)1; +} + +void vkDestroyPipelineCache_CMockStopIgnore(void) +{ + Mock.vkDestroyPipelineCache_IgnoreBool = (char)0; +} + +void vkDestroyPipelineCache_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyPipelineCache_CALL_INSTANCE)); + CMOCK_vkDestroyPipelineCache_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyPipelineCache_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyPipelineCache_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyPipelineCache_CallInstance, cmock_guts_index); + Mock.vkDestroyPipelineCache_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyPipelineCache_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyPipelineCache_CALL_INSTANCE)); + CMOCK_vkDestroyPipelineCache_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyPipelineCache_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyPipelineCache_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyPipelineCache_CallInstance, cmock_guts_index); + Mock.vkDestroyPipelineCache_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyPipelineCache(cmock_call_instance, device, pipelineCache, pAllocator); +} + +void vkDestroyPipelineCache_AddCallback(CMOCK_vkDestroyPipelineCache_CALLBACK Callback) +{ + Mock.vkDestroyPipelineCache_IgnoreBool = (char)0; + Mock.vkDestroyPipelineCache_CallbackBool = (char)1; + Mock.vkDestroyPipelineCache_CallbackFunctionPointer = Callback; +} + +void vkDestroyPipelineCache_Stub(CMOCK_vkDestroyPipelineCache_CALLBACK Callback) +{ + Mock.vkDestroyPipelineCache_IgnoreBool = (char)0; + Mock.vkDestroyPipelineCache_CallbackBool = (char)0; + Mock.vkDestroyPipelineCache_CallbackFunctionPointer = Callback; +} + +void vkDestroyPipelineCache_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyPipelineCache_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyPipelineCache_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyPipelineCache_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyPipelineCache_CMockIgnoreArg_pipelineCache(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyPipelineCache_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyPipelineCache_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyPipelineCache_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pipelineCache = 1; +} + +void vkDestroyPipelineCache_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyPipelineCache_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyPipelineCache_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyPipelineCache_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPipelineCacheData_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPipelineCacheData); + cmock_call_instance = (CMOCK_vkGetPipelineCacheData_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPipelineCacheData_CallInstance); + Mock.vkGetPipelineCacheData_CallInstance = CMock_Guts_MemNext(Mock.vkGetPipelineCacheData_CallInstance); + if (Mock.vkGetPipelineCacheData_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPipelineCacheData_FinalReturn; + memcpy((void*)(&Mock.vkGetPipelineCacheData_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPipelineCacheData_CallbackBool && + Mock.vkGetPipelineCacheData_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPipelineCacheData_CallbackFunctionPointer(device, pipelineCache, pDataSize, pData, Mock.vkGetPipelineCacheData_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetPipelineCacheData,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pipelineCache) + { + UNITY_SET_DETAILS(CMockString_vkGetPipelineCacheData,CMockString_pipelineCache); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_pipelineCache), (void*)(&pipelineCache), sizeof(VkPipelineCache), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDataSize) + { + UNITY_SET_DETAILS(CMockString_vkGetPipelineCacheData,CMockString_pDataSize); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDataSize), (void*)(pDataSize), sizeof(size_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pData) + { + UNITY_SET_DETAILS(CMockString_vkGetPipelineCacheData,CMockString_pData); + if (cmock_call_instance->Expected_pData == NULL) + { UNITY_TEST_ASSERT_NULL(pData, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(cmock_call_instance->Expected_pData, pData, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkGetPipelineCacheData_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPipelineCacheData_CallbackFunctionPointer(device, pipelineCache, pDataSize, pData, Mock.vkGetPipelineCacheData_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pDataSize_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pDataSize, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pDataSize, (const void*)cmock_call_instance->ReturnThruPtr_pDataSize_Val, + cmock_call_instance->ReturnThruPtr_pDataSize_Size); + } + if (cmock_call_instance->ReturnThruPtr_pData_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pData, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pData, (const void*)cmock_call_instance->ReturnThruPtr_pData_Val, + cmock_call_instance->ReturnThruPtr_pData_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPipelineCacheData(CMOCK_vkGetPipelineCacheData_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData); +void CMockExpectParameters_vkGetPipelineCacheData(CMOCK_vkGetPipelineCacheData_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_pipelineCache), (void*)(&pipelineCache), + sizeof(VkPipelineCache[sizeof(pipelineCache) == sizeof(VkPipelineCache) ? 1 : -1])); /* add VkPipelineCache to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_pipelineCache = 0; + cmock_call_instance->Expected_pDataSize = pDataSize; + cmock_call_instance->IgnoreArg_pDataSize = 0; + cmock_call_instance->ReturnThruPtr_pDataSize_Used = 0; + cmock_call_instance->Expected_pData = pData; + cmock_call_instance->IgnoreArg_pData = 0; + cmock_call_instance->ReturnThruPtr_pData_Used = 0; +} + +void vkGetPipelineCacheData_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPipelineCacheData_CALL_INSTANCE)); + CMOCK_vkGetPipelineCacheData_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineCacheData_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPipelineCacheData_CallInstance = CMock_Guts_MemChain(Mock.vkGetPipelineCacheData_CallInstance, cmock_guts_index); + Mock.vkGetPipelineCacheData_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPipelineCacheData_IgnoreBool = (char)1; +} + +void vkGetPipelineCacheData_CMockStopIgnore(void) +{ + if(Mock.vkGetPipelineCacheData_IgnoreBool) + Mock.vkGetPipelineCacheData_CallInstance = CMock_Guts_MemNext(Mock.vkGetPipelineCacheData_CallInstance); + Mock.vkGetPipelineCacheData_IgnoreBool = (char)0; +} + +void vkGetPipelineCacheData_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPipelineCacheData_CALL_INSTANCE)); + CMOCK_vkGetPipelineCacheData_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineCacheData_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPipelineCacheData_CallInstance = CMock_Guts_MemChain(Mock.vkGetPipelineCacheData_CallInstance, cmock_guts_index); + Mock.vkGetPipelineCacheData_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPipelineCacheData_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPipelineCacheData_CALL_INSTANCE)); + CMOCK_vkGetPipelineCacheData_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineCacheData_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPipelineCacheData_CallInstance = CMock_Guts_MemChain(Mock.vkGetPipelineCacheData_CallInstance, cmock_guts_index); + Mock.vkGetPipelineCacheData_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPipelineCacheData(cmock_call_instance, device, pipelineCache, pDataSize, pData); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPipelineCacheData_AddCallback(CMOCK_vkGetPipelineCacheData_CALLBACK Callback) +{ + Mock.vkGetPipelineCacheData_IgnoreBool = (char)0; + Mock.vkGetPipelineCacheData_CallbackBool = (char)1; + Mock.vkGetPipelineCacheData_CallbackFunctionPointer = Callback; +} + +void vkGetPipelineCacheData_Stub(CMOCK_vkGetPipelineCacheData_CALLBACK Callback) +{ + Mock.vkGetPipelineCacheData_IgnoreBool = (char)0; + Mock.vkGetPipelineCacheData_CallbackBool = (char)0; + Mock.vkGetPipelineCacheData_CallbackFunctionPointer = Callback; +} + +void vkGetPipelineCacheData_CMockReturnMemThruPtr_pDataSize(UNITY_LINE_TYPE cmock_line, size_t const* pDataSize, size_t cmock_size) +{ + CMOCK_vkGetPipelineCacheData_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineCacheData_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPipelineCacheData_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pDataSize_Used = 1; + cmock_call_instance->ReturnThruPtr_pDataSize_Val = pDataSize; + cmock_call_instance->ReturnThruPtr_pDataSize_Size = cmock_size; +} + +void vkGetPipelineCacheData_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, void const* pData, size_t cmock_size) +{ + CMOCK_vkGetPipelineCacheData_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineCacheData_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPipelineCacheData_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pData_Used = 1; + cmock_call_instance->ReturnThruPtr_pData_Val = pData; + cmock_call_instance->ReturnThruPtr_pData_Size = cmock_size; +} + +void vkGetPipelineCacheData_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPipelineCacheData_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineCacheData_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPipelineCacheData_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetPipelineCacheData_CMockIgnoreArg_pipelineCache(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPipelineCacheData_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineCacheData_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPipelineCacheData_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pipelineCache = 1; +} + +void vkGetPipelineCacheData_CMockIgnoreArg_pDataSize(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPipelineCacheData_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineCacheData_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPipelineCacheData_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDataSize = 1; +} + +void vkGetPipelineCacheData_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPipelineCacheData_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineCacheData_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPipelineCacheData_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pData = 1; +} + +VkResult vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkMergePipelineCaches_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkMergePipelineCaches); + cmock_call_instance = (CMOCK_vkMergePipelineCaches_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkMergePipelineCaches_CallInstance); + Mock.vkMergePipelineCaches_CallInstance = CMock_Guts_MemNext(Mock.vkMergePipelineCaches_CallInstance); + if (Mock.vkMergePipelineCaches_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkMergePipelineCaches_FinalReturn; + memcpy((void*)(&Mock.vkMergePipelineCaches_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkMergePipelineCaches_CallbackBool && + Mock.vkMergePipelineCaches_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkMergePipelineCaches_CallbackFunctionPointer(device, dstCache, srcCacheCount, pSrcCaches, Mock.vkMergePipelineCaches_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkMergePipelineCaches,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dstCache) + { + UNITY_SET_DETAILS(CMockString_vkMergePipelineCaches,CMockString_dstCache); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dstCache), (void*)(&dstCache), sizeof(VkPipelineCache), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_srcCacheCount) + { + UNITY_SET_DETAILS(CMockString_vkMergePipelineCaches,CMockString_srcCacheCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_srcCacheCount, srcCacheCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSrcCaches) + { + UNITY_SET_DETAILS(CMockString_vkMergePipelineCaches,CMockString_pSrcCaches); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSrcCaches), (void*)(pSrcCaches), sizeof(const VkPipelineCache), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkMergePipelineCaches_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkMergePipelineCaches_CallbackFunctionPointer(device, dstCache, srcCacheCount, pSrcCaches, Mock.vkMergePipelineCaches_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkMergePipelineCaches(CMOCK_vkMergePipelineCaches_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); +void CMockExpectParameters_vkMergePipelineCaches(CMOCK_vkMergePipelineCaches_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_dstCache), (void*)(&dstCache), + sizeof(VkPipelineCache[sizeof(dstCache) == sizeof(VkPipelineCache) ? 1 : -1])); /* add VkPipelineCache to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dstCache = 0; + cmock_call_instance->Expected_srcCacheCount = srcCacheCount; + cmock_call_instance->IgnoreArg_srcCacheCount = 0; + cmock_call_instance->Expected_pSrcCaches = pSrcCaches; + cmock_call_instance->IgnoreArg_pSrcCaches = 0; +} + +void vkMergePipelineCaches_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkMergePipelineCaches_CALL_INSTANCE)); + CMOCK_vkMergePipelineCaches_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMergePipelineCaches_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkMergePipelineCaches_CallInstance = CMock_Guts_MemChain(Mock.vkMergePipelineCaches_CallInstance, cmock_guts_index); + Mock.vkMergePipelineCaches_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkMergePipelineCaches_IgnoreBool = (char)1; +} + +void vkMergePipelineCaches_CMockStopIgnore(void) +{ + if(Mock.vkMergePipelineCaches_IgnoreBool) + Mock.vkMergePipelineCaches_CallInstance = CMock_Guts_MemNext(Mock.vkMergePipelineCaches_CallInstance); + Mock.vkMergePipelineCaches_IgnoreBool = (char)0; +} + +void vkMergePipelineCaches_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkMergePipelineCaches_CALL_INSTANCE)); + CMOCK_vkMergePipelineCaches_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMergePipelineCaches_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkMergePipelineCaches_CallInstance = CMock_Guts_MemChain(Mock.vkMergePipelineCaches_CallInstance, cmock_guts_index); + Mock.vkMergePipelineCaches_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkMergePipelineCaches_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkMergePipelineCaches_CALL_INSTANCE)); + CMOCK_vkMergePipelineCaches_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMergePipelineCaches_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkMergePipelineCaches_CallInstance = CMock_Guts_MemChain(Mock.vkMergePipelineCaches_CallInstance, cmock_guts_index); + Mock.vkMergePipelineCaches_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkMergePipelineCaches(cmock_call_instance, device, dstCache, srcCacheCount, pSrcCaches); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkMergePipelineCaches_AddCallback(CMOCK_vkMergePipelineCaches_CALLBACK Callback) +{ + Mock.vkMergePipelineCaches_IgnoreBool = (char)0; + Mock.vkMergePipelineCaches_CallbackBool = (char)1; + Mock.vkMergePipelineCaches_CallbackFunctionPointer = Callback; +} + +void vkMergePipelineCaches_Stub(CMOCK_vkMergePipelineCaches_CALLBACK Callback) +{ + Mock.vkMergePipelineCaches_IgnoreBool = (char)0; + Mock.vkMergePipelineCaches_CallbackBool = (char)0; + Mock.vkMergePipelineCaches_CallbackFunctionPointer = Callback; +} + +void vkMergePipelineCaches_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkMergePipelineCaches_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMergePipelineCaches_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkMergePipelineCaches_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkMergePipelineCaches_CMockIgnoreArg_dstCache(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkMergePipelineCaches_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMergePipelineCaches_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkMergePipelineCaches_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dstCache = 1; +} + +void vkMergePipelineCaches_CMockIgnoreArg_srcCacheCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkMergePipelineCaches_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMergePipelineCaches_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkMergePipelineCaches_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_srcCacheCount = 1; +} + +void vkMergePipelineCaches_CMockIgnoreArg_pSrcCaches(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkMergePipelineCaches_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMergePipelineCaches_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkMergePipelineCaches_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSrcCaches = 1; +} + +VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateGraphicsPipelines_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateGraphicsPipelines); + cmock_call_instance = (CMOCK_vkCreateGraphicsPipelines_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateGraphicsPipelines_CallInstance); + Mock.vkCreateGraphicsPipelines_CallInstance = CMock_Guts_MemNext(Mock.vkCreateGraphicsPipelines_CallInstance); + if (Mock.vkCreateGraphicsPipelines_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateGraphicsPipelines_FinalReturn; + memcpy((void*)(&Mock.vkCreateGraphicsPipelines_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateGraphicsPipelines_CallbackBool && + Mock.vkCreateGraphicsPipelines_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateGraphicsPipelines_CallbackFunctionPointer(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, Mock.vkCreateGraphicsPipelines_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateGraphicsPipelines,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pipelineCache) + { + UNITY_SET_DETAILS(CMockString_vkCreateGraphicsPipelines,CMockString_pipelineCache); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_pipelineCache), (void*)(&pipelineCache), sizeof(VkPipelineCache), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_createInfoCount) + { + UNITY_SET_DETAILS(CMockString_vkCreateGraphicsPipelines,CMockString_createInfoCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_createInfoCount, createInfoCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfos) + { + UNITY_SET_DETAILS(CMockString_vkCreateGraphicsPipelines,CMockString_pCreateInfos); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfos), (void*)(pCreateInfos), sizeof(const VkGraphicsPipelineCreateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateGraphicsPipelines,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPipelines) + { + UNITY_SET_DETAILS(CMockString_vkCreateGraphicsPipelines,CMockString_pPipelines); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pPipelines), (void*)(pPipelines), sizeof(VkPipeline), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateGraphicsPipelines_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateGraphicsPipelines_CallbackFunctionPointer(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, Mock.vkCreateGraphicsPipelines_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPipelines_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPipelines, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPipelines, (const void*)cmock_call_instance->ReturnThruPtr_pPipelines_Val, + cmock_call_instance->ReturnThruPtr_pPipelines_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateGraphicsPipelines(CMOCK_vkCreateGraphicsPipelines_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +void CMockExpectParameters_vkCreateGraphicsPipelines(CMOCK_vkCreateGraphicsPipelines_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_pipelineCache), (void*)(&pipelineCache), + sizeof(VkPipelineCache[sizeof(pipelineCache) == sizeof(VkPipelineCache) ? 1 : -1])); /* add VkPipelineCache to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_pipelineCache = 0; + cmock_call_instance->Expected_createInfoCount = createInfoCount; + cmock_call_instance->IgnoreArg_createInfoCount = 0; + cmock_call_instance->Expected_pCreateInfos = pCreateInfos; + cmock_call_instance->IgnoreArg_pCreateInfos = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pPipelines = pPipelines; + cmock_call_instance->IgnoreArg_pPipelines = 0; + cmock_call_instance->ReturnThruPtr_pPipelines_Used = 0; +} + +void vkCreateGraphicsPipelines_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateGraphicsPipelines_CALL_INSTANCE)); + CMOCK_vkCreateGraphicsPipelines_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateGraphicsPipelines_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateGraphicsPipelines_CallInstance = CMock_Guts_MemChain(Mock.vkCreateGraphicsPipelines_CallInstance, cmock_guts_index); + Mock.vkCreateGraphicsPipelines_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateGraphicsPipelines_IgnoreBool = (char)1; +} + +void vkCreateGraphicsPipelines_CMockStopIgnore(void) +{ + if(Mock.vkCreateGraphicsPipelines_IgnoreBool) + Mock.vkCreateGraphicsPipelines_CallInstance = CMock_Guts_MemNext(Mock.vkCreateGraphicsPipelines_CallInstance); + Mock.vkCreateGraphicsPipelines_IgnoreBool = (char)0; +} + +void vkCreateGraphicsPipelines_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateGraphicsPipelines_CALL_INSTANCE)); + CMOCK_vkCreateGraphicsPipelines_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateGraphicsPipelines_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateGraphicsPipelines_CallInstance = CMock_Guts_MemChain(Mock.vkCreateGraphicsPipelines_CallInstance, cmock_guts_index); + Mock.vkCreateGraphicsPipelines_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateGraphicsPipelines_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateGraphicsPipelines_CALL_INSTANCE)); + CMOCK_vkCreateGraphicsPipelines_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateGraphicsPipelines_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateGraphicsPipelines_CallInstance = CMock_Guts_MemChain(Mock.vkCreateGraphicsPipelines_CallInstance, cmock_guts_index); + Mock.vkCreateGraphicsPipelines_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateGraphicsPipelines(cmock_call_instance, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateGraphicsPipelines_AddCallback(CMOCK_vkCreateGraphicsPipelines_CALLBACK Callback) +{ + Mock.vkCreateGraphicsPipelines_IgnoreBool = (char)0; + Mock.vkCreateGraphicsPipelines_CallbackBool = (char)1; + Mock.vkCreateGraphicsPipelines_CallbackFunctionPointer = Callback; +} + +void vkCreateGraphicsPipelines_Stub(CMOCK_vkCreateGraphicsPipelines_CALLBACK Callback) +{ + Mock.vkCreateGraphicsPipelines_IgnoreBool = (char)0; + Mock.vkCreateGraphicsPipelines_CallbackBool = (char)0; + Mock.vkCreateGraphicsPipelines_CallbackFunctionPointer = Callback; +} + +void vkCreateGraphicsPipelines_CMockReturnMemThruPtr_pPipelines(UNITY_LINE_TYPE cmock_line, VkPipeline const* pPipelines, size_t cmock_size) +{ + CMOCK_vkCreateGraphicsPipelines_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateGraphicsPipelines_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateGraphicsPipelines_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPipelines_Used = 1; + cmock_call_instance->ReturnThruPtr_pPipelines_Val = pPipelines; + cmock_call_instance->ReturnThruPtr_pPipelines_Size = cmock_size; +} + +void vkCreateGraphicsPipelines_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateGraphicsPipelines_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateGraphicsPipelines_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateGraphicsPipelines_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateGraphicsPipelines_CMockIgnoreArg_pipelineCache(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateGraphicsPipelines_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateGraphicsPipelines_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateGraphicsPipelines_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pipelineCache = 1; +} + +void vkCreateGraphicsPipelines_CMockIgnoreArg_createInfoCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateGraphicsPipelines_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateGraphicsPipelines_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateGraphicsPipelines_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_createInfoCount = 1; +} + +void vkCreateGraphicsPipelines_CMockIgnoreArg_pCreateInfos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateGraphicsPipelines_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateGraphicsPipelines_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateGraphicsPipelines_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfos = 1; +} + +void vkCreateGraphicsPipelines_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateGraphicsPipelines_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateGraphicsPipelines_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateGraphicsPipelines_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateGraphicsPipelines_CMockIgnoreArg_pPipelines(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateGraphicsPipelines_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateGraphicsPipelines_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateGraphicsPipelines_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPipelines = 1; +} + +VkResult vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateComputePipelines_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateComputePipelines); + cmock_call_instance = (CMOCK_vkCreateComputePipelines_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateComputePipelines_CallInstance); + Mock.vkCreateComputePipelines_CallInstance = CMock_Guts_MemNext(Mock.vkCreateComputePipelines_CallInstance); + if (Mock.vkCreateComputePipelines_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateComputePipelines_FinalReturn; + memcpy((void*)(&Mock.vkCreateComputePipelines_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateComputePipelines_CallbackBool && + Mock.vkCreateComputePipelines_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateComputePipelines_CallbackFunctionPointer(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, Mock.vkCreateComputePipelines_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateComputePipelines,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pipelineCache) + { + UNITY_SET_DETAILS(CMockString_vkCreateComputePipelines,CMockString_pipelineCache); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_pipelineCache), (void*)(&pipelineCache), sizeof(VkPipelineCache), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_createInfoCount) + { + UNITY_SET_DETAILS(CMockString_vkCreateComputePipelines,CMockString_createInfoCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_createInfoCount, createInfoCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfos) + { + UNITY_SET_DETAILS(CMockString_vkCreateComputePipelines,CMockString_pCreateInfos); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfos), (void*)(pCreateInfos), sizeof(const VkComputePipelineCreateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateComputePipelines,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPipelines) + { + UNITY_SET_DETAILS(CMockString_vkCreateComputePipelines,CMockString_pPipelines); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pPipelines), (void*)(pPipelines), sizeof(VkPipeline), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateComputePipelines_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateComputePipelines_CallbackFunctionPointer(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, Mock.vkCreateComputePipelines_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPipelines_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPipelines, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPipelines, (const void*)cmock_call_instance->ReturnThruPtr_pPipelines_Val, + cmock_call_instance->ReturnThruPtr_pPipelines_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateComputePipelines(CMOCK_vkCreateComputePipelines_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +void CMockExpectParameters_vkCreateComputePipelines(CMOCK_vkCreateComputePipelines_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_pipelineCache), (void*)(&pipelineCache), + sizeof(VkPipelineCache[sizeof(pipelineCache) == sizeof(VkPipelineCache) ? 1 : -1])); /* add VkPipelineCache to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_pipelineCache = 0; + cmock_call_instance->Expected_createInfoCount = createInfoCount; + cmock_call_instance->IgnoreArg_createInfoCount = 0; + cmock_call_instance->Expected_pCreateInfos = pCreateInfos; + cmock_call_instance->IgnoreArg_pCreateInfos = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pPipelines = pPipelines; + cmock_call_instance->IgnoreArg_pPipelines = 0; + cmock_call_instance->ReturnThruPtr_pPipelines_Used = 0; +} + +void vkCreateComputePipelines_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateComputePipelines_CALL_INSTANCE)); + CMOCK_vkCreateComputePipelines_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateComputePipelines_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateComputePipelines_CallInstance = CMock_Guts_MemChain(Mock.vkCreateComputePipelines_CallInstance, cmock_guts_index); + Mock.vkCreateComputePipelines_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateComputePipelines_IgnoreBool = (char)1; +} + +void vkCreateComputePipelines_CMockStopIgnore(void) +{ + if(Mock.vkCreateComputePipelines_IgnoreBool) + Mock.vkCreateComputePipelines_CallInstance = CMock_Guts_MemNext(Mock.vkCreateComputePipelines_CallInstance); + Mock.vkCreateComputePipelines_IgnoreBool = (char)0; +} + +void vkCreateComputePipelines_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateComputePipelines_CALL_INSTANCE)); + CMOCK_vkCreateComputePipelines_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateComputePipelines_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateComputePipelines_CallInstance = CMock_Guts_MemChain(Mock.vkCreateComputePipelines_CallInstance, cmock_guts_index); + Mock.vkCreateComputePipelines_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateComputePipelines_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateComputePipelines_CALL_INSTANCE)); + CMOCK_vkCreateComputePipelines_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateComputePipelines_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateComputePipelines_CallInstance = CMock_Guts_MemChain(Mock.vkCreateComputePipelines_CallInstance, cmock_guts_index); + Mock.vkCreateComputePipelines_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateComputePipelines(cmock_call_instance, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateComputePipelines_AddCallback(CMOCK_vkCreateComputePipelines_CALLBACK Callback) +{ + Mock.vkCreateComputePipelines_IgnoreBool = (char)0; + Mock.vkCreateComputePipelines_CallbackBool = (char)1; + Mock.vkCreateComputePipelines_CallbackFunctionPointer = Callback; +} + +void vkCreateComputePipelines_Stub(CMOCK_vkCreateComputePipelines_CALLBACK Callback) +{ + Mock.vkCreateComputePipelines_IgnoreBool = (char)0; + Mock.vkCreateComputePipelines_CallbackBool = (char)0; + Mock.vkCreateComputePipelines_CallbackFunctionPointer = Callback; +} + +void vkCreateComputePipelines_CMockReturnMemThruPtr_pPipelines(UNITY_LINE_TYPE cmock_line, VkPipeline const* pPipelines, size_t cmock_size) +{ + CMOCK_vkCreateComputePipelines_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateComputePipelines_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateComputePipelines_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPipelines_Used = 1; + cmock_call_instance->ReturnThruPtr_pPipelines_Val = pPipelines; + cmock_call_instance->ReturnThruPtr_pPipelines_Size = cmock_size; +} + +void vkCreateComputePipelines_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateComputePipelines_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateComputePipelines_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateComputePipelines_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateComputePipelines_CMockIgnoreArg_pipelineCache(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateComputePipelines_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateComputePipelines_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateComputePipelines_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pipelineCache = 1; +} + +void vkCreateComputePipelines_CMockIgnoreArg_createInfoCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateComputePipelines_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateComputePipelines_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateComputePipelines_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_createInfoCount = 1; +} + +void vkCreateComputePipelines_CMockIgnoreArg_pCreateInfos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateComputePipelines_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateComputePipelines_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateComputePipelines_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfos = 1; +} + +void vkCreateComputePipelines_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateComputePipelines_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateComputePipelines_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateComputePipelines_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateComputePipelines_CMockIgnoreArg_pPipelines(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateComputePipelines_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateComputePipelines_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateComputePipelines_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPipelines = 1; +} + +void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyPipeline_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyPipeline); + cmock_call_instance = (CMOCK_vkDestroyPipeline_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyPipeline_CallInstance); + Mock.vkDestroyPipeline_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyPipeline_CallInstance); + if (Mock.vkDestroyPipeline_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyPipeline_CallbackBool && + Mock.vkDestroyPipeline_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyPipeline_CallbackFunctionPointer(device, pipeline, pAllocator, Mock.vkDestroyPipeline_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyPipeline,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pipeline) + { + UNITY_SET_DETAILS(CMockString_vkDestroyPipeline,CMockString_pipeline); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_pipeline), (void*)(&pipeline), sizeof(VkPipeline), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyPipeline,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyPipeline_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyPipeline_CallbackFunctionPointer(device, pipeline, pAllocator, Mock.vkDestroyPipeline_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyPipeline(CMOCK_vkDestroyPipeline_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyPipeline(CMOCK_vkDestroyPipeline_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_pipeline), (void*)(&pipeline), + sizeof(VkPipeline[sizeof(pipeline) == sizeof(VkPipeline) ? 1 : -1])); /* add VkPipeline to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_pipeline = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyPipeline_CMockIgnore(void) +{ + Mock.vkDestroyPipeline_IgnoreBool = (char)1; +} + +void vkDestroyPipeline_CMockStopIgnore(void) +{ + Mock.vkDestroyPipeline_IgnoreBool = (char)0; +} + +void vkDestroyPipeline_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyPipeline_CALL_INSTANCE)); + CMOCK_vkDestroyPipeline_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyPipeline_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyPipeline_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyPipeline_CallInstance, cmock_guts_index); + Mock.vkDestroyPipeline_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyPipeline_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyPipeline_CALL_INSTANCE)); + CMOCK_vkDestroyPipeline_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyPipeline_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyPipeline_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyPipeline_CallInstance, cmock_guts_index); + Mock.vkDestroyPipeline_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyPipeline(cmock_call_instance, device, pipeline, pAllocator); +} + +void vkDestroyPipeline_AddCallback(CMOCK_vkDestroyPipeline_CALLBACK Callback) +{ + Mock.vkDestroyPipeline_IgnoreBool = (char)0; + Mock.vkDestroyPipeline_CallbackBool = (char)1; + Mock.vkDestroyPipeline_CallbackFunctionPointer = Callback; +} + +void vkDestroyPipeline_Stub(CMOCK_vkDestroyPipeline_CALLBACK Callback) +{ + Mock.vkDestroyPipeline_IgnoreBool = (char)0; + Mock.vkDestroyPipeline_CallbackBool = (char)0; + Mock.vkDestroyPipeline_CallbackFunctionPointer = Callback; +} + +void vkDestroyPipeline_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyPipeline_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyPipeline_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyPipeline_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyPipeline_CMockIgnoreArg_pipeline(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyPipeline_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyPipeline_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyPipeline_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pipeline = 1; +} + +void vkDestroyPipeline_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyPipeline_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyPipeline_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyPipeline_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +VkResult vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreatePipelineLayout_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreatePipelineLayout); + cmock_call_instance = (CMOCK_vkCreatePipelineLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreatePipelineLayout_CallInstance); + Mock.vkCreatePipelineLayout_CallInstance = CMock_Guts_MemNext(Mock.vkCreatePipelineLayout_CallInstance); + if (Mock.vkCreatePipelineLayout_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreatePipelineLayout_FinalReturn; + memcpy((void*)(&Mock.vkCreatePipelineLayout_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreatePipelineLayout_CallbackBool && + Mock.vkCreatePipelineLayout_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreatePipelineLayout_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pPipelineLayout, Mock.vkCreatePipelineLayout_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreatePipelineLayout,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreatePipelineLayout,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkPipelineLayoutCreateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreatePipelineLayout,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPipelineLayout) + { + UNITY_SET_DETAILS(CMockString_vkCreatePipelineLayout,CMockString_pPipelineLayout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pPipelineLayout), (void*)(pPipelineLayout), sizeof(VkPipelineLayout), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreatePipelineLayout_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreatePipelineLayout_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pPipelineLayout, Mock.vkCreatePipelineLayout_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPipelineLayout_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPipelineLayout, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPipelineLayout, (const void*)cmock_call_instance->ReturnThruPtr_pPipelineLayout_Val, + cmock_call_instance->ReturnThruPtr_pPipelineLayout_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreatePipelineLayout(CMOCK_vkCreatePipelineLayout_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout); +void CMockExpectParameters_vkCreatePipelineLayout(CMOCK_vkCreatePipelineLayout_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pPipelineLayout = pPipelineLayout; + cmock_call_instance->IgnoreArg_pPipelineLayout = 0; + cmock_call_instance->ReturnThruPtr_pPipelineLayout_Used = 0; +} + +void vkCreatePipelineLayout_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreatePipelineLayout_CALL_INSTANCE)); + CMOCK_vkCreatePipelineLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePipelineLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreatePipelineLayout_CallInstance = CMock_Guts_MemChain(Mock.vkCreatePipelineLayout_CallInstance, cmock_guts_index); + Mock.vkCreatePipelineLayout_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreatePipelineLayout_IgnoreBool = (char)1; +} + +void vkCreatePipelineLayout_CMockStopIgnore(void) +{ + if(Mock.vkCreatePipelineLayout_IgnoreBool) + Mock.vkCreatePipelineLayout_CallInstance = CMock_Guts_MemNext(Mock.vkCreatePipelineLayout_CallInstance); + Mock.vkCreatePipelineLayout_IgnoreBool = (char)0; +} + +void vkCreatePipelineLayout_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreatePipelineLayout_CALL_INSTANCE)); + CMOCK_vkCreatePipelineLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePipelineLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreatePipelineLayout_CallInstance = CMock_Guts_MemChain(Mock.vkCreatePipelineLayout_CallInstance, cmock_guts_index); + Mock.vkCreatePipelineLayout_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreatePipelineLayout_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreatePipelineLayout_CALL_INSTANCE)); + CMOCK_vkCreatePipelineLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePipelineLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreatePipelineLayout_CallInstance = CMock_Guts_MemChain(Mock.vkCreatePipelineLayout_CallInstance, cmock_guts_index); + Mock.vkCreatePipelineLayout_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreatePipelineLayout(cmock_call_instance, device, pCreateInfo, pAllocator, pPipelineLayout); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreatePipelineLayout_AddCallback(CMOCK_vkCreatePipelineLayout_CALLBACK Callback) +{ + Mock.vkCreatePipelineLayout_IgnoreBool = (char)0; + Mock.vkCreatePipelineLayout_CallbackBool = (char)1; + Mock.vkCreatePipelineLayout_CallbackFunctionPointer = Callback; +} + +void vkCreatePipelineLayout_Stub(CMOCK_vkCreatePipelineLayout_CALLBACK Callback) +{ + Mock.vkCreatePipelineLayout_IgnoreBool = (char)0; + Mock.vkCreatePipelineLayout_CallbackBool = (char)0; + Mock.vkCreatePipelineLayout_CallbackFunctionPointer = Callback; +} + +void vkCreatePipelineLayout_CMockReturnMemThruPtr_pPipelineLayout(UNITY_LINE_TYPE cmock_line, VkPipelineLayout const* pPipelineLayout, size_t cmock_size) +{ + CMOCK_vkCreatePipelineLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePipelineLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreatePipelineLayout_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPipelineLayout_Used = 1; + cmock_call_instance->ReturnThruPtr_pPipelineLayout_Val = pPipelineLayout; + cmock_call_instance->ReturnThruPtr_pPipelineLayout_Size = cmock_size; +} + +void vkCreatePipelineLayout_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreatePipelineLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePipelineLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreatePipelineLayout_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreatePipelineLayout_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreatePipelineLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePipelineLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreatePipelineLayout_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreatePipelineLayout_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreatePipelineLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePipelineLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreatePipelineLayout_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreatePipelineLayout_CMockIgnoreArg_pPipelineLayout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreatePipelineLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePipelineLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreatePipelineLayout_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPipelineLayout = 1; +} + +void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyPipelineLayout_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyPipelineLayout); + cmock_call_instance = (CMOCK_vkDestroyPipelineLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyPipelineLayout_CallInstance); + Mock.vkDestroyPipelineLayout_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyPipelineLayout_CallInstance); + if (Mock.vkDestroyPipelineLayout_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyPipelineLayout_CallbackBool && + Mock.vkDestroyPipelineLayout_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyPipelineLayout_CallbackFunctionPointer(device, pipelineLayout, pAllocator, Mock.vkDestroyPipelineLayout_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyPipelineLayout,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pipelineLayout) + { + UNITY_SET_DETAILS(CMockString_vkDestroyPipelineLayout,CMockString_pipelineLayout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_pipelineLayout), (void*)(&pipelineLayout), sizeof(VkPipelineLayout), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyPipelineLayout,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyPipelineLayout_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyPipelineLayout_CallbackFunctionPointer(device, pipelineLayout, pAllocator, Mock.vkDestroyPipelineLayout_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyPipelineLayout(CMOCK_vkDestroyPipelineLayout_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyPipelineLayout(CMOCK_vkDestroyPipelineLayout_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_pipelineLayout), (void*)(&pipelineLayout), + sizeof(VkPipelineLayout[sizeof(pipelineLayout) == sizeof(VkPipelineLayout) ? 1 : -1])); /* add VkPipelineLayout to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_pipelineLayout = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyPipelineLayout_CMockIgnore(void) +{ + Mock.vkDestroyPipelineLayout_IgnoreBool = (char)1; +} + +void vkDestroyPipelineLayout_CMockStopIgnore(void) +{ + Mock.vkDestroyPipelineLayout_IgnoreBool = (char)0; +} + +void vkDestroyPipelineLayout_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyPipelineLayout_CALL_INSTANCE)); + CMOCK_vkDestroyPipelineLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyPipelineLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyPipelineLayout_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyPipelineLayout_CallInstance, cmock_guts_index); + Mock.vkDestroyPipelineLayout_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyPipelineLayout_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyPipelineLayout_CALL_INSTANCE)); + CMOCK_vkDestroyPipelineLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyPipelineLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyPipelineLayout_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyPipelineLayout_CallInstance, cmock_guts_index); + Mock.vkDestroyPipelineLayout_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyPipelineLayout(cmock_call_instance, device, pipelineLayout, pAllocator); +} + +void vkDestroyPipelineLayout_AddCallback(CMOCK_vkDestroyPipelineLayout_CALLBACK Callback) +{ + Mock.vkDestroyPipelineLayout_IgnoreBool = (char)0; + Mock.vkDestroyPipelineLayout_CallbackBool = (char)1; + Mock.vkDestroyPipelineLayout_CallbackFunctionPointer = Callback; +} + +void vkDestroyPipelineLayout_Stub(CMOCK_vkDestroyPipelineLayout_CALLBACK Callback) +{ + Mock.vkDestroyPipelineLayout_IgnoreBool = (char)0; + Mock.vkDestroyPipelineLayout_CallbackBool = (char)0; + Mock.vkDestroyPipelineLayout_CallbackFunctionPointer = Callback; +} + +void vkDestroyPipelineLayout_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyPipelineLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyPipelineLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyPipelineLayout_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyPipelineLayout_CMockIgnoreArg_pipelineLayout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyPipelineLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyPipelineLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyPipelineLayout_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pipelineLayout = 1; +} + +void vkDestroyPipelineLayout_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyPipelineLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyPipelineLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyPipelineLayout_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +VkResult vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateSampler_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateSampler); + cmock_call_instance = (CMOCK_vkCreateSampler_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateSampler_CallInstance); + Mock.vkCreateSampler_CallInstance = CMock_Guts_MemNext(Mock.vkCreateSampler_CallInstance); + if (Mock.vkCreateSampler_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateSampler_FinalReturn; + memcpy((void*)(&Mock.vkCreateSampler_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateSampler_CallbackBool && + Mock.vkCreateSampler_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateSampler_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pSampler, Mock.vkCreateSampler_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateSampler,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateSampler,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkSamplerCreateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateSampler,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSampler) + { + UNITY_SET_DETAILS(CMockString_vkCreateSampler,CMockString_pSampler); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSampler), (void*)(pSampler), sizeof(VkSampler), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateSampler_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateSampler_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pSampler, Mock.vkCreateSampler_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pSampler_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSampler, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSampler, (const void*)cmock_call_instance->ReturnThruPtr_pSampler_Val, + cmock_call_instance->ReturnThruPtr_pSampler_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateSampler(CMOCK_vkCreateSampler_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler); +void CMockExpectParameters_vkCreateSampler(CMOCK_vkCreateSampler_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pSampler = pSampler; + cmock_call_instance->IgnoreArg_pSampler = 0; + cmock_call_instance->ReturnThruPtr_pSampler_Used = 0; +} + +void vkCreateSampler_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateSampler_CALL_INSTANCE)); + CMOCK_vkCreateSampler_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSampler_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateSampler_CallInstance = CMock_Guts_MemChain(Mock.vkCreateSampler_CallInstance, cmock_guts_index); + Mock.vkCreateSampler_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateSampler_IgnoreBool = (char)1; +} + +void vkCreateSampler_CMockStopIgnore(void) +{ + if(Mock.vkCreateSampler_IgnoreBool) + Mock.vkCreateSampler_CallInstance = CMock_Guts_MemNext(Mock.vkCreateSampler_CallInstance); + Mock.vkCreateSampler_IgnoreBool = (char)0; +} + +void vkCreateSampler_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateSampler_CALL_INSTANCE)); + CMOCK_vkCreateSampler_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSampler_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateSampler_CallInstance = CMock_Guts_MemChain(Mock.vkCreateSampler_CallInstance, cmock_guts_index); + Mock.vkCreateSampler_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateSampler_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateSampler_CALL_INSTANCE)); + CMOCK_vkCreateSampler_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSampler_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateSampler_CallInstance = CMock_Guts_MemChain(Mock.vkCreateSampler_CallInstance, cmock_guts_index); + Mock.vkCreateSampler_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateSampler(cmock_call_instance, device, pCreateInfo, pAllocator, pSampler); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateSampler_AddCallback(CMOCK_vkCreateSampler_CALLBACK Callback) +{ + Mock.vkCreateSampler_IgnoreBool = (char)0; + Mock.vkCreateSampler_CallbackBool = (char)1; + Mock.vkCreateSampler_CallbackFunctionPointer = Callback; +} + +void vkCreateSampler_Stub(CMOCK_vkCreateSampler_CALLBACK Callback) +{ + Mock.vkCreateSampler_IgnoreBool = (char)0; + Mock.vkCreateSampler_CallbackBool = (char)0; + Mock.vkCreateSampler_CallbackFunctionPointer = Callback; +} + +void vkCreateSampler_CMockReturnMemThruPtr_pSampler(UNITY_LINE_TYPE cmock_line, VkSampler const* pSampler, size_t cmock_size) +{ + CMOCK_vkCreateSampler_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSampler_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSampler_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSampler_Used = 1; + cmock_call_instance->ReturnThruPtr_pSampler_Val = pSampler; + cmock_call_instance->ReturnThruPtr_pSampler_Size = cmock_size; +} + +void vkCreateSampler_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateSampler_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSampler_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSampler_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateSampler_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateSampler_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSampler_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSampler_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateSampler_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateSampler_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSampler_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSampler_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateSampler_CMockIgnoreArg_pSampler(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateSampler_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSampler_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSampler_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSampler = 1; +} + +void vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroySampler_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroySampler); + cmock_call_instance = (CMOCK_vkDestroySampler_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroySampler_CallInstance); + Mock.vkDestroySampler_CallInstance = CMock_Guts_MemNext(Mock.vkDestroySampler_CallInstance); + if (Mock.vkDestroySampler_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroySampler_CallbackBool && + Mock.vkDestroySampler_CallbackFunctionPointer != NULL) + { + Mock.vkDestroySampler_CallbackFunctionPointer(device, sampler, pAllocator, Mock.vkDestroySampler_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroySampler,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_sampler) + { + UNITY_SET_DETAILS(CMockString_vkDestroySampler,CMockString_sampler); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_sampler), (void*)(&sampler), sizeof(VkSampler), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroySampler,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroySampler_CallbackFunctionPointer != NULL) + { + Mock.vkDestroySampler_CallbackFunctionPointer(device, sampler, pAllocator, Mock.vkDestroySampler_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroySampler(CMOCK_vkDestroySampler_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroySampler(CMOCK_vkDestroySampler_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_sampler), (void*)(&sampler), + sizeof(VkSampler[sizeof(sampler) == sizeof(VkSampler) ? 1 : -1])); /* add VkSampler to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_sampler = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroySampler_CMockIgnore(void) +{ + Mock.vkDestroySampler_IgnoreBool = (char)1; +} + +void vkDestroySampler_CMockStopIgnore(void) +{ + Mock.vkDestroySampler_IgnoreBool = (char)0; +} + +void vkDestroySampler_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroySampler_CALL_INSTANCE)); + CMOCK_vkDestroySampler_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroySampler_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroySampler_CallInstance = CMock_Guts_MemChain(Mock.vkDestroySampler_CallInstance, cmock_guts_index); + Mock.vkDestroySampler_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroySampler_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroySampler_CALL_INSTANCE)); + CMOCK_vkDestroySampler_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroySampler_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroySampler_CallInstance = CMock_Guts_MemChain(Mock.vkDestroySampler_CallInstance, cmock_guts_index); + Mock.vkDestroySampler_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroySampler(cmock_call_instance, device, sampler, pAllocator); +} + +void vkDestroySampler_AddCallback(CMOCK_vkDestroySampler_CALLBACK Callback) +{ + Mock.vkDestroySampler_IgnoreBool = (char)0; + Mock.vkDestroySampler_CallbackBool = (char)1; + Mock.vkDestroySampler_CallbackFunctionPointer = Callback; +} + +void vkDestroySampler_Stub(CMOCK_vkDestroySampler_CALLBACK Callback) +{ + Mock.vkDestroySampler_IgnoreBool = (char)0; + Mock.vkDestroySampler_CallbackBool = (char)0; + Mock.vkDestroySampler_CallbackFunctionPointer = Callback; +} + +void vkDestroySampler_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroySampler_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroySampler_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroySampler_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroySampler_CMockIgnoreArg_sampler(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroySampler_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroySampler_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroySampler_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_sampler = 1; +} + +void vkDestroySampler_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroySampler_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroySampler_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroySampler_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +VkResult vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateDescriptorSetLayout_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateDescriptorSetLayout); + cmock_call_instance = (CMOCK_vkCreateDescriptorSetLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateDescriptorSetLayout_CallInstance); + Mock.vkCreateDescriptorSetLayout_CallInstance = CMock_Guts_MemNext(Mock.vkCreateDescriptorSetLayout_CallInstance); + if (Mock.vkCreateDescriptorSetLayout_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateDescriptorSetLayout_FinalReturn; + memcpy((void*)(&Mock.vkCreateDescriptorSetLayout_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateDescriptorSetLayout_CallbackBool && + Mock.vkCreateDescriptorSetLayout_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateDescriptorSetLayout_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pSetLayout, Mock.vkCreateDescriptorSetLayout_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateDescriptorSetLayout,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateDescriptorSetLayout,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkDescriptorSetLayoutCreateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateDescriptorSetLayout,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSetLayout) + { + UNITY_SET_DETAILS(CMockString_vkCreateDescriptorSetLayout,CMockString_pSetLayout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSetLayout), (void*)(pSetLayout), sizeof(VkDescriptorSetLayout), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateDescriptorSetLayout_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateDescriptorSetLayout_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pSetLayout, Mock.vkCreateDescriptorSetLayout_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pSetLayout_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSetLayout, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSetLayout, (const void*)cmock_call_instance->ReturnThruPtr_pSetLayout_Val, + cmock_call_instance->ReturnThruPtr_pSetLayout_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateDescriptorSetLayout(CMOCK_vkCreateDescriptorSetLayout_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout); +void CMockExpectParameters_vkCreateDescriptorSetLayout(CMOCK_vkCreateDescriptorSetLayout_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pSetLayout = pSetLayout; + cmock_call_instance->IgnoreArg_pSetLayout = 0; + cmock_call_instance->ReturnThruPtr_pSetLayout_Used = 0; +} + +void vkCreateDescriptorSetLayout_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateDescriptorSetLayout_CALL_INSTANCE)); + CMOCK_vkCreateDescriptorSetLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorSetLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateDescriptorSetLayout_CallInstance = CMock_Guts_MemChain(Mock.vkCreateDescriptorSetLayout_CallInstance, cmock_guts_index); + Mock.vkCreateDescriptorSetLayout_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateDescriptorSetLayout_IgnoreBool = (char)1; +} + +void vkCreateDescriptorSetLayout_CMockStopIgnore(void) +{ + if(Mock.vkCreateDescriptorSetLayout_IgnoreBool) + Mock.vkCreateDescriptorSetLayout_CallInstance = CMock_Guts_MemNext(Mock.vkCreateDescriptorSetLayout_CallInstance); + Mock.vkCreateDescriptorSetLayout_IgnoreBool = (char)0; +} + +void vkCreateDescriptorSetLayout_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateDescriptorSetLayout_CALL_INSTANCE)); + CMOCK_vkCreateDescriptorSetLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorSetLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateDescriptorSetLayout_CallInstance = CMock_Guts_MemChain(Mock.vkCreateDescriptorSetLayout_CallInstance, cmock_guts_index); + Mock.vkCreateDescriptorSetLayout_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateDescriptorSetLayout_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateDescriptorSetLayout_CALL_INSTANCE)); + CMOCK_vkCreateDescriptorSetLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorSetLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateDescriptorSetLayout_CallInstance = CMock_Guts_MemChain(Mock.vkCreateDescriptorSetLayout_CallInstance, cmock_guts_index); + Mock.vkCreateDescriptorSetLayout_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateDescriptorSetLayout(cmock_call_instance, device, pCreateInfo, pAllocator, pSetLayout); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateDescriptorSetLayout_AddCallback(CMOCK_vkCreateDescriptorSetLayout_CALLBACK Callback) +{ + Mock.vkCreateDescriptorSetLayout_IgnoreBool = (char)0; + Mock.vkCreateDescriptorSetLayout_CallbackBool = (char)1; + Mock.vkCreateDescriptorSetLayout_CallbackFunctionPointer = Callback; +} + +void vkCreateDescriptorSetLayout_Stub(CMOCK_vkCreateDescriptorSetLayout_CALLBACK Callback) +{ + Mock.vkCreateDescriptorSetLayout_IgnoreBool = (char)0; + Mock.vkCreateDescriptorSetLayout_CallbackBool = (char)0; + Mock.vkCreateDescriptorSetLayout_CallbackFunctionPointer = Callback; +} + +void vkCreateDescriptorSetLayout_CMockReturnMemThruPtr_pSetLayout(UNITY_LINE_TYPE cmock_line, VkDescriptorSetLayout const* pSetLayout, size_t cmock_size) +{ + CMOCK_vkCreateDescriptorSetLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorSetLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDescriptorSetLayout_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSetLayout_Used = 1; + cmock_call_instance->ReturnThruPtr_pSetLayout_Val = pSetLayout; + cmock_call_instance->ReturnThruPtr_pSetLayout_Size = cmock_size; +} + +void vkCreateDescriptorSetLayout_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDescriptorSetLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorSetLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDescriptorSetLayout_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateDescriptorSetLayout_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDescriptorSetLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorSetLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDescriptorSetLayout_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateDescriptorSetLayout_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDescriptorSetLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorSetLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDescriptorSetLayout_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateDescriptorSetLayout_CMockIgnoreArg_pSetLayout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDescriptorSetLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorSetLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDescriptorSetLayout_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSetLayout = 1; +} + +void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyDescriptorSetLayout_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyDescriptorSetLayout); + cmock_call_instance = (CMOCK_vkDestroyDescriptorSetLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyDescriptorSetLayout_CallInstance); + Mock.vkDestroyDescriptorSetLayout_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyDescriptorSetLayout_CallInstance); + if (Mock.vkDestroyDescriptorSetLayout_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyDescriptorSetLayout_CallbackBool && + Mock.vkDestroyDescriptorSetLayout_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyDescriptorSetLayout_CallbackFunctionPointer(device, descriptorSetLayout, pAllocator, Mock.vkDestroyDescriptorSetLayout_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyDescriptorSetLayout,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_descriptorSetLayout) + { + UNITY_SET_DETAILS(CMockString_vkDestroyDescriptorSetLayout,CMockString_descriptorSetLayout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_descriptorSetLayout), (void*)(&descriptorSetLayout), sizeof(VkDescriptorSetLayout), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyDescriptorSetLayout,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyDescriptorSetLayout_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyDescriptorSetLayout_CallbackFunctionPointer(device, descriptorSetLayout, pAllocator, Mock.vkDestroyDescriptorSetLayout_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyDescriptorSetLayout(CMOCK_vkDestroyDescriptorSetLayout_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyDescriptorSetLayout(CMOCK_vkDestroyDescriptorSetLayout_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_descriptorSetLayout), (void*)(&descriptorSetLayout), + sizeof(VkDescriptorSetLayout[sizeof(descriptorSetLayout) == sizeof(VkDescriptorSetLayout) ? 1 : -1])); /* add VkDescriptorSetLayout to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_descriptorSetLayout = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyDescriptorSetLayout_CMockIgnore(void) +{ + Mock.vkDestroyDescriptorSetLayout_IgnoreBool = (char)1; +} + +void vkDestroyDescriptorSetLayout_CMockStopIgnore(void) +{ + Mock.vkDestroyDescriptorSetLayout_IgnoreBool = (char)0; +} + +void vkDestroyDescriptorSetLayout_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyDescriptorSetLayout_CALL_INSTANCE)); + CMOCK_vkDestroyDescriptorSetLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDescriptorSetLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyDescriptorSetLayout_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyDescriptorSetLayout_CallInstance, cmock_guts_index); + Mock.vkDestroyDescriptorSetLayout_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyDescriptorSetLayout_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyDescriptorSetLayout_CALL_INSTANCE)); + CMOCK_vkDestroyDescriptorSetLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDescriptorSetLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyDescriptorSetLayout_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyDescriptorSetLayout_CallInstance, cmock_guts_index); + Mock.vkDestroyDescriptorSetLayout_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyDescriptorSetLayout(cmock_call_instance, device, descriptorSetLayout, pAllocator); +} + +void vkDestroyDescriptorSetLayout_AddCallback(CMOCK_vkDestroyDescriptorSetLayout_CALLBACK Callback) +{ + Mock.vkDestroyDescriptorSetLayout_IgnoreBool = (char)0; + Mock.vkDestroyDescriptorSetLayout_CallbackBool = (char)1; + Mock.vkDestroyDescriptorSetLayout_CallbackFunctionPointer = Callback; +} + +void vkDestroyDescriptorSetLayout_Stub(CMOCK_vkDestroyDescriptorSetLayout_CALLBACK Callback) +{ + Mock.vkDestroyDescriptorSetLayout_IgnoreBool = (char)0; + Mock.vkDestroyDescriptorSetLayout_CallbackBool = (char)0; + Mock.vkDestroyDescriptorSetLayout_CallbackFunctionPointer = Callback; +} + +void vkDestroyDescriptorSetLayout_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyDescriptorSetLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDescriptorSetLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyDescriptorSetLayout_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyDescriptorSetLayout_CMockIgnoreArg_descriptorSetLayout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyDescriptorSetLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDescriptorSetLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyDescriptorSetLayout_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_descriptorSetLayout = 1; +} + +void vkDestroyDescriptorSetLayout_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyDescriptorSetLayout_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDescriptorSetLayout_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyDescriptorSetLayout_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +VkResult vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateDescriptorPool_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateDescriptorPool); + cmock_call_instance = (CMOCK_vkCreateDescriptorPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateDescriptorPool_CallInstance); + Mock.vkCreateDescriptorPool_CallInstance = CMock_Guts_MemNext(Mock.vkCreateDescriptorPool_CallInstance); + if (Mock.vkCreateDescriptorPool_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateDescriptorPool_FinalReturn; + memcpy((void*)(&Mock.vkCreateDescriptorPool_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateDescriptorPool_CallbackBool && + Mock.vkCreateDescriptorPool_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateDescriptorPool_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pDescriptorPool, Mock.vkCreateDescriptorPool_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateDescriptorPool,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateDescriptorPool,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkDescriptorPoolCreateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateDescriptorPool,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDescriptorPool) + { + UNITY_SET_DETAILS(CMockString_vkCreateDescriptorPool,CMockString_pDescriptorPool); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDescriptorPool), (void*)(pDescriptorPool), sizeof(VkDescriptorPool), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateDescriptorPool_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateDescriptorPool_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pDescriptorPool, Mock.vkCreateDescriptorPool_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pDescriptorPool_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pDescriptorPool, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pDescriptorPool, (const void*)cmock_call_instance->ReturnThruPtr_pDescriptorPool_Val, + cmock_call_instance->ReturnThruPtr_pDescriptorPool_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateDescriptorPool(CMOCK_vkCreateDescriptorPool_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool); +void CMockExpectParameters_vkCreateDescriptorPool(CMOCK_vkCreateDescriptorPool_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pDescriptorPool = pDescriptorPool; + cmock_call_instance->IgnoreArg_pDescriptorPool = 0; + cmock_call_instance->ReturnThruPtr_pDescriptorPool_Used = 0; +} + +void vkCreateDescriptorPool_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateDescriptorPool_CALL_INSTANCE)); + CMOCK_vkCreateDescriptorPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateDescriptorPool_CallInstance = CMock_Guts_MemChain(Mock.vkCreateDescriptorPool_CallInstance, cmock_guts_index); + Mock.vkCreateDescriptorPool_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateDescriptorPool_IgnoreBool = (char)1; +} + +void vkCreateDescriptorPool_CMockStopIgnore(void) +{ + if(Mock.vkCreateDescriptorPool_IgnoreBool) + Mock.vkCreateDescriptorPool_CallInstance = CMock_Guts_MemNext(Mock.vkCreateDescriptorPool_CallInstance); + Mock.vkCreateDescriptorPool_IgnoreBool = (char)0; +} + +void vkCreateDescriptorPool_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateDescriptorPool_CALL_INSTANCE)); + CMOCK_vkCreateDescriptorPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateDescriptorPool_CallInstance = CMock_Guts_MemChain(Mock.vkCreateDescriptorPool_CallInstance, cmock_guts_index); + Mock.vkCreateDescriptorPool_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateDescriptorPool_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateDescriptorPool_CALL_INSTANCE)); + CMOCK_vkCreateDescriptorPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateDescriptorPool_CallInstance = CMock_Guts_MemChain(Mock.vkCreateDescriptorPool_CallInstance, cmock_guts_index); + Mock.vkCreateDescriptorPool_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateDescriptorPool(cmock_call_instance, device, pCreateInfo, pAllocator, pDescriptorPool); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateDescriptorPool_AddCallback(CMOCK_vkCreateDescriptorPool_CALLBACK Callback) +{ + Mock.vkCreateDescriptorPool_IgnoreBool = (char)0; + Mock.vkCreateDescriptorPool_CallbackBool = (char)1; + Mock.vkCreateDescriptorPool_CallbackFunctionPointer = Callback; +} + +void vkCreateDescriptorPool_Stub(CMOCK_vkCreateDescriptorPool_CALLBACK Callback) +{ + Mock.vkCreateDescriptorPool_IgnoreBool = (char)0; + Mock.vkCreateDescriptorPool_CallbackBool = (char)0; + Mock.vkCreateDescriptorPool_CallbackFunctionPointer = Callback; +} + +void vkCreateDescriptorPool_CMockReturnMemThruPtr_pDescriptorPool(UNITY_LINE_TYPE cmock_line, VkDescriptorPool const* pDescriptorPool, size_t cmock_size) +{ + CMOCK_vkCreateDescriptorPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDescriptorPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pDescriptorPool_Used = 1; + cmock_call_instance->ReturnThruPtr_pDescriptorPool_Val = pDescriptorPool; + cmock_call_instance->ReturnThruPtr_pDescriptorPool_Size = cmock_size; +} + +void vkCreateDescriptorPool_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDescriptorPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDescriptorPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateDescriptorPool_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDescriptorPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDescriptorPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateDescriptorPool_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDescriptorPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDescriptorPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateDescriptorPool_CMockIgnoreArg_pDescriptorPool(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDescriptorPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDescriptorPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDescriptorPool = 1; +} + +void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyDescriptorPool_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyDescriptorPool); + cmock_call_instance = (CMOCK_vkDestroyDescriptorPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyDescriptorPool_CallInstance); + Mock.vkDestroyDescriptorPool_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyDescriptorPool_CallInstance); + if (Mock.vkDestroyDescriptorPool_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyDescriptorPool_CallbackBool && + Mock.vkDestroyDescriptorPool_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyDescriptorPool_CallbackFunctionPointer(device, descriptorPool, pAllocator, Mock.vkDestroyDescriptorPool_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyDescriptorPool,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_descriptorPool) + { + UNITY_SET_DETAILS(CMockString_vkDestroyDescriptorPool,CMockString_descriptorPool); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_descriptorPool), (void*)(&descriptorPool), sizeof(VkDescriptorPool), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyDescriptorPool,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyDescriptorPool_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyDescriptorPool_CallbackFunctionPointer(device, descriptorPool, pAllocator, Mock.vkDestroyDescriptorPool_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyDescriptorPool(CMOCK_vkDestroyDescriptorPool_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyDescriptorPool(CMOCK_vkDestroyDescriptorPool_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_descriptorPool), (void*)(&descriptorPool), + sizeof(VkDescriptorPool[sizeof(descriptorPool) == sizeof(VkDescriptorPool) ? 1 : -1])); /* add VkDescriptorPool to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_descriptorPool = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyDescriptorPool_CMockIgnore(void) +{ + Mock.vkDestroyDescriptorPool_IgnoreBool = (char)1; +} + +void vkDestroyDescriptorPool_CMockStopIgnore(void) +{ + Mock.vkDestroyDescriptorPool_IgnoreBool = (char)0; +} + +void vkDestroyDescriptorPool_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyDescriptorPool_CALL_INSTANCE)); + CMOCK_vkDestroyDescriptorPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDescriptorPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyDescriptorPool_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyDescriptorPool_CallInstance, cmock_guts_index); + Mock.vkDestroyDescriptorPool_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyDescriptorPool_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyDescriptorPool_CALL_INSTANCE)); + CMOCK_vkDestroyDescriptorPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDescriptorPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyDescriptorPool_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyDescriptorPool_CallInstance, cmock_guts_index); + Mock.vkDestroyDescriptorPool_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyDescriptorPool(cmock_call_instance, device, descriptorPool, pAllocator); +} + +void vkDestroyDescriptorPool_AddCallback(CMOCK_vkDestroyDescriptorPool_CALLBACK Callback) +{ + Mock.vkDestroyDescriptorPool_IgnoreBool = (char)0; + Mock.vkDestroyDescriptorPool_CallbackBool = (char)1; + Mock.vkDestroyDescriptorPool_CallbackFunctionPointer = Callback; +} + +void vkDestroyDescriptorPool_Stub(CMOCK_vkDestroyDescriptorPool_CALLBACK Callback) +{ + Mock.vkDestroyDescriptorPool_IgnoreBool = (char)0; + Mock.vkDestroyDescriptorPool_CallbackBool = (char)0; + Mock.vkDestroyDescriptorPool_CallbackFunctionPointer = Callback; +} + +void vkDestroyDescriptorPool_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyDescriptorPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDescriptorPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyDescriptorPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyDescriptorPool_CMockIgnoreArg_descriptorPool(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyDescriptorPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDescriptorPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyDescriptorPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_descriptorPool = 1; +} + +void vkDestroyDescriptorPool_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyDescriptorPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDescriptorPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyDescriptorPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +VkResult vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkResetDescriptorPool_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkResetDescriptorPool); + cmock_call_instance = (CMOCK_vkResetDescriptorPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkResetDescriptorPool_CallInstance); + Mock.vkResetDescriptorPool_CallInstance = CMock_Guts_MemNext(Mock.vkResetDescriptorPool_CallInstance); + if (Mock.vkResetDescriptorPool_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkResetDescriptorPool_FinalReturn; + memcpy((void*)(&Mock.vkResetDescriptorPool_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkResetDescriptorPool_CallbackBool && + Mock.vkResetDescriptorPool_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkResetDescriptorPool_CallbackFunctionPointer(device, descriptorPool, flags, Mock.vkResetDescriptorPool_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkResetDescriptorPool,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_descriptorPool) + { + UNITY_SET_DETAILS(CMockString_vkResetDescriptorPool,CMockString_descriptorPool); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_descriptorPool), (void*)(&descriptorPool), sizeof(VkDescriptorPool), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_flags) + { + UNITY_SET_DETAILS(CMockString_vkResetDescriptorPool,CMockString_flags); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_flags), (void*)(&flags), sizeof(VkDescriptorPoolResetFlags), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkResetDescriptorPool_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkResetDescriptorPool_CallbackFunctionPointer(device, descriptorPool, flags, Mock.vkResetDescriptorPool_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkResetDescriptorPool(CMOCK_vkResetDescriptorPool_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags); +void CMockExpectParameters_vkResetDescriptorPool(CMOCK_vkResetDescriptorPool_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_descriptorPool), (void*)(&descriptorPool), + sizeof(VkDescriptorPool[sizeof(descriptorPool) == sizeof(VkDescriptorPool) ? 1 : -1])); /* add VkDescriptorPool to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_descriptorPool = 0; + memcpy((void*)(&cmock_call_instance->Expected_flags), (void*)(&flags), + sizeof(VkDescriptorPoolResetFlags[sizeof(flags) == sizeof(VkDescriptorPoolResetFlags) ? 1 : -1])); /* add VkDescriptorPoolResetFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_flags = 0; +} + +void vkResetDescriptorPool_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkResetDescriptorPool_CALL_INSTANCE)); + CMOCK_vkResetDescriptorPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetDescriptorPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkResetDescriptorPool_CallInstance = CMock_Guts_MemChain(Mock.vkResetDescriptorPool_CallInstance, cmock_guts_index); + Mock.vkResetDescriptorPool_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkResetDescriptorPool_IgnoreBool = (char)1; +} + +void vkResetDescriptorPool_CMockStopIgnore(void) +{ + if(Mock.vkResetDescriptorPool_IgnoreBool) + Mock.vkResetDescriptorPool_CallInstance = CMock_Guts_MemNext(Mock.vkResetDescriptorPool_CallInstance); + Mock.vkResetDescriptorPool_IgnoreBool = (char)0; +} + +void vkResetDescriptorPool_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkResetDescriptorPool_CALL_INSTANCE)); + CMOCK_vkResetDescriptorPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetDescriptorPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkResetDescriptorPool_CallInstance = CMock_Guts_MemChain(Mock.vkResetDescriptorPool_CallInstance, cmock_guts_index); + Mock.vkResetDescriptorPool_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkResetDescriptorPool_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkResetDescriptorPool_CALL_INSTANCE)); + CMOCK_vkResetDescriptorPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetDescriptorPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkResetDescriptorPool_CallInstance = CMock_Guts_MemChain(Mock.vkResetDescriptorPool_CallInstance, cmock_guts_index); + Mock.vkResetDescriptorPool_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkResetDescriptorPool(cmock_call_instance, device, descriptorPool, flags); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkResetDescriptorPool_AddCallback(CMOCK_vkResetDescriptorPool_CALLBACK Callback) +{ + Mock.vkResetDescriptorPool_IgnoreBool = (char)0; + Mock.vkResetDescriptorPool_CallbackBool = (char)1; + Mock.vkResetDescriptorPool_CallbackFunctionPointer = Callback; +} + +void vkResetDescriptorPool_Stub(CMOCK_vkResetDescriptorPool_CALLBACK Callback) +{ + Mock.vkResetDescriptorPool_IgnoreBool = (char)0; + Mock.vkResetDescriptorPool_CallbackBool = (char)0; + Mock.vkResetDescriptorPool_CallbackFunctionPointer = Callback; +} + +void vkResetDescriptorPool_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkResetDescriptorPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetDescriptorPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkResetDescriptorPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkResetDescriptorPool_CMockIgnoreArg_descriptorPool(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkResetDescriptorPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetDescriptorPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkResetDescriptorPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_descriptorPool = 1; +} + +void vkResetDescriptorPool_CMockIgnoreArg_flags(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkResetDescriptorPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetDescriptorPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkResetDescriptorPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_flags = 1; +} + +VkResult vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkAllocateDescriptorSets_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkAllocateDescriptorSets); + cmock_call_instance = (CMOCK_vkAllocateDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkAllocateDescriptorSets_CallInstance); + Mock.vkAllocateDescriptorSets_CallInstance = CMock_Guts_MemNext(Mock.vkAllocateDescriptorSets_CallInstance); + if (Mock.vkAllocateDescriptorSets_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkAllocateDescriptorSets_FinalReturn; + memcpy((void*)(&Mock.vkAllocateDescriptorSets_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkAllocateDescriptorSets_CallbackBool && + Mock.vkAllocateDescriptorSets_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkAllocateDescriptorSets_CallbackFunctionPointer(device, pAllocateInfo, pDescriptorSets, Mock.vkAllocateDescriptorSets_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkAllocateDescriptorSets,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocateInfo) + { + UNITY_SET_DETAILS(CMockString_vkAllocateDescriptorSets,CMockString_pAllocateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocateInfo), (void*)(pAllocateInfo), sizeof(const VkDescriptorSetAllocateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDescriptorSets) + { + UNITY_SET_DETAILS(CMockString_vkAllocateDescriptorSets,CMockString_pDescriptorSets); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDescriptorSets), (void*)(pDescriptorSets), sizeof(VkDescriptorSet), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkAllocateDescriptorSets_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkAllocateDescriptorSets_CallbackFunctionPointer(device, pAllocateInfo, pDescriptorSets, Mock.vkAllocateDescriptorSets_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pDescriptorSets_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pDescriptorSets, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pDescriptorSets, (const void*)cmock_call_instance->ReturnThruPtr_pDescriptorSets_Val, + cmock_call_instance->ReturnThruPtr_pDescriptorSets_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkAllocateDescriptorSets(CMOCK_vkAllocateDescriptorSets_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets); +void CMockExpectParameters_vkAllocateDescriptorSets(CMOCK_vkAllocateDescriptorSets_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pAllocateInfo = pAllocateInfo; + cmock_call_instance->IgnoreArg_pAllocateInfo = 0; + cmock_call_instance->Expected_pDescriptorSets = pDescriptorSets; + cmock_call_instance->IgnoreArg_pDescriptorSets = 0; + cmock_call_instance->ReturnThruPtr_pDescriptorSets_Used = 0; +} + +void vkAllocateDescriptorSets_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkAllocateDescriptorSets_CALL_INSTANCE)); + CMOCK_vkAllocateDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAllocateDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkAllocateDescriptorSets_CallInstance = CMock_Guts_MemChain(Mock.vkAllocateDescriptorSets_CallInstance, cmock_guts_index); + Mock.vkAllocateDescriptorSets_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkAllocateDescriptorSets_IgnoreBool = (char)1; +} + +void vkAllocateDescriptorSets_CMockStopIgnore(void) +{ + if(Mock.vkAllocateDescriptorSets_IgnoreBool) + Mock.vkAllocateDescriptorSets_CallInstance = CMock_Guts_MemNext(Mock.vkAllocateDescriptorSets_CallInstance); + Mock.vkAllocateDescriptorSets_IgnoreBool = (char)0; +} + +void vkAllocateDescriptorSets_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkAllocateDescriptorSets_CALL_INSTANCE)); + CMOCK_vkAllocateDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAllocateDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkAllocateDescriptorSets_CallInstance = CMock_Guts_MemChain(Mock.vkAllocateDescriptorSets_CallInstance, cmock_guts_index); + Mock.vkAllocateDescriptorSets_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkAllocateDescriptorSets_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkAllocateDescriptorSets_CALL_INSTANCE)); + CMOCK_vkAllocateDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAllocateDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkAllocateDescriptorSets_CallInstance = CMock_Guts_MemChain(Mock.vkAllocateDescriptorSets_CallInstance, cmock_guts_index); + Mock.vkAllocateDescriptorSets_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkAllocateDescriptorSets(cmock_call_instance, device, pAllocateInfo, pDescriptorSets); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkAllocateDescriptorSets_AddCallback(CMOCK_vkAllocateDescriptorSets_CALLBACK Callback) +{ + Mock.vkAllocateDescriptorSets_IgnoreBool = (char)0; + Mock.vkAllocateDescriptorSets_CallbackBool = (char)1; + Mock.vkAllocateDescriptorSets_CallbackFunctionPointer = Callback; +} + +void vkAllocateDescriptorSets_Stub(CMOCK_vkAllocateDescriptorSets_CALLBACK Callback) +{ + Mock.vkAllocateDescriptorSets_IgnoreBool = (char)0; + Mock.vkAllocateDescriptorSets_CallbackBool = (char)0; + Mock.vkAllocateDescriptorSets_CallbackFunctionPointer = Callback; +} + +void vkAllocateDescriptorSets_CMockReturnMemThruPtr_pDescriptorSets(UNITY_LINE_TYPE cmock_line, VkDescriptorSet const* pDescriptorSets, size_t cmock_size) +{ + CMOCK_vkAllocateDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAllocateDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAllocateDescriptorSets_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pDescriptorSets_Used = 1; + cmock_call_instance->ReturnThruPtr_pDescriptorSets_Val = pDescriptorSets; + cmock_call_instance->ReturnThruPtr_pDescriptorSets_Size = cmock_size; +} + +void vkAllocateDescriptorSets_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkAllocateDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAllocateDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAllocateDescriptorSets_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkAllocateDescriptorSets_CMockIgnoreArg_pAllocateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkAllocateDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAllocateDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAllocateDescriptorSets_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocateInfo = 1; +} + +void vkAllocateDescriptorSets_CMockIgnoreArg_pDescriptorSets(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkAllocateDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAllocateDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAllocateDescriptorSets_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDescriptorSets = 1; +} + +VkResult vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkFreeDescriptorSets_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkFreeDescriptorSets); + cmock_call_instance = (CMOCK_vkFreeDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkFreeDescriptorSets_CallInstance); + Mock.vkFreeDescriptorSets_CallInstance = CMock_Guts_MemNext(Mock.vkFreeDescriptorSets_CallInstance); + if (Mock.vkFreeDescriptorSets_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkFreeDescriptorSets_FinalReturn; + memcpy((void*)(&Mock.vkFreeDescriptorSets_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkFreeDescriptorSets_CallbackBool && + Mock.vkFreeDescriptorSets_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkFreeDescriptorSets_CallbackFunctionPointer(device, descriptorPool, descriptorSetCount, pDescriptorSets, Mock.vkFreeDescriptorSets_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkFreeDescriptorSets,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_descriptorPool) + { + UNITY_SET_DETAILS(CMockString_vkFreeDescriptorSets,CMockString_descriptorPool); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_descriptorPool), (void*)(&descriptorPool), sizeof(VkDescriptorPool), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_descriptorSetCount) + { + UNITY_SET_DETAILS(CMockString_vkFreeDescriptorSets,CMockString_descriptorSetCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_descriptorSetCount, descriptorSetCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDescriptorSets) + { + UNITY_SET_DETAILS(CMockString_vkFreeDescriptorSets,CMockString_pDescriptorSets); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDescriptorSets), (void*)(pDescriptorSets), sizeof(const VkDescriptorSet), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkFreeDescriptorSets_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkFreeDescriptorSets_CallbackFunctionPointer(device, descriptorPool, descriptorSetCount, pDescriptorSets, Mock.vkFreeDescriptorSets_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkFreeDescriptorSets(CMOCK_vkFreeDescriptorSets_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets); +void CMockExpectParameters_vkFreeDescriptorSets(CMOCK_vkFreeDescriptorSets_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_descriptorPool), (void*)(&descriptorPool), + sizeof(VkDescriptorPool[sizeof(descriptorPool) == sizeof(VkDescriptorPool) ? 1 : -1])); /* add VkDescriptorPool to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_descriptorPool = 0; + cmock_call_instance->Expected_descriptorSetCount = descriptorSetCount; + cmock_call_instance->IgnoreArg_descriptorSetCount = 0; + cmock_call_instance->Expected_pDescriptorSets = pDescriptorSets; + cmock_call_instance->IgnoreArg_pDescriptorSets = 0; +} + +void vkFreeDescriptorSets_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkFreeDescriptorSets_CALL_INSTANCE)); + CMOCK_vkFreeDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkFreeDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkFreeDescriptorSets_CallInstance = CMock_Guts_MemChain(Mock.vkFreeDescriptorSets_CallInstance, cmock_guts_index); + Mock.vkFreeDescriptorSets_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkFreeDescriptorSets_IgnoreBool = (char)1; +} + +void vkFreeDescriptorSets_CMockStopIgnore(void) +{ + if(Mock.vkFreeDescriptorSets_IgnoreBool) + Mock.vkFreeDescriptorSets_CallInstance = CMock_Guts_MemNext(Mock.vkFreeDescriptorSets_CallInstance); + Mock.vkFreeDescriptorSets_IgnoreBool = (char)0; +} + +void vkFreeDescriptorSets_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkFreeDescriptorSets_CALL_INSTANCE)); + CMOCK_vkFreeDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkFreeDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkFreeDescriptorSets_CallInstance = CMock_Guts_MemChain(Mock.vkFreeDescriptorSets_CallInstance, cmock_guts_index); + Mock.vkFreeDescriptorSets_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkFreeDescriptorSets_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkFreeDescriptorSets_CALL_INSTANCE)); + CMOCK_vkFreeDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkFreeDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkFreeDescriptorSets_CallInstance = CMock_Guts_MemChain(Mock.vkFreeDescriptorSets_CallInstance, cmock_guts_index); + Mock.vkFreeDescriptorSets_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkFreeDescriptorSets(cmock_call_instance, device, descriptorPool, descriptorSetCount, pDescriptorSets); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkFreeDescriptorSets_AddCallback(CMOCK_vkFreeDescriptorSets_CALLBACK Callback) +{ + Mock.vkFreeDescriptorSets_IgnoreBool = (char)0; + Mock.vkFreeDescriptorSets_CallbackBool = (char)1; + Mock.vkFreeDescriptorSets_CallbackFunctionPointer = Callback; +} + +void vkFreeDescriptorSets_Stub(CMOCK_vkFreeDescriptorSets_CALLBACK Callback) +{ + Mock.vkFreeDescriptorSets_IgnoreBool = (char)0; + Mock.vkFreeDescriptorSets_CallbackBool = (char)0; + Mock.vkFreeDescriptorSets_CallbackFunctionPointer = Callback; +} + +void vkFreeDescriptorSets_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkFreeDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkFreeDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkFreeDescriptorSets_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkFreeDescriptorSets_CMockIgnoreArg_descriptorPool(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkFreeDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkFreeDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkFreeDescriptorSets_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_descriptorPool = 1; +} + +void vkFreeDescriptorSets_CMockIgnoreArg_descriptorSetCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkFreeDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkFreeDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkFreeDescriptorSets_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_descriptorSetCount = 1; +} + +void vkFreeDescriptorSets_CMockIgnoreArg_pDescriptorSets(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkFreeDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkFreeDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkFreeDescriptorSets_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDescriptorSets = 1; +} + +void vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkUpdateDescriptorSets_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkUpdateDescriptorSets); + cmock_call_instance = (CMOCK_vkUpdateDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkUpdateDescriptorSets_CallInstance); + Mock.vkUpdateDescriptorSets_CallInstance = CMock_Guts_MemNext(Mock.vkUpdateDescriptorSets_CallInstance); + if (Mock.vkUpdateDescriptorSets_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkUpdateDescriptorSets_CallbackBool && + Mock.vkUpdateDescriptorSets_CallbackFunctionPointer != NULL) + { + Mock.vkUpdateDescriptorSets_CallbackFunctionPointer(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies, Mock.vkUpdateDescriptorSets_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkUpdateDescriptorSets,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_descriptorWriteCount) + { + UNITY_SET_DETAILS(CMockString_vkUpdateDescriptorSets,CMockString_descriptorWriteCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_descriptorWriteCount, descriptorWriteCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDescriptorWrites) + { + UNITY_SET_DETAILS(CMockString_vkUpdateDescriptorSets,CMockString_pDescriptorWrites); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDescriptorWrites), (void*)(pDescriptorWrites), sizeof(const VkWriteDescriptorSet), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_descriptorCopyCount) + { + UNITY_SET_DETAILS(CMockString_vkUpdateDescriptorSets,CMockString_descriptorCopyCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_descriptorCopyCount, descriptorCopyCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDescriptorCopies) + { + UNITY_SET_DETAILS(CMockString_vkUpdateDescriptorSets,CMockString_pDescriptorCopies); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDescriptorCopies), (void*)(pDescriptorCopies), sizeof(const VkCopyDescriptorSet), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkUpdateDescriptorSets_CallbackFunctionPointer != NULL) + { + Mock.vkUpdateDescriptorSets_CallbackFunctionPointer(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies, Mock.vkUpdateDescriptorSets_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkUpdateDescriptorSets(CMOCK_vkUpdateDescriptorSets_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies); +void CMockExpectParameters_vkUpdateDescriptorSets(CMOCK_vkUpdateDescriptorSets_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_descriptorWriteCount = descriptorWriteCount; + cmock_call_instance->IgnoreArg_descriptorWriteCount = 0; + cmock_call_instance->Expected_pDescriptorWrites = pDescriptorWrites; + cmock_call_instance->IgnoreArg_pDescriptorWrites = 0; + cmock_call_instance->Expected_descriptorCopyCount = descriptorCopyCount; + cmock_call_instance->IgnoreArg_descriptorCopyCount = 0; + cmock_call_instance->Expected_pDescriptorCopies = pDescriptorCopies; + cmock_call_instance->IgnoreArg_pDescriptorCopies = 0; +} + +void vkUpdateDescriptorSets_CMockIgnore(void) +{ + Mock.vkUpdateDescriptorSets_IgnoreBool = (char)1; +} + +void vkUpdateDescriptorSets_CMockStopIgnore(void) +{ + Mock.vkUpdateDescriptorSets_IgnoreBool = (char)0; +} + +void vkUpdateDescriptorSets_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkUpdateDescriptorSets_CALL_INSTANCE)); + CMOCK_vkUpdateDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUpdateDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkUpdateDescriptorSets_CallInstance = CMock_Guts_MemChain(Mock.vkUpdateDescriptorSets_CallInstance, cmock_guts_index); + Mock.vkUpdateDescriptorSets_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkUpdateDescriptorSets_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkUpdateDescriptorSets_CALL_INSTANCE)); + CMOCK_vkUpdateDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUpdateDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkUpdateDescriptorSets_CallInstance = CMock_Guts_MemChain(Mock.vkUpdateDescriptorSets_CallInstance, cmock_guts_index); + Mock.vkUpdateDescriptorSets_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkUpdateDescriptorSets(cmock_call_instance, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); +} + +void vkUpdateDescriptorSets_AddCallback(CMOCK_vkUpdateDescriptorSets_CALLBACK Callback) +{ + Mock.vkUpdateDescriptorSets_IgnoreBool = (char)0; + Mock.vkUpdateDescriptorSets_CallbackBool = (char)1; + Mock.vkUpdateDescriptorSets_CallbackFunctionPointer = Callback; +} + +void vkUpdateDescriptorSets_Stub(CMOCK_vkUpdateDescriptorSets_CALLBACK Callback) +{ + Mock.vkUpdateDescriptorSets_IgnoreBool = (char)0; + Mock.vkUpdateDescriptorSets_CallbackBool = (char)0; + Mock.vkUpdateDescriptorSets_CallbackFunctionPointer = Callback; +} + +void vkUpdateDescriptorSets_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkUpdateDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUpdateDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkUpdateDescriptorSets_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkUpdateDescriptorSets_CMockIgnoreArg_descriptorWriteCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkUpdateDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUpdateDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkUpdateDescriptorSets_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_descriptorWriteCount = 1; +} + +void vkUpdateDescriptorSets_CMockIgnoreArg_pDescriptorWrites(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkUpdateDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUpdateDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkUpdateDescriptorSets_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDescriptorWrites = 1; +} + +void vkUpdateDescriptorSets_CMockIgnoreArg_descriptorCopyCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkUpdateDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUpdateDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkUpdateDescriptorSets_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_descriptorCopyCount = 1; +} + +void vkUpdateDescriptorSets_CMockIgnoreArg_pDescriptorCopies(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkUpdateDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUpdateDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkUpdateDescriptorSets_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDescriptorCopies = 1; +} + +VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateFramebuffer_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateFramebuffer); + cmock_call_instance = (CMOCK_vkCreateFramebuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateFramebuffer_CallInstance); + Mock.vkCreateFramebuffer_CallInstance = CMock_Guts_MemNext(Mock.vkCreateFramebuffer_CallInstance); + if (Mock.vkCreateFramebuffer_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateFramebuffer_FinalReturn; + memcpy((void*)(&Mock.vkCreateFramebuffer_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateFramebuffer_CallbackBool && + Mock.vkCreateFramebuffer_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateFramebuffer_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pFramebuffer, Mock.vkCreateFramebuffer_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateFramebuffer,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateFramebuffer,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkFramebufferCreateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateFramebuffer,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pFramebuffer) + { + UNITY_SET_DETAILS(CMockString_vkCreateFramebuffer,CMockString_pFramebuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pFramebuffer), (void*)(pFramebuffer), sizeof(VkFramebuffer), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateFramebuffer_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateFramebuffer_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pFramebuffer, Mock.vkCreateFramebuffer_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pFramebuffer_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pFramebuffer, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pFramebuffer, (const void*)cmock_call_instance->ReturnThruPtr_pFramebuffer_Val, + cmock_call_instance->ReturnThruPtr_pFramebuffer_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateFramebuffer(CMOCK_vkCreateFramebuffer_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer); +void CMockExpectParameters_vkCreateFramebuffer(CMOCK_vkCreateFramebuffer_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pFramebuffer = pFramebuffer; + cmock_call_instance->IgnoreArg_pFramebuffer = 0; + cmock_call_instance->ReturnThruPtr_pFramebuffer_Used = 0; +} + +void vkCreateFramebuffer_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateFramebuffer_CALL_INSTANCE)); + CMOCK_vkCreateFramebuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateFramebuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateFramebuffer_CallInstance = CMock_Guts_MemChain(Mock.vkCreateFramebuffer_CallInstance, cmock_guts_index); + Mock.vkCreateFramebuffer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateFramebuffer_IgnoreBool = (char)1; +} + +void vkCreateFramebuffer_CMockStopIgnore(void) +{ + if(Mock.vkCreateFramebuffer_IgnoreBool) + Mock.vkCreateFramebuffer_CallInstance = CMock_Guts_MemNext(Mock.vkCreateFramebuffer_CallInstance); + Mock.vkCreateFramebuffer_IgnoreBool = (char)0; +} + +void vkCreateFramebuffer_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateFramebuffer_CALL_INSTANCE)); + CMOCK_vkCreateFramebuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateFramebuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateFramebuffer_CallInstance = CMock_Guts_MemChain(Mock.vkCreateFramebuffer_CallInstance, cmock_guts_index); + Mock.vkCreateFramebuffer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateFramebuffer_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateFramebuffer_CALL_INSTANCE)); + CMOCK_vkCreateFramebuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateFramebuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateFramebuffer_CallInstance = CMock_Guts_MemChain(Mock.vkCreateFramebuffer_CallInstance, cmock_guts_index); + Mock.vkCreateFramebuffer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateFramebuffer(cmock_call_instance, device, pCreateInfo, pAllocator, pFramebuffer); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateFramebuffer_AddCallback(CMOCK_vkCreateFramebuffer_CALLBACK Callback) +{ + Mock.vkCreateFramebuffer_IgnoreBool = (char)0; + Mock.vkCreateFramebuffer_CallbackBool = (char)1; + Mock.vkCreateFramebuffer_CallbackFunctionPointer = Callback; +} + +void vkCreateFramebuffer_Stub(CMOCK_vkCreateFramebuffer_CALLBACK Callback) +{ + Mock.vkCreateFramebuffer_IgnoreBool = (char)0; + Mock.vkCreateFramebuffer_CallbackBool = (char)0; + Mock.vkCreateFramebuffer_CallbackFunctionPointer = Callback; +} + +void vkCreateFramebuffer_CMockReturnMemThruPtr_pFramebuffer(UNITY_LINE_TYPE cmock_line, VkFramebuffer const* pFramebuffer, size_t cmock_size) +{ + CMOCK_vkCreateFramebuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateFramebuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateFramebuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pFramebuffer_Used = 1; + cmock_call_instance->ReturnThruPtr_pFramebuffer_Val = pFramebuffer; + cmock_call_instance->ReturnThruPtr_pFramebuffer_Size = cmock_size; +} + +void vkCreateFramebuffer_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateFramebuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateFramebuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateFramebuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateFramebuffer_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateFramebuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateFramebuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateFramebuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateFramebuffer_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateFramebuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateFramebuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateFramebuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateFramebuffer_CMockIgnoreArg_pFramebuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateFramebuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateFramebuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateFramebuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pFramebuffer = 1; +} + +void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyFramebuffer_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyFramebuffer); + cmock_call_instance = (CMOCK_vkDestroyFramebuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyFramebuffer_CallInstance); + Mock.vkDestroyFramebuffer_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyFramebuffer_CallInstance); + if (Mock.vkDestroyFramebuffer_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyFramebuffer_CallbackBool && + Mock.vkDestroyFramebuffer_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyFramebuffer_CallbackFunctionPointer(device, framebuffer, pAllocator, Mock.vkDestroyFramebuffer_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyFramebuffer,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_framebuffer) + { + UNITY_SET_DETAILS(CMockString_vkDestroyFramebuffer,CMockString_framebuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_framebuffer), (void*)(&framebuffer), sizeof(VkFramebuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyFramebuffer,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyFramebuffer_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyFramebuffer_CallbackFunctionPointer(device, framebuffer, pAllocator, Mock.vkDestroyFramebuffer_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyFramebuffer(CMOCK_vkDestroyFramebuffer_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyFramebuffer(CMOCK_vkDestroyFramebuffer_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_framebuffer), (void*)(&framebuffer), + sizeof(VkFramebuffer[sizeof(framebuffer) == sizeof(VkFramebuffer) ? 1 : -1])); /* add VkFramebuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_framebuffer = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyFramebuffer_CMockIgnore(void) +{ + Mock.vkDestroyFramebuffer_IgnoreBool = (char)1; +} + +void vkDestroyFramebuffer_CMockStopIgnore(void) +{ + Mock.vkDestroyFramebuffer_IgnoreBool = (char)0; +} + +void vkDestroyFramebuffer_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyFramebuffer_CALL_INSTANCE)); + CMOCK_vkDestroyFramebuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyFramebuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyFramebuffer_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyFramebuffer_CallInstance, cmock_guts_index); + Mock.vkDestroyFramebuffer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyFramebuffer_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyFramebuffer_CALL_INSTANCE)); + CMOCK_vkDestroyFramebuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyFramebuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyFramebuffer_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyFramebuffer_CallInstance, cmock_guts_index); + Mock.vkDestroyFramebuffer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyFramebuffer(cmock_call_instance, device, framebuffer, pAllocator); +} + +void vkDestroyFramebuffer_AddCallback(CMOCK_vkDestroyFramebuffer_CALLBACK Callback) +{ + Mock.vkDestroyFramebuffer_IgnoreBool = (char)0; + Mock.vkDestroyFramebuffer_CallbackBool = (char)1; + Mock.vkDestroyFramebuffer_CallbackFunctionPointer = Callback; +} + +void vkDestroyFramebuffer_Stub(CMOCK_vkDestroyFramebuffer_CALLBACK Callback) +{ + Mock.vkDestroyFramebuffer_IgnoreBool = (char)0; + Mock.vkDestroyFramebuffer_CallbackBool = (char)0; + Mock.vkDestroyFramebuffer_CallbackFunctionPointer = Callback; +} + +void vkDestroyFramebuffer_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyFramebuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyFramebuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyFramebuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyFramebuffer_CMockIgnoreArg_framebuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyFramebuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyFramebuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyFramebuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_framebuffer = 1; +} + +void vkDestroyFramebuffer_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyFramebuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyFramebuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyFramebuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateRenderPass_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateRenderPass); + cmock_call_instance = (CMOCK_vkCreateRenderPass_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateRenderPass_CallInstance); + Mock.vkCreateRenderPass_CallInstance = CMock_Guts_MemNext(Mock.vkCreateRenderPass_CallInstance); + if (Mock.vkCreateRenderPass_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateRenderPass_FinalReturn; + memcpy((void*)(&Mock.vkCreateRenderPass_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateRenderPass_CallbackBool && + Mock.vkCreateRenderPass_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateRenderPass_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pRenderPass, Mock.vkCreateRenderPass_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateRenderPass,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateRenderPass,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkRenderPassCreateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateRenderPass,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pRenderPass) + { + UNITY_SET_DETAILS(CMockString_vkCreateRenderPass,CMockString_pRenderPass); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pRenderPass), (void*)(pRenderPass), sizeof(VkRenderPass), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateRenderPass_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateRenderPass_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pRenderPass, Mock.vkCreateRenderPass_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pRenderPass_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pRenderPass, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pRenderPass, (const void*)cmock_call_instance->ReturnThruPtr_pRenderPass_Val, + cmock_call_instance->ReturnThruPtr_pRenderPass_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateRenderPass(CMOCK_vkCreateRenderPass_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); +void CMockExpectParameters_vkCreateRenderPass(CMOCK_vkCreateRenderPass_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pRenderPass = pRenderPass; + cmock_call_instance->IgnoreArg_pRenderPass = 0; + cmock_call_instance->ReturnThruPtr_pRenderPass_Used = 0; +} + +void vkCreateRenderPass_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateRenderPass_CALL_INSTANCE)); + CMOCK_vkCreateRenderPass_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRenderPass_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateRenderPass_CallInstance = CMock_Guts_MemChain(Mock.vkCreateRenderPass_CallInstance, cmock_guts_index); + Mock.vkCreateRenderPass_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateRenderPass_IgnoreBool = (char)1; +} + +void vkCreateRenderPass_CMockStopIgnore(void) +{ + if(Mock.vkCreateRenderPass_IgnoreBool) + Mock.vkCreateRenderPass_CallInstance = CMock_Guts_MemNext(Mock.vkCreateRenderPass_CallInstance); + Mock.vkCreateRenderPass_IgnoreBool = (char)0; +} + +void vkCreateRenderPass_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateRenderPass_CALL_INSTANCE)); + CMOCK_vkCreateRenderPass_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRenderPass_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateRenderPass_CallInstance = CMock_Guts_MemChain(Mock.vkCreateRenderPass_CallInstance, cmock_guts_index); + Mock.vkCreateRenderPass_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateRenderPass_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateRenderPass_CALL_INSTANCE)); + CMOCK_vkCreateRenderPass_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRenderPass_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateRenderPass_CallInstance = CMock_Guts_MemChain(Mock.vkCreateRenderPass_CallInstance, cmock_guts_index); + Mock.vkCreateRenderPass_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateRenderPass(cmock_call_instance, device, pCreateInfo, pAllocator, pRenderPass); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateRenderPass_AddCallback(CMOCK_vkCreateRenderPass_CALLBACK Callback) +{ + Mock.vkCreateRenderPass_IgnoreBool = (char)0; + Mock.vkCreateRenderPass_CallbackBool = (char)1; + Mock.vkCreateRenderPass_CallbackFunctionPointer = Callback; +} + +void vkCreateRenderPass_Stub(CMOCK_vkCreateRenderPass_CALLBACK Callback) +{ + Mock.vkCreateRenderPass_IgnoreBool = (char)0; + Mock.vkCreateRenderPass_CallbackBool = (char)0; + Mock.vkCreateRenderPass_CallbackFunctionPointer = Callback; +} + +void vkCreateRenderPass_CMockReturnMemThruPtr_pRenderPass(UNITY_LINE_TYPE cmock_line, VkRenderPass const* pRenderPass, size_t cmock_size) +{ + CMOCK_vkCreateRenderPass_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRenderPass_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateRenderPass_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pRenderPass_Used = 1; + cmock_call_instance->ReturnThruPtr_pRenderPass_Val = pRenderPass; + cmock_call_instance->ReturnThruPtr_pRenderPass_Size = cmock_size; +} + +void vkCreateRenderPass_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateRenderPass_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRenderPass_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateRenderPass_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateRenderPass_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateRenderPass_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRenderPass_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateRenderPass_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateRenderPass_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateRenderPass_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRenderPass_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateRenderPass_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateRenderPass_CMockIgnoreArg_pRenderPass(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateRenderPass_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRenderPass_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateRenderPass_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pRenderPass = 1; +} + +void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyRenderPass_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyRenderPass); + cmock_call_instance = (CMOCK_vkDestroyRenderPass_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyRenderPass_CallInstance); + Mock.vkDestroyRenderPass_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyRenderPass_CallInstance); + if (Mock.vkDestroyRenderPass_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyRenderPass_CallbackBool && + Mock.vkDestroyRenderPass_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyRenderPass_CallbackFunctionPointer(device, renderPass, pAllocator, Mock.vkDestroyRenderPass_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyRenderPass,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_renderPass) + { + UNITY_SET_DETAILS(CMockString_vkDestroyRenderPass,CMockString_renderPass); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_renderPass), (void*)(&renderPass), sizeof(VkRenderPass), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyRenderPass,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyRenderPass_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyRenderPass_CallbackFunctionPointer(device, renderPass, pAllocator, Mock.vkDestroyRenderPass_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyRenderPass(CMOCK_vkDestroyRenderPass_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyRenderPass(CMOCK_vkDestroyRenderPass_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_renderPass), (void*)(&renderPass), + sizeof(VkRenderPass[sizeof(renderPass) == sizeof(VkRenderPass) ? 1 : -1])); /* add VkRenderPass to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_renderPass = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyRenderPass_CMockIgnore(void) +{ + Mock.vkDestroyRenderPass_IgnoreBool = (char)1; +} + +void vkDestroyRenderPass_CMockStopIgnore(void) +{ + Mock.vkDestroyRenderPass_IgnoreBool = (char)0; +} + +void vkDestroyRenderPass_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyRenderPass_CALL_INSTANCE)); + CMOCK_vkDestroyRenderPass_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyRenderPass_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyRenderPass_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyRenderPass_CallInstance, cmock_guts_index); + Mock.vkDestroyRenderPass_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyRenderPass_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyRenderPass_CALL_INSTANCE)); + CMOCK_vkDestroyRenderPass_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyRenderPass_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyRenderPass_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyRenderPass_CallInstance, cmock_guts_index); + Mock.vkDestroyRenderPass_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyRenderPass(cmock_call_instance, device, renderPass, pAllocator); +} + +void vkDestroyRenderPass_AddCallback(CMOCK_vkDestroyRenderPass_CALLBACK Callback) +{ + Mock.vkDestroyRenderPass_IgnoreBool = (char)0; + Mock.vkDestroyRenderPass_CallbackBool = (char)1; + Mock.vkDestroyRenderPass_CallbackFunctionPointer = Callback; +} + +void vkDestroyRenderPass_Stub(CMOCK_vkDestroyRenderPass_CALLBACK Callback) +{ + Mock.vkDestroyRenderPass_IgnoreBool = (char)0; + Mock.vkDestroyRenderPass_CallbackBool = (char)0; + Mock.vkDestroyRenderPass_CallbackFunctionPointer = Callback; +} + +void vkDestroyRenderPass_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyRenderPass_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyRenderPass_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyRenderPass_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyRenderPass_CMockIgnoreArg_renderPass(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyRenderPass_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyRenderPass_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyRenderPass_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_renderPass = 1; +} + +void vkDestroyRenderPass_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyRenderPass_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyRenderPass_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyRenderPass_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetRenderAreaGranularity_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetRenderAreaGranularity); + cmock_call_instance = (CMOCK_vkGetRenderAreaGranularity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetRenderAreaGranularity_CallInstance); + Mock.vkGetRenderAreaGranularity_CallInstance = CMock_Guts_MemNext(Mock.vkGetRenderAreaGranularity_CallInstance); + if (Mock.vkGetRenderAreaGranularity_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetRenderAreaGranularity_CallbackBool && + Mock.vkGetRenderAreaGranularity_CallbackFunctionPointer != NULL) + { + Mock.vkGetRenderAreaGranularity_CallbackFunctionPointer(device, renderPass, pGranularity, Mock.vkGetRenderAreaGranularity_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetRenderAreaGranularity,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_renderPass) + { + UNITY_SET_DETAILS(CMockString_vkGetRenderAreaGranularity,CMockString_renderPass); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_renderPass), (void*)(&renderPass), sizeof(VkRenderPass), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pGranularity) + { + UNITY_SET_DETAILS(CMockString_vkGetRenderAreaGranularity,CMockString_pGranularity); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pGranularity), (void*)(pGranularity), sizeof(VkExtent2D), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetRenderAreaGranularity_CallbackFunctionPointer != NULL) + { + Mock.vkGetRenderAreaGranularity_CallbackFunctionPointer(device, renderPass, pGranularity, Mock.vkGetRenderAreaGranularity_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pGranularity_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pGranularity, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pGranularity, (const void*)cmock_call_instance->ReturnThruPtr_pGranularity_Val, + cmock_call_instance->ReturnThruPtr_pGranularity_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetRenderAreaGranularity(CMOCK_vkGetRenderAreaGranularity_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); +void CMockExpectParameters_vkGetRenderAreaGranularity(CMOCK_vkGetRenderAreaGranularity_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_renderPass), (void*)(&renderPass), + sizeof(VkRenderPass[sizeof(renderPass) == sizeof(VkRenderPass) ? 1 : -1])); /* add VkRenderPass to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_renderPass = 0; + cmock_call_instance->Expected_pGranularity = pGranularity; + cmock_call_instance->IgnoreArg_pGranularity = 0; + cmock_call_instance->ReturnThruPtr_pGranularity_Used = 0; +} + +void vkGetRenderAreaGranularity_CMockIgnore(void) +{ + Mock.vkGetRenderAreaGranularity_IgnoreBool = (char)1; +} + +void vkGetRenderAreaGranularity_CMockStopIgnore(void) +{ + Mock.vkGetRenderAreaGranularity_IgnoreBool = (char)0; +} + +void vkGetRenderAreaGranularity_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetRenderAreaGranularity_CALL_INSTANCE)); + CMOCK_vkGetRenderAreaGranularity_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRenderAreaGranularity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetRenderAreaGranularity_CallInstance = CMock_Guts_MemChain(Mock.vkGetRenderAreaGranularity_CallInstance, cmock_guts_index); + Mock.vkGetRenderAreaGranularity_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetRenderAreaGranularity_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetRenderAreaGranularity_CALL_INSTANCE)); + CMOCK_vkGetRenderAreaGranularity_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRenderAreaGranularity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetRenderAreaGranularity_CallInstance = CMock_Guts_MemChain(Mock.vkGetRenderAreaGranularity_CallInstance, cmock_guts_index); + Mock.vkGetRenderAreaGranularity_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetRenderAreaGranularity(cmock_call_instance, device, renderPass, pGranularity); +} + +void vkGetRenderAreaGranularity_AddCallback(CMOCK_vkGetRenderAreaGranularity_CALLBACK Callback) +{ + Mock.vkGetRenderAreaGranularity_IgnoreBool = (char)0; + Mock.vkGetRenderAreaGranularity_CallbackBool = (char)1; + Mock.vkGetRenderAreaGranularity_CallbackFunctionPointer = Callback; +} + +void vkGetRenderAreaGranularity_Stub(CMOCK_vkGetRenderAreaGranularity_CALLBACK Callback) +{ + Mock.vkGetRenderAreaGranularity_IgnoreBool = (char)0; + Mock.vkGetRenderAreaGranularity_CallbackBool = (char)0; + Mock.vkGetRenderAreaGranularity_CallbackFunctionPointer = Callback; +} + +void vkGetRenderAreaGranularity_CMockReturnMemThruPtr_pGranularity(UNITY_LINE_TYPE cmock_line, VkExtent2D const* pGranularity, size_t cmock_size) +{ + CMOCK_vkGetRenderAreaGranularity_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRenderAreaGranularity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRenderAreaGranularity_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pGranularity_Used = 1; + cmock_call_instance->ReturnThruPtr_pGranularity_Val = pGranularity; + cmock_call_instance->ReturnThruPtr_pGranularity_Size = cmock_size; +} + +void vkGetRenderAreaGranularity_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetRenderAreaGranularity_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRenderAreaGranularity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRenderAreaGranularity_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetRenderAreaGranularity_CMockIgnoreArg_renderPass(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetRenderAreaGranularity_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRenderAreaGranularity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRenderAreaGranularity_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_renderPass = 1; +} + +void vkGetRenderAreaGranularity_CMockIgnoreArg_pGranularity(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetRenderAreaGranularity_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRenderAreaGranularity_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRenderAreaGranularity_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pGranularity = 1; +} + +VkResult vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateCommandPool_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateCommandPool); + cmock_call_instance = (CMOCK_vkCreateCommandPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateCommandPool_CallInstance); + Mock.vkCreateCommandPool_CallInstance = CMock_Guts_MemNext(Mock.vkCreateCommandPool_CallInstance); + if (Mock.vkCreateCommandPool_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateCommandPool_FinalReturn; + memcpy((void*)(&Mock.vkCreateCommandPool_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateCommandPool_CallbackBool && + Mock.vkCreateCommandPool_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateCommandPool_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pCommandPool, Mock.vkCreateCommandPool_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateCommandPool,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateCommandPool,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkCommandPoolCreateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateCommandPool,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCommandPool) + { + UNITY_SET_DETAILS(CMockString_vkCreateCommandPool,CMockString_pCommandPool); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCommandPool), (void*)(pCommandPool), sizeof(VkCommandPool), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateCommandPool_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateCommandPool_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pCommandPool, Mock.vkCreateCommandPool_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pCommandPool_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pCommandPool, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pCommandPool, (const void*)cmock_call_instance->ReturnThruPtr_pCommandPool_Val, + cmock_call_instance->ReturnThruPtr_pCommandPool_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateCommandPool(CMOCK_vkCreateCommandPool_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool); +void CMockExpectParameters_vkCreateCommandPool(CMOCK_vkCreateCommandPool_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pCommandPool = pCommandPool; + cmock_call_instance->IgnoreArg_pCommandPool = 0; + cmock_call_instance->ReturnThruPtr_pCommandPool_Used = 0; +} + +void vkCreateCommandPool_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateCommandPool_CALL_INSTANCE)); + CMOCK_vkCreateCommandPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateCommandPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateCommandPool_CallInstance = CMock_Guts_MemChain(Mock.vkCreateCommandPool_CallInstance, cmock_guts_index); + Mock.vkCreateCommandPool_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateCommandPool_IgnoreBool = (char)1; +} + +void vkCreateCommandPool_CMockStopIgnore(void) +{ + if(Mock.vkCreateCommandPool_IgnoreBool) + Mock.vkCreateCommandPool_CallInstance = CMock_Guts_MemNext(Mock.vkCreateCommandPool_CallInstance); + Mock.vkCreateCommandPool_IgnoreBool = (char)0; +} + +void vkCreateCommandPool_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateCommandPool_CALL_INSTANCE)); + CMOCK_vkCreateCommandPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateCommandPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateCommandPool_CallInstance = CMock_Guts_MemChain(Mock.vkCreateCommandPool_CallInstance, cmock_guts_index); + Mock.vkCreateCommandPool_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateCommandPool_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateCommandPool_CALL_INSTANCE)); + CMOCK_vkCreateCommandPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateCommandPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateCommandPool_CallInstance = CMock_Guts_MemChain(Mock.vkCreateCommandPool_CallInstance, cmock_guts_index); + Mock.vkCreateCommandPool_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateCommandPool(cmock_call_instance, device, pCreateInfo, pAllocator, pCommandPool); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateCommandPool_AddCallback(CMOCK_vkCreateCommandPool_CALLBACK Callback) +{ + Mock.vkCreateCommandPool_IgnoreBool = (char)0; + Mock.vkCreateCommandPool_CallbackBool = (char)1; + Mock.vkCreateCommandPool_CallbackFunctionPointer = Callback; +} + +void vkCreateCommandPool_Stub(CMOCK_vkCreateCommandPool_CALLBACK Callback) +{ + Mock.vkCreateCommandPool_IgnoreBool = (char)0; + Mock.vkCreateCommandPool_CallbackBool = (char)0; + Mock.vkCreateCommandPool_CallbackFunctionPointer = Callback; +} + +void vkCreateCommandPool_CMockReturnMemThruPtr_pCommandPool(UNITY_LINE_TYPE cmock_line, VkCommandPool const* pCommandPool, size_t cmock_size) +{ + CMOCK_vkCreateCommandPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateCommandPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateCommandPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pCommandPool_Used = 1; + cmock_call_instance->ReturnThruPtr_pCommandPool_Val = pCommandPool; + cmock_call_instance->ReturnThruPtr_pCommandPool_Size = cmock_size; +} + +void vkCreateCommandPool_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateCommandPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateCommandPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateCommandPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateCommandPool_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateCommandPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateCommandPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateCommandPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateCommandPool_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateCommandPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateCommandPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateCommandPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateCommandPool_CMockIgnoreArg_pCommandPool(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateCommandPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateCommandPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateCommandPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCommandPool = 1; +} + +void vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyCommandPool_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyCommandPool); + cmock_call_instance = (CMOCK_vkDestroyCommandPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyCommandPool_CallInstance); + Mock.vkDestroyCommandPool_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyCommandPool_CallInstance); + if (Mock.vkDestroyCommandPool_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyCommandPool_CallbackBool && + Mock.vkDestroyCommandPool_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyCommandPool_CallbackFunctionPointer(device, commandPool, pAllocator, Mock.vkDestroyCommandPool_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyCommandPool,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_commandPool) + { + UNITY_SET_DETAILS(CMockString_vkDestroyCommandPool,CMockString_commandPool); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandPool), (void*)(&commandPool), sizeof(VkCommandPool), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyCommandPool,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyCommandPool_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyCommandPool_CallbackFunctionPointer(device, commandPool, pAllocator, Mock.vkDestroyCommandPool_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyCommandPool(CMOCK_vkDestroyCommandPool_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyCommandPool(CMOCK_vkDestroyCommandPool_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_commandPool), (void*)(&commandPool), + sizeof(VkCommandPool[sizeof(commandPool) == sizeof(VkCommandPool) ? 1 : -1])); /* add VkCommandPool to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandPool = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyCommandPool_CMockIgnore(void) +{ + Mock.vkDestroyCommandPool_IgnoreBool = (char)1; +} + +void vkDestroyCommandPool_CMockStopIgnore(void) +{ + Mock.vkDestroyCommandPool_IgnoreBool = (char)0; +} + +void vkDestroyCommandPool_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyCommandPool_CALL_INSTANCE)); + CMOCK_vkDestroyCommandPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyCommandPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyCommandPool_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyCommandPool_CallInstance, cmock_guts_index); + Mock.vkDestroyCommandPool_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyCommandPool_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyCommandPool_CALL_INSTANCE)); + CMOCK_vkDestroyCommandPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyCommandPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyCommandPool_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyCommandPool_CallInstance, cmock_guts_index); + Mock.vkDestroyCommandPool_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyCommandPool(cmock_call_instance, device, commandPool, pAllocator); +} + +void vkDestroyCommandPool_AddCallback(CMOCK_vkDestroyCommandPool_CALLBACK Callback) +{ + Mock.vkDestroyCommandPool_IgnoreBool = (char)0; + Mock.vkDestroyCommandPool_CallbackBool = (char)1; + Mock.vkDestroyCommandPool_CallbackFunctionPointer = Callback; +} + +void vkDestroyCommandPool_Stub(CMOCK_vkDestroyCommandPool_CALLBACK Callback) +{ + Mock.vkDestroyCommandPool_IgnoreBool = (char)0; + Mock.vkDestroyCommandPool_CallbackBool = (char)0; + Mock.vkDestroyCommandPool_CallbackFunctionPointer = Callback; +} + +void vkDestroyCommandPool_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyCommandPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyCommandPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyCommandPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyCommandPool_CMockIgnoreArg_commandPool(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyCommandPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyCommandPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyCommandPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandPool = 1; +} + +void vkDestroyCommandPool_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyCommandPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyCommandPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyCommandPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +VkResult vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkResetCommandPool_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkResetCommandPool); + cmock_call_instance = (CMOCK_vkResetCommandPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkResetCommandPool_CallInstance); + Mock.vkResetCommandPool_CallInstance = CMock_Guts_MemNext(Mock.vkResetCommandPool_CallInstance); + if (Mock.vkResetCommandPool_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkResetCommandPool_FinalReturn; + memcpy((void*)(&Mock.vkResetCommandPool_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkResetCommandPool_CallbackBool && + Mock.vkResetCommandPool_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkResetCommandPool_CallbackFunctionPointer(device, commandPool, flags, Mock.vkResetCommandPool_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkResetCommandPool,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_commandPool) + { + UNITY_SET_DETAILS(CMockString_vkResetCommandPool,CMockString_commandPool); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandPool), (void*)(&commandPool), sizeof(VkCommandPool), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_flags) + { + UNITY_SET_DETAILS(CMockString_vkResetCommandPool,CMockString_flags); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_flags), (void*)(&flags), sizeof(VkCommandPoolResetFlags), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkResetCommandPool_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkResetCommandPool_CallbackFunctionPointer(device, commandPool, flags, Mock.vkResetCommandPool_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkResetCommandPool(CMOCK_vkResetCommandPool_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags); +void CMockExpectParameters_vkResetCommandPool(CMOCK_vkResetCommandPool_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_commandPool), (void*)(&commandPool), + sizeof(VkCommandPool[sizeof(commandPool) == sizeof(VkCommandPool) ? 1 : -1])); /* add VkCommandPool to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandPool = 0; + memcpy((void*)(&cmock_call_instance->Expected_flags), (void*)(&flags), + sizeof(VkCommandPoolResetFlags[sizeof(flags) == sizeof(VkCommandPoolResetFlags) ? 1 : -1])); /* add VkCommandPoolResetFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_flags = 0; +} + +void vkResetCommandPool_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkResetCommandPool_CALL_INSTANCE)); + CMOCK_vkResetCommandPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetCommandPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkResetCommandPool_CallInstance = CMock_Guts_MemChain(Mock.vkResetCommandPool_CallInstance, cmock_guts_index); + Mock.vkResetCommandPool_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkResetCommandPool_IgnoreBool = (char)1; +} + +void vkResetCommandPool_CMockStopIgnore(void) +{ + if(Mock.vkResetCommandPool_IgnoreBool) + Mock.vkResetCommandPool_CallInstance = CMock_Guts_MemNext(Mock.vkResetCommandPool_CallInstance); + Mock.vkResetCommandPool_IgnoreBool = (char)0; +} + +void vkResetCommandPool_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkResetCommandPool_CALL_INSTANCE)); + CMOCK_vkResetCommandPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetCommandPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkResetCommandPool_CallInstance = CMock_Guts_MemChain(Mock.vkResetCommandPool_CallInstance, cmock_guts_index); + Mock.vkResetCommandPool_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkResetCommandPool_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkResetCommandPool_CALL_INSTANCE)); + CMOCK_vkResetCommandPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetCommandPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkResetCommandPool_CallInstance = CMock_Guts_MemChain(Mock.vkResetCommandPool_CallInstance, cmock_guts_index); + Mock.vkResetCommandPool_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkResetCommandPool(cmock_call_instance, device, commandPool, flags); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkResetCommandPool_AddCallback(CMOCK_vkResetCommandPool_CALLBACK Callback) +{ + Mock.vkResetCommandPool_IgnoreBool = (char)0; + Mock.vkResetCommandPool_CallbackBool = (char)1; + Mock.vkResetCommandPool_CallbackFunctionPointer = Callback; +} + +void vkResetCommandPool_Stub(CMOCK_vkResetCommandPool_CALLBACK Callback) +{ + Mock.vkResetCommandPool_IgnoreBool = (char)0; + Mock.vkResetCommandPool_CallbackBool = (char)0; + Mock.vkResetCommandPool_CallbackFunctionPointer = Callback; +} + +void vkResetCommandPool_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkResetCommandPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetCommandPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkResetCommandPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkResetCommandPool_CMockIgnoreArg_commandPool(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkResetCommandPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetCommandPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkResetCommandPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandPool = 1; +} + +void vkResetCommandPool_CMockIgnoreArg_flags(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkResetCommandPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetCommandPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkResetCommandPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_flags = 1; +} + +VkResult vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkAllocateCommandBuffers_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkAllocateCommandBuffers); + cmock_call_instance = (CMOCK_vkAllocateCommandBuffers_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkAllocateCommandBuffers_CallInstance); + Mock.vkAllocateCommandBuffers_CallInstance = CMock_Guts_MemNext(Mock.vkAllocateCommandBuffers_CallInstance); + if (Mock.vkAllocateCommandBuffers_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkAllocateCommandBuffers_FinalReturn; + memcpy((void*)(&Mock.vkAllocateCommandBuffers_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkAllocateCommandBuffers_CallbackBool && + Mock.vkAllocateCommandBuffers_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkAllocateCommandBuffers_CallbackFunctionPointer(device, pAllocateInfo, pCommandBuffers, Mock.vkAllocateCommandBuffers_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkAllocateCommandBuffers,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocateInfo) + { + UNITY_SET_DETAILS(CMockString_vkAllocateCommandBuffers,CMockString_pAllocateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocateInfo), (void*)(pAllocateInfo), sizeof(const VkCommandBufferAllocateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCommandBuffers) + { + UNITY_SET_DETAILS(CMockString_vkAllocateCommandBuffers,CMockString_pCommandBuffers); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCommandBuffers), (void*)(pCommandBuffers), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkAllocateCommandBuffers_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkAllocateCommandBuffers_CallbackFunctionPointer(device, pAllocateInfo, pCommandBuffers, Mock.vkAllocateCommandBuffers_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pCommandBuffers_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pCommandBuffers, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pCommandBuffers, (const void*)cmock_call_instance->ReturnThruPtr_pCommandBuffers_Val, + cmock_call_instance->ReturnThruPtr_pCommandBuffers_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkAllocateCommandBuffers(CMOCK_vkAllocateCommandBuffers_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); +void CMockExpectParameters_vkAllocateCommandBuffers(CMOCK_vkAllocateCommandBuffers_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pAllocateInfo = pAllocateInfo; + cmock_call_instance->IgnoreArg_pAllocateInfo = 0; + cmock_call_instance->Expected_pCommandBuffers = pCommandBuffers; + cmock_call_instance->IgnoreArg_pCommandBuffers = 0; + cmock_call_instance->ReturnThruPtr_pCommandBuffers_Used = 0; +} + +void vkAllocateCommandBuffers_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkAllocateCommandBuffers_CALL_INSTANCE)); + CMOCK_vkAllocateCommandBuffers_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAllocateCommandBuffers_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkAllocateCommandBuffers_CallInstance = CMock_Guts_MemChain(Mock.vkAllocateCommandBuffers_CallInstance, cmock_guts_index); + Mock.vkAllocateCommandBuffers_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkAllocateCommandBuffers_IgnoreBool = (char)1; +} + +void vkAllocateCommandBuffers_CMockStopIgnore(void) +{ + if(Mock.vkAllocateCommandBuffers_IgnoreBool) + Mock.vkAllocateCommandBuffers_CallInstance = CMock_Guts_MemNext(Mock.vkAllocateCommandBuffers_CallInstance); + Mock.vkAllocateCommandBuffers_IgnoreBool = (char)0; +} + +void vkAllocateCommandBuffers_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkAllocateCommandBuffers_CALL_INSTANCE)); + CMOCK_vkAllocateCommandBuffers_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAllocateCommandBuffers_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkAllocateCommandBuffers_CallInstance = CMock_Guts_MemChain(Mock.vkAllocateCommandBuffers_CallInstance, cmock_guts_index); + Mock.vkAllocateCommandBuffers_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkAllocateCommandBuffers_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkAllocateCommandBuffers_CALL_INSTANCE)); + CMOCK_vkAllocateCommandBuffers_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAllocateCommandBuffers_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkAllocateCommandBuffers_CallInstance = CMock_Guts_MemChain(Mock.vkAllocateCommandBuffers_CallInstance, cmock_guts_index); + Mock.vkAllocateCommandBuffers_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkAllocateCommandBuffers(cmock_call_instance, device, pAllocateInfo, pCommandBuffers); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkAllocateCommandBuffers_AddCallback(CMOCK_vkAllocateCommandBuffers_CALLBACK Callback) +{ + Mock.vkAllocateCommandBuffers_IgnoreBool = (char)0; + Mock.vkAllocateCommandBuffers_CallbackBool = (char)1; + Mock.vkAllocateCommandBuffers_CallbackFunctionPointer = Callback; +} + +void vkAllocateCommandBuffers_Stub(CMOCK_vkAllocateCommandBuffers_CALLBACK Callback) +{ + Mock.vkAllocateCommandBuffers_IgnoreBool = (char)0; + Mock.vkAllocateCommandBuffers_CallbackBool = (char)0; + Mock.vkAllocateCommandBuffers_CallbackFunctionPointer = Callback; +} + +void vkAllocateCommandBuffers_CMockReturnMemThruPtr_pCommandBuffers(UNITY_LINE_TYPE cmock_line, VkCommandBuffer const* pCommandBuffers, size_t cmock_size) +{ + CMOCK_vkAllocateCommandBuffers_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAllocateCommandBuffers_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAllocateCommandBuffers_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pCommandBuffers_Used = 1; + cmock_call_instance->ReturnThruPtr_pCommandBuffers_Val = pCommandBuffers; + cmock_call_instance->ReturnThruPtr_pCommandBuffers_Size = cmock_size; +} + +void vkAllocateCommandBuffers_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkAllocateCommandBuffers_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAllocateCommandBuffers_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAllocateCommandBuffers_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkAllocateCommandBuffers_CMockIgnoreArg_pAllocateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkAllocateCommandBuffers_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAllocateCommandBuffers_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAllocateCommandBuffers_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocateInfo = 1; +} + +void vkAllocateCommandBuffers_CMockIgnoreArg_pCommandBuffers(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkAllocateCommandBuffers_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAllocateCommandBuffers_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAllocateCommandBuffers_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCommandBuffers = 1; +} + +void vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkFreeCommandBuffers_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkFreeCommandBuffers); + cmock_call_instance = (CMOCK_vkFreeCommandBuffers_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkFreeCommandBuffers_CallInstance); + Mock.vkFreeCommandBuffers_CallInstance = CMock_Guts_MemNext(Mock.vkFreeCommandBuffers_CallInstance); + if (Mock.vkFreeCommandBuffers_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkFreeCommandBuffers_CallbackBool && + Mock.vkFreeCommandBuffers_CallbackFunctionPointer != NULL) + { + Mock.vkFreeCommandBuffers_CallbackFunctionPointer(device, commandPool, commandBufferCount, pCommandBuffers, Mock.vkFreeCommandBuffers_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkFreeCommandBuffers,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_commandPool) + { + UNITY_SET_DETAILS(CMockString_vkFreeCommandBuffers,CMockString_commandPool); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandPool), (void*)(&commandPool), sizeof(VkCommandPool), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_commandBufferCount) + { + UNITY_SET_DETAILS(CMockString_vkFreeCommandBuffers,CMockString_commandBufferCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_commandBufferCount, commandBufferCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCommandBuffers) + { + UNITY_SET_DETAILS(CMockString_vkFreeCommandBuffers,CMockString_pCommandBuffers); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCommandBuffers), (void*)(pCommandBuffers), sizeof(const VkCommandBuffer), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkFreeCommandBuffers_CallbackFunctionPointer != NULL) + { + Mock.vkFreeCommandBuffers_CallbackFunctionPointer(device, commandPool, commandBufferCount, pCommandBuffers, Mock.vkFreeCommandBuffers_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkFreeCommandBuffers(CMOCK_vkFreeCommandBuffers_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); +void CMockExpectParameters_vkFreeCommandBuffers(CMOCK_vkFreeCommandBuffers_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_commandPool), (void*)(&commandPool), + sizeof(VkCommandPool[sizeof(commandPool) == sizeof(VkCommandPool) ? 1 : -1])); /* add VkCommandPool to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandPool = 0; + cmock_call_instance->Expected_commandBufferCount = commandBufferCount; + cmock_call_instance->IgnoreArg_commandBufferCount = 0; + cmock_call_instance->Expected_pCommandBuffers = pCommandBuffers; + cmock_call_instance->IgnoreArg_pCommandBuffers = 0; +} + +void vkFreeCommandBuffers_CMockIgnore(void) +{ + Mock.vkFreeCommandBuffers_IgnoreBool = (char)1; +} + +void vkFreeCommandBuffers_CMockStopIgnore(void) +{ + Mock.vkFreeCommandBuffers_IgnoreBool = (char)0; +} + +void vkFreeCommandBuffers_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkFreeCommandBuffers_CALL_INSTANCE)); + CMOCK_vkFreeCommandBuffers_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkFreeCommandBuffers_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkFreeCommandBuffers_CallInstance = CMock_Guts_MemChain(Mock.vkFreeCommandBuffers_CallInstance, cmock_guts_index); + Mock.vkFreeCommandBuffers_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkFreeCommandBuffers_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkFreeCommandBuffers_CALL_INSTANCE)); + CMOCK_vkFreeCommandBuffers_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkFreeCommandBuffers_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkFreeCommandBuffers_CallInstance = CMock_Guts_MemChain(Mock.vkFreeCommandBuffers_CallInstance, cmock_guts_index); + Mock.vkFreeCommandBuffers_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkFreeCommandBuffers(cmock_call_instance, device, commandPool, commandBufferCount, pCommandBuffers); +} + +void vkFreeCommandBuffers_AddCallback(CMOCK_vkFreeCommandBuffers_CALLBACK Callback) +{ + Mock.vkFreeCommandBuffers_IgnoreBool = (char)0; + Mock.vkFreeCommandBuffers_CallbackBool = (char)1; + Mock.vkFreeCommandBuffers_CallbackFunctionPointer = Callback; +} + +void vkFreeCommandBuffers_Stub(CMOCK_vkFreeCommandBuffers_CALLBACK Callback) +{ + Mock.vkFreeCommandBuffers_IgnoreBool = (char)0; + Mock.vkFreeCommandBuffers_CallbackBool = (char)0; + Mock.vkFreeCommandBuffers_CallbackFunctionPointer = Callback; +} + +void vkFreeCommandBuffers_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkFreeCommandBuffers_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkFreeCommandBuffers_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkFreeCommandBuffers_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkFreeCommandBuffers_CMockIgnoreArg_commandPool(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkFreeCommandBuffers_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkFreeCommandBuffers_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkFreeCommandBuffers_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandPool = 1; +} + +void vkFreeCommandBuffers_CMockIgnoreArg_commandBufferCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkFreeCommandBuffers_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkFreeCommandBuffers_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkFreeCommandBuffers_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBufferCount = 1; +} + +void vkFreeCommandBuffers_CMockIgnoreArg_pCommandBuffers(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkFreeCommandBuffers_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkFreeCommandBuffers_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkFreeCommandBuffers_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCommandBuffers = 1; +} + +VkResult vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkBeginCommandBuffer_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkBeginCommandBuffer); + cmock_call_instance = (CMOCK_vkBeginCommandBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkBeginCommandBuffer_CallInstance); + Mock.vkBeginCommandBuffer_CallInstance = CMock_Guts_MemNext(Mock.vkBeginCommandBuffer_CallInstance); + if (Mock.vkBeginCommandBuffer_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkBeginCommandBuffer_FinalReturn; + memcpy((void*)(&Mock.vkBeginCommandBuffer_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkBeginCommandBuffer_CallbackBool && + Mock.vkBeginCommandBuffer_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkBeginCommandBuffer_CallbackFunctionPointer(commandBuffer, pBeginInfo, Mock.vkBeginCommandBuffer_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkBeginCommandBuffer,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pBeginInfo) + { + UNITY_SET_DETAILS(CMockString_vkBeginCommandBuffer,CMockString_pBeginInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pBeginInfo), (void*)(pBeginInfo), sizeof(const VkCommandBufferBeginInfo), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkBeginCommandBuffer_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkBeginCommandBuffer_CallbackFunctionPointer(commandBuffer, pBeginInfo, Mock.vkBeginCommandBuffer_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkBeginCommandBuffer(CMOCK_vkBeginCommandBuffer_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo); +void CMockExpectParameters_vkBeginCommandBuffer(CMOCK_vkBeginCommandBuffer_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pBeginInfo = pBeginInfo; + cmock_call_instance->IgnoreArg_pBeginInfo = 0; +} + +void vkBeginCommandBuffer_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBeginCommandBuffer_CALL_INSTANCE)); + CMOCK_vkBeginCommandBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBeginCommandBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBeginCommandBuffer_CallInstance = CMock_Guts_MemChain(Mock.vkBeginCommandBuffer_CallInstance, cmock_guts_index); + Mock.vkBeginCommandBuffer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkBeginCommandBuffer_IgnoreBool = (char)1; +} + +void vkBeginCommandBuffer_CMockStopIgnore(void) +{ + if(Mock.vkBeginCommandBuffer_IgnoreBool) + Mock.vkBeginCommandBuffer_CallInstance = CMock_Guts_MemNext(Mock.vkBeginCommandBuffer_CallInstance); + Mock.vkBeginCommandBuffer_IgnoreBool = (char)0; +} + +void vkBeginCommandBuffer_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBeginCommandBuffer_CALL_INSTANCE)); + CMOCK_vkBeginCommandBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBeginCommandBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBeginCommandBuffer_CallInstance = CMock_Guts_MemChain(Mock.vkBeginCommandBuffer_CallInstance, cmock_guts_index); + Mock.vkBeginCommandBuffer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkBeginCommandBuffer_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBeginCommandBuffer_CALL_INSTANCE)); + CMOCK_vkBeginCommandBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBeginCommandBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBeginCommandBuffer_CallInstance = CMock_Guts_MemChain(Mock.vkBeginCommandBuffer_CallInstance, cmock_guts_index); + Mock.vkBeginCommandBuffer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkBeginCommandBuffer(cmock_call_instance, commandBuffer, pBeginInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkBeginCommandBuffer_AddCallback(CMOCK_vkBeginCommandBuffer_CALLBACK Callback) +{ + Mock.vkBeginCommandBuffer_IgnoreBool = (char)0; + Mock.vkBeginCommandBuffer_CallbackBool = (char)1; + Mock.vkBeginCommandBuffer_CallbackFunctionPointer = Callback; +} + +void vkBeginCommandBuffer_Stub(CMOCK_vkBeginCommandBuffer_CALLBACK Callback) +{ + Mock.vkBeginCommandBuffer_IgnoreBool = (char)0; + Mock.vkBeginCommandBuffer_CallbackBool = (char)0; + Mock.vkBeginCommandBuffer_CallbackFunctionPointer = Callback; +} + +void vkBeginCommandBuffer_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBeginCommandBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBeginCommandBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBeginCommandBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkBeginCommandBuffer_CMockIgnoreArg_pBeginInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBeginCommandBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBeginCommandBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBeginCommandBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pBeginInfo = 1; +} + +VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkEndCommandBuffer_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkEndCommandBuffer); + cmock_call_instance = (CMOCK_vkEndCommandBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkEndCommandBuffer_CallInstance); + Mock.vkEndCommandBuffer_CallInstance = CMock_Guts_MemNext(Mock.vkEndCommandBuffer_CallInstance); + if (Mock.vkEndCommandBuffer_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkEndCommandBuffer_FinalReturn; + memcpy((void*)(&Mock.vkEndCommandBuffer_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkEndCommandBuffer_CallbackBool && + Mock.vkEndCommandBuffer_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkEndCommandBuffer_CallbackFunctionPointer(commandBuffer, Mock.vkEndCommandBuffer_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkEndCommandBuffer,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkEndCommandBuffer_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkEndCommandBuffer_CallbackFunctionPointer(commandBuffer, Mock.vkEndCommandBuffer_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkEndCommandBuffer(CMOCK_vkEndCommandBuffer_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer); +void CMockExpectParameters_vkEndCommandBuffer(CMOCK_vkEndCommandBuffer_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; +} + +void vkEndCommandBuffer_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkEndCommandBuffer_CALL_INSTANCE)); + CMOCK_vkEndCommandBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEndCommandBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkEndCommandBuffer_CallInstance = CMock_Guts_MemChain(Mock.vkEndCommandBuffer_CallInstance, cmock_guts_index); + Mock.vkEndCommandBuffer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkEndCommandBuffer_IgnoreBool = (char)1; +} + +void vkEndCommandBuffer_CMockStopIgnore(void) +{ + if(Mock.vkEndCommandBuffer_IgnoreBool) + Mock.vkEndCommandBuffer_CallInstance = CMock_Guts_MemNext(Mock.vkEndCommandBuffer_CallInstance); + Mock.vkEndCommandBuffer_IgnoreBool = (char)0; +} + +void vkEndCommandBuffer_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkEndCommandBuffer_CALL_INSTANCE)); + CMOCK_vkEndCommandBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEndCommandBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkEndCommandBuffer_CallInstance = CMock_Guts_MemChain(Mock.vkEndCommandBuffer_CallInstance, cmock_guts_index); + Mock.vkEndCommandBuffer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkEndCommandBuffer_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkEndCommandBuffer_CALL_INSTANCE)); + CMOCK_vkEndCommandBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEndCommandBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkEndCommandBuffer_CallInstance = CMock_Guts_MemChain(Mock.vkEndCommandBuffer_CallInstance, cmock_guts_index); + Mock.vkEndCommandBuffer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkEndCommandBuffer(cmock_call_instance, commandBuffer); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkEndCommandBuffer_AddCallback(CMOCK_vkEndCommandBuffer_CALLBACK Callback) +{ + Mock.vkEndCommandBuffer_IgnoreBool = (char)0; + Mock.vkEndCommandBuffer_CallbackBool = (char)1; + Mock.vkEndCommandBuffer_CallbackFunctionPointer = Callback; +} + +void vkEndCommandBuffer_Stub(CMOCK_vkEndCommandBuffer_CALLBACK Callback) +{ + Mock.vkEndCommandBuffer_IgnoreBool = (char)0; + Mock.vkEndCommandBuffer_CallbackBool = (char)0; + Mock.vkEndCommandBuffer_CallbackFunctionPointer = Callback; +} + +void vkEndCommandBuffer_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkEndCommandBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEndCommandBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEndCommandBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkResetCommandBuffer_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkResetCommandBuffer); + cmock_call_instance = (CMOCK_vkResetCommandBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkResetCommandBuffer_CallInstance); + Mock.vkResetCommandBuffer_CallInstance = CMock_Guts_MemNext(Mock.vkResetCommandBuffer_CallInstance); + if (Mock.vkResetCommandBuffer_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkResetCommandBuffer_FinalReturn; + memcpy((void*)(&Mock.vkResetCommandBuffer_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkResetCommandBuffer_CallbackBool && + Mock.vkResetCommandBuffer_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkResetCommandBuffer_CallbackFunctionPointer(commandBuffer, flags, Mock.vkResetCommandBuffer_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkResetCommandBuffer,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_flags) + { + UNITY_SET_DETAILS(CMockString_vkResetCommandBuffer,CMockString_flags); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_flags), (void*)(&flags), sizeof(VkCommandBufferResetFlags), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkResetCommandBuffer_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkResetCommandBuffer_CallbackFunctionPointer(commandBuffer, flags, Mock.vkResetCommandBuffer_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkResetCommandBuffer(CMOCK_vkResetCommandBuffer_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags); +void CMockExpectParameters_vkResetCommandBuffer(CMOCK_vkResetCommandBuffer_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_flags), (void*)(&flags), + sizeof(VkCommandBufferResetFlags[sizeof(flags) == sizeof(VkCommandBufferResetFlags) ? 1 : -1])); /* add VkCommandBufferResetFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_flags = 0; +} + +void vkResetCommandBuffer_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkResetCommandBuffer_CALL_INSTANCE)); + CMOCK_vkResetCommandBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetCommandBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkResetCommandBuffer_CallInstance = CMock_Guts_MemChain(Mock.vkResetCommandBuffer_CallInstance, cmock_guts_index); + Mock.vkResetCommandBuffer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkResetCommandBuffer_IgnoreBool = (char)1; +} + +void vkResetCommandBuffer_CMockStopIgnore(void) +{ + if(Mock.vkResetCommandBuffer_IgnoreBool) + Mock.vkResetCommandBuffer_CallInstance = CMock_Guts_MemNext(Mock.vkResetCommandBuffer_CallInstance); + Mock.vkResetCommandBuffer_IgnoreBool = (char)0; +} + +void vkResetCommandBuffer_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkResetCommandBuffer_CALL_INSTANCE)); + CMOCK_vkResetCommandBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetCommandBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkResetCommandBuffer_CallInstance = CMock_Guts_MemChain(Mock.vkResetCommandBuffer_CallInstance, cmock_guts_index); + Mock.vkResetCommandBuffer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkResetCommandBuffer_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkResetCommandBuffer_CALL_INSTANCE)); + CMOCK_vkResetCommandBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetCommandBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkResetCommandBuffer_CallInstance = CMock_Guts_MemChain(Mock.vkResetCommandBuffer_CallInstance, cmock_guts_index); + Mock.vkResetCommandBuffer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkResetCommandBuffer(cmock_call_instance, commandBuffer, flags); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkResetCommandBuffer_AddCallback(CMOCK_vkResetCommandBuffer_CALLBACK Callback) +{ + Mock.vkResetCommandBuffer_IgnoreBool = (char)0; + Mock.vkResetCommandBuffer_CallbackBool = (char)1; + Mock.vkResetCommandBuffer_CallbackFunctionPointer = Callback; +} + +void vkResetCommandBuffer_Stub(CMOCK_vkResetCommandBuffer_CALLBACK Callback) +{ + Mock.vkResetCommandBuffer_IgnoreBool = (char)0; + Mock.vkResetCommandBuffer_CallbackBool = (char)0; + Mock.vkResetCommandBuffer_CallbackFunctionPointer = Callback; +} + +void vkResetCommandBuffer_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkResetCommandBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetCommandBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkResetCommandBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkResetCommandBuffer_CMockIgnoreArg_flags(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkResetCommandBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetCommandBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkResetCommandBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_flags = 1; +} + +void vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBindPipeline_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBindPipeline); + cmock_call_instance = (CMOCK_vkCmdBindPipeline_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBindPipeline_CallInstance); + Mock.vkCmdBindPipeline_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBindPipeline_CallInstance); + if (Mock.vkCmdBindPipeline_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBindPipeline_CallbackBool && + Mock.vkCmdBindPipeline_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBindPipeline_CallbackFunctionPointer(commandBuffer, pipelineBindPoint, pipeline, Mock.vkCmdBindPipeline_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindPipeline,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pipelineBindPoint) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindPipeline,CMockString_pipelineBindPoint); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_pipelineBindPoint), (void*)(&pipelineBindPoint), sizeof(VkPipelineBindPoint), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pipeline) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindPipeline,CMockString_pipeline); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_pipeline), (void*)(&pipeline), sizeof(VkPipeline), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdBindPipeline_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBindPipeline_CallbackFunctionPointer(commandBuffer, pipelineBindPoint, pipeline, Mock.vkCmdBindPipeline_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBindPipeline(CMOCK_vkCmdBindPipeline_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); +void CMockExpectParameters_vkCmdBindPipeline(CMOCK_vkCmdBindPipeline_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_pipelineBindPoint), (void*)(&pipelineBindPoint), + sizeof(VkPipelineBindPoint[sizeof(pipelineBindPoint) == sizeof(VkPipelineBindPoint) ? 1 : -1])); /* add VkPipelineBindPoint to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_pipelineBindPoint = 0; + memcpy((void*)(&cmock_call_instance->Expected_pipeline), (void*)(&pipeline), + sizeof(VkPipeline[sizeof(pipeline) == sizeof(VkPipeline) ? 1 : -1])); /* add VkPipeline to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_pipeline = 0; +} + +void vkCmdBindPipeline_CMockIgnore(void) +{ + Mock.vkCmdBindPipeline_IgnoreBool = (char)1; +} + +void vkCmdBindPipeline_CMockStopIgnore(void) +{ + Mock.vkCmdBindPipeline_IgnoreBool = (char)0; +} + +void vkCmdBindPipeline_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBindPipeline_CALL_INSTANCE)); + CMOCK_vkCmdBindPipeline_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindPipeline_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBindPipeline_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBindPipeline_CallInstance, cmock_guts_index); + Mock.vkCmdBindPipeline_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBindPipeline_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBindPipeline_CALL_INSTANCE)); + CMOCK_vkCmdBindPipeline_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindPipeline_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBindPipeline_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBindPipeline_CallInstance, cmock_guts_index); + Mock.vkCmdBindPipeline_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBindPipeline(cmock_call_instance, commandBuffer, pipelineBindPoint, pipeline); +} + +void vkCmdBindPipeline_AddCallback(CMOCK_vkCmdBindPipeline_CALLBACK Callback) +{ + Mock.vkCmdBindPipeline_IgnoreBool = (char)0; + Mock.vkCmdBindPipeline_CallbackBool = (char)1; + Mock.vkCmdBindPipeline_CallbackFunctionPointer = Callback; +} + +void vkCmdBindPipeline_Stub(CMOCK_vkCmdBindPipeline_CALLBACK Callback) +{ + Mock.vkCmdBindPipeline_IgnoreBool = (char)0; + Mock.vkCmdBindPipeline_CallbackBool = (char)0; + Mock.vkCmdBindPipeline_CallbackFunctionPointer = Callback; +} + +void vkCmdBindPipeline_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindPipeline_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindPipeline_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindPipeline_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBindPipeline_CMockIgnoreArg_pipelineBindPoint(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindPipeline_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindPipeline_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindPipeline_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pipelineBindPoint = 1; +} + +void vkCmdBindPipeline_CMockIgnoreArg_pipeline(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindPipeline_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindPipeline_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindPipeline_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pipeline = 1; +} + +void vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetViewport_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetViewport); + cmock_call_instance = (CMOCK_vkCmdSetViewport_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetViewport_CallInstance); + Mock.vkCmdSetViewport_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetViewport_CallInstance); + if (Mock.vkCmdSetViewport_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetViewport_CallbackBool && + Mock.vkCmdSetViewport_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetViewport_CallbackFunctionPointer(commandBuffer, firstViewport, viewportCount, pViewports, Mock.vkCmdSetViewport_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetViewport,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstViewport) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetViewport,CMockString_firstViewport); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstViewport, firstViewport, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_viewportCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetViewport,CMockString_viewportCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_viewportCount, viewportCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pViewports) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetViewport,CMockString_pViewports); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pViewports), (void*)(pViewports), sizeof(const VkViewport), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetViewport_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetViewport_CallbackFunctionPointer(commandBuffer, firstViewport, viewportCount, pViewports, Mock.vkCmdSetViewport_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetViewport(CMOCK_vkCmdSetViewport_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports); +void CMockExpectParameters_vkCmdSetViewport(CMOCK_vkCmdSetViewport_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_firstViewport = firstViewport; + cmock_call_instance->IgnoreArg_firstViewport = 0; + cmock_call_instance->Expected_viewportCount = viewportCount; + cmock_call_instance->IgnoreArg_viewportCount = 0; + cmock_call_instance->Expected_pViewports = pViewports; + cmock_call_instance->IgnoreArg_pViewports = 0; +} + +void vkCmdSetViewport_CMockIgnore(void) +{ + Mock.vkCmdSetViewport_IgnoreBool = (char)1; +} + +void vkCmdSetViewport_CMockStopIgnore(void) +{ + Mock.vkCmdSetViewport_IgnoreBool = (char)0; +} + +void vkCmdSetViewport_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetViewport_CALL_INSTANCE)); + CMOCK_vkCmdSetViewport_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewport_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetViewport_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetViewport_CallInstance, cmock_guts_index); + Mock.vkCmdSetViewport_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetViewport_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetViewport_CALL_INSTANCE)); + CMOCK_vkCmdSetViewport_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewport_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetViewport_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetViewport_CallInstance, cmock_guts_index); + Mock.vkCmdSetViewport_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetViewport(cmock_call_instance, commandBuffer, firstViewport, viewportCount, pViewports); +} + +void vkCmdSetViewport_AddCallback(CMOCK_vkCmdSetViewport_CALLBACK Callback) +{ + Mock.vkCmdSetViewport_IgnoreBool = (char)0; + Mock.vkCmdSetViewport_CallbackBool = (char)1; + Mock.vkCmdSetViewport_CallbackFunctionPointer = Callback; +} + +void vkCmdSetViewport_Stub(CMOCK_vkCmdSetViewport_CALLBACK Callback) +{ + Mock.vkCmdSetViewport_IgnoreBool = (char)0; + Mock.vkCmdSetViewport_CallbackBool = (char)0; + Mock.vkCmdSetViewport_CallbackFunctionPointer = Callback; +} + +void vkCmdSetViewport_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetViewport_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewport_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetViewport_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetViewport_CMockIgnoreArg_firstViewport(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetViewport_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewport_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetViewport_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstViewport = 1; +} + +void vkCmdSetViewport_CMockIgnoreArg_viewportCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetViewport_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewport_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetViewport_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_viewportCount = 1; +} + +void vkCmdSetViewport_CMockIgnoreArg_pViewports(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetViewport_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewport_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetViewport_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pViewports = 1; +} + +void vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetScissor_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetScissor); + cmock_call_instance = (CMOCK_vkCmdSetScissor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetScissor_CallInstance); + Mock.vkCmdSetScissor_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetScissor_CallInstance); + if (Mock.vkCmdSetScissor_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetScissor_CallbackBool && + Mock.vkCmdSetScissor_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetScissor_CallbackFunctionPointer(commandBuffer, firstScissor, scissorCount, pScissors, Mock.vkCmdSetScissor_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetScissor,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstScissor) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetScissor,CMockString_firstScissor); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstScissor, firstScissor, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_scissorCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetScissor,CMockString_scissorCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_scissorCount, scissorCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pScissors) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetScissor,CMockString_pScissors); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pScissors), (void*)(pScissors), sizeof(const VkRect2D), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetScissor_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetScissor_CallbackFunctionPointer(commandBuffer, firstScissor, scissorCount, pScissors, Mock.vkCmdSetScissor_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetScissor(CMOCK_vkCmdSetScissor_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors); +void CMockExpectParameters_vkCmdSetScissor(CMOCK_vkCmdSetScissor_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_firstScissor = firstScissor; + cmock_call_instance->IgnoreArg_firstScissor = 0; + cmock_call_instance->Expected_scissorCount = scissorCount; + cmock_call_instance->IgnoreArg_scissorCount = 0; + cmock_call_instance->Expected_pScissors = pScissors; + cmock_call_instance->IgnoreArg_pScissors = 0; +} + +void vkCmdSetScissor_CMockIgnore(void) +{ + Mock.vkCmdSetScissor_IgnoreBool = (char)1; +} + +void vkCmdSetScissor_CMockStopIgnore(void) +{ + Mock.vkCmdSetScissor_IgnoreBool = (char)0; +} + +void vkCmdSetScissor_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetScissor_CALL_INSTANCE)); + CMOCK_vkCmdSetScissor_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetScissor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetScissor_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetScissor_CallInstance, cmock_guts_index); + Mock.vkCmdSetScissor_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetScissor_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetScissor_CALL_INSTANCE)); + CMOCK_vkCmdSetScissor_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetScissor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetScissor_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetScissor_CallInstance, cmock_guts_index); + Mock.vkCmdSetScissor_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetScissor(cmock_call_instance, commandBuffer, firstScissor, scissorCount, pScissors); +} + +void vkCmdSetScissor_AddCallback(CMOCK_vkCmdSetScissor_CALLBACK Callback) +{ + Mock.vkCmdSetScissor_IgnoreBool = (char)0; + Mock.vkCmdSetScissor_CallbackBool = (char)1; + Mock.vkCmdSetScissor_CallbackFunctionPointer = Callback; +} + +void vkCmdSetScissor_Stub(CMOCK_vkCmdSetScissor_CALLBACK Callback) +{ + Mock.vkCmdSetScissor_IgnoreBool = (char)0; + Mock.vkCmdSetScissor_CallbackBool = (char)0; + Mock.vkCmdSetScissor_CallbackFunctionPointer = Callback; +} + +void vkCmdSetScissor_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetScissor_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetScissor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetScissor_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetScissor_CMockIgnoreArg_firstScissor(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetScissor_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetScissor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetScissor_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstScissor = 1; +} + +void vkCmdSetScissor_CMockIgnoreArg_scissorCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetScissor_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetScissor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetScissor_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_scissorCount = 1; +} + +void vkCmdSetScissor_CMockIgnoreArg_pScissors(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetScissor_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetScissor_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetScissor_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pScissors = 1; +} + +void vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetLineWidth_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetLineWidth); + cmock_call_instance = (CMOCK_vkCmdSetLineWidth_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetLineWidth_CallInstance); + Mock.vkCmdSetLineWidth_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetLineWidth_CallInstance); + if (Mock.vkCmdSetLineWidth_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetLineWidth_CallbackBool && + Mock.vkCmdSetLineWidth_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetLineWidth_CallbackFunctionPointer(commandBuffer, lineWidth, Mock.vkCmdSetLineWidth_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetLineWidth,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_lineWidth) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetLineWidth,CMockString_lineWidth); + UNITY_TEST_ASSERT_EQUAL_FLOAT(cmock_call_instance->Expected_lineWidth, lineWidth, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetLineWidth_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetLineWidth_CallbackFunctionPointer(commandBuffer, lineWidth, Mock.vkCmdSetLineWidth_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetLineWidth(CMOCK_vkCmdSetLineWidth_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, float lineWidth); +void CMockExpectParameters_vkCmdSetLineWidth(CMOCK_vkCmdSetLineWidth_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, float lineWidth) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_lineWidth = lineWidth; + cmock_call_instance->IgnoreArg_lineWidth = 0; +} + +void vkCmdSetLineWidth_CMockIgnore(void) +{ + Mock.vkCmdSetLineWidth_IgnoreBool = (char)1; +} + +void vkCmdSetLineWidth_CMockStopIgnore(void) +{ + Mock.vkCmdSetLineWidth_IgnoreBool = (char)0; +} + +void vkCmdSetLineWidth_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetLineWidth_CALL_INSTANCE)); + CMOCK_vkCmdSetLineWidth_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetLineWidth_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetLineWidth_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetLineWidth_CallInstance, cmock_guts_index); + Mock.vkCmdSetLineWidth_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetLineWidth_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, float lineWidth) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetLineWidth_CALL_INSTANCE)); + CMOCK_vkCmdSetLineWidth_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetLineWidth_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetLineWidth_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetLineWidth_CallInstance, cmock_guts_index); + Mock.vkCmdSetLineWidth_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetLineWidth(cmock_call_instance, commandBuffer, lineWidth); +} + +void vkCmdSetLineWidth_AddCallback(CMOCK_vkCmdSetLineWidth_CALLBACK Callback) +{ + Mock.vkCmdSetLineWidth_IgnoreBool = (char)0; + Mock.vkCmdSetLineWidth_CallbackBool = (char)1; + Mock.vkCmdSetLineWidth_CallbackFunctionPointer = Callback; +} + +void vkCmdSetLineWidth_Stub(CMOCK_vkCmdSetLineWidth_CALLBACK Callback) +{ + Mock.vkCmdSetLineWidth_IgnoreBool = (char)0; + Mock.vkCmdSetLineWidth_CallbackBool = (char)0; + Mock.vkCmdSetLineWidth_CallbackFunctionPointer = Callback; +} + +void vkCmdSetLineWidth_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetLineWidth_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetLineWidth_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetLineWidth_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetLineWidth_CMockIgnoreArg_lineWidth(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetLineWidth_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetLineWidth_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetLineWidth_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_lineWidth = 1; +} + +void vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetDepthBias_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetDepthBias); + cmock_call_instance = (CMOCK_vkCmdSetDepthBias_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetDepthBias_CallInstance); + Mock.vkCmdSetDepthBias_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetDepthBias_CallInstance); + if (Mock.vkCmdSetDepthBias_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetDepthBias_CallbackBool && + Mock.vkCmdSetDepthBias_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDepthBias_CallbackFunctionPointer(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor, Mock.vkCmdSetDepthBias_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthBias,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_depthBiasConstantFactor) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthBias,CMockString_depthBiasConstantFactor); + UNITY_TEST_ASSERT_EQUAL_FLOAT(cmock_call_instance->Expected_depthBiasConstantFactor, depthBiasConstantFactor, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_depthBiasClamp) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthBias,CMockString_depthBiasClamp); + UNITY_TEST_ASSERT_EQUAL_FLOAT(cmock_call_instance->Expected_depthBiasClamp, depthBiasClamp, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_depthBiasSlopeFactor) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthBias,CMockString_depthBiasSlopeFactor); + UNITY_TEST_ASSERT_EQUAL_FLOAT(cmock_call_instance->Expected_depthBiasSlopeFactor, depthBiasSlopeFactor, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetDepthBias_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDepthBias_CallbackFunctionPointer(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor, Mock.vkCmdSetDepthBias_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetDepthBias(CMOCK_vkCmdSetDepthBias_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor); +void CMockExpectParameters_vkCmdSetDepthBias(CMOCK_vkCmdSetDepthBias_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_depthBiasConstantFactor = depthBiasConstantFactor; + cmock_call_instance->IgnoreArg_depthBiasConstantFactor = 0; + cmock_call_instance->Expected_depthBiasClamp = depthBiasClamp; + cmock_call_instance->IgnoreArg_depthBiasClamp = 0; + cmock_call_instance->Expected_depthBiasSlopeFactor = depthBiasSlopeFactor; + cmock_call_instance->IgnoreArg_depthBiasSlopeFactor = 0; +} + +void vkCmdSetDepthBias_CMockIgnore(void) +{ + Mock.vkCmdSetDepthBias_IgnoreBool = (char)1; +} + +void vkCmdSetDepthBias_CMockStopIgnore(void) +{ + Mock.vkCmdSetDepthBias_IgnoreBool = (char)0; +} + +void vkCmdSetDepthBias_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDepthBias_CALL_INSTANCE)); + CMOCK_vkCmdSetDepthBias_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthBias_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDepthBias_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDepthBias_CallInstance, cmock_guts_index); + Mock.vkCmdSetDepthBias_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetDepthBias_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDepthBias_CALL_INSTANCE)); + CMOCK_vkCmdSetDepthBias_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthBias_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDepthBias_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDepthBias_CallInstance, cmock_guts_index); + Mock.vkCmdSetDepthBias_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetDepthBias(cmock_call_instance, commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); +} + +void vkCmdSetDepthBias_AddCallback(CMOCK_vkCmdSetDepthBias_CALLBACK Callback) +{ + Mock.vkCmdSetDepthBias_IgnoreBool = (char)0; + Mock.vkCmdSetDepthBias_CallbackBool = (char)1; + Mock.vkCmdSetDepthBias_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDepthBias_Stub(CMOCK_vkCmdSetDepthBias_CALLBACK Callback) +{ + Mock.vkCmdSetDepthBias_IgnoreBool = (char)0; + Mock.vkCmdSetDepthBias_CallbackBool = (char)0; + Mock.vkCmdSetDepthBias_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDepthBias_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthBias_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthBias_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthBias_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetDepthBias_CMockIgnoreArg_depthBiasConstantFactor(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthBias_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthBias_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthBias_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_depthBiasConstantFactor = 1; +} + +void vkCmdSetDepthBias_CMockIgnoreArg_depthBiasClamp(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthBias_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthBias_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthBias_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_depthBiasClamp = 1; +} + +void vkCmdSetDepthBias_CMockIgnoreArg_depthBiasSlopeFactor(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthBias_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthBias_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthBias_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_depthBiasSlopeFactor = 1; +} + +void vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetBlendConstants_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetBlendConstants); + cmock_call_instance = (CMOCK_vkCmdSetBlendConstants_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetBlendConstants_CallInstance); + Mock.vkCmdSetBlendConstants_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetBlendConstants_CallInstance); + if (Mock.vkCmdSetBlendConstants_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetBlendConstants_CallbackBool && + Mock.vkCmdSetBlendConstants_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetBlendConstants_CallbackFunctionPointer(commandBuffer, blendConstants, Mock.vkCmdSetBlendConstants_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetBlendConstants,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_blendConstants) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetBlendConstants,CMockString_blendConstants); + if (cmock_call_instance->Expected_blendConstants == NULL) + { UNITY_TEST_ASSERT_NULL(blendConstants, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(cmock_call_instance->Expected_blendConstants, blendConstants, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkCmdSetBlendConstants_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetBlendConstants_CallbackFunctionPointer(commandBuffer, blendConstants, Mock.vkCmdSetBlendConstants_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetBlendConstants(CMOCK_vkCmdSetBlendConstants_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const float* blendConstants); +void CMockExpectParameters_vkCmdSetBlendConstants(CMOCK_vkCmdSetBlendConstants_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const float* blendConstants) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_blendConstants = blendConstants; + cmock_call_instance->IgnoreArg_blendConstants = 0; +} + +void vkCmdSetBlendConstants_CMockIgnore(void) +{ + Mock.vkCmdSetBlendConstants_IgnoreBool = (char)1; +} + +void vkCmdSetBlendConstants_CMockStopIgnore(void) +{ + Mock.vkCmdSetBlendConstants_IgnoreBool = (char)0; +} + +void vkCmdSetBlendConstants_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetBlendConstants_CALL_INSTANCE)); + CMOCK_vkCmdSetBlendConstants_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetBlendConstants_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetBlendConstants_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetBlendConstants_CallInstance, cmock_guts_index); + Mock.vkCmdSetBlendConstants_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetBlendConstants_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const float* blendConstants) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetBlendConstants_CALL_INSTANCE)); + CMOCK_vkCmdSetBlendConstants_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetBlendConstants_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetBlendConstants_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetBlendConstants_CallInstance, cmock_guts_index); + Mock.vkCmdSetBlendConstants_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetBlendConstants(cmock_call_instance, commandBuffer, blendConstants); +} + +void vkCmdSetBlendConstants_AddCallback(CMOCK_vkCmdSetBlendConstants_CALLBACK Callback) +{ + Mock.vkCmdSetBlendConstants_IgnoreBool = (char)0; + Mock.vkCmdSetBlendConstants_CallbackBool = (char)1; + Mock.vkCmdSetBlendConstants_CallbackFunctionPointer = Callback; +} + +void vkCmdSetBlendConstants_Stub(CMOCK_vkCmdSetBlendConstants_CALLBACK Callback) +{ + Mock.vkCmdSetBlendConstants_IgnoreBool = (char)0; + Mock.vkCmdSetBlendConstants_CallbackBool = (char)0; + Mock.vkCmdSetBlendConstants_CallbackFunctionPointer = Callback; +} + +void vkCmdSetBlendConstants_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetBlendConstants_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetBlendConstants_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetBlendConstants_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetBlendConstants_CMockIgnoreArg_blendConstants(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetBlendConstants_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetBlendConstants_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetBlendConstants_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_blendConstants = 1; +} + +void vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetDepthBounds_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetDepthBounds); + cmock_call_instance = (CMOCK_vkCmdSetDepthBounds_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetDepthBounds_CallInstance); + Mock.vkCmdSetDepthBounds_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetDepthBounds_CallInstance); + if (Mock.vkCmdSetDepthBounds_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetDepthBounds_CallbackBool && + Mock.vkCmdSetDepthBounds_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDepthBounds_CallbackFunctionPointer(commandBuffer, minDepthBounds, maxDepthBounds, Mock.vkCmdSetDepthBounds_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthBounds,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_minDepthBounds) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthBounds,CMockString_minDepthBounds); + UNITY_TEST_ASSERT_EQUAL_FLOAT(cmock_call_instance->Expected_minDepthBounds, minDepthBounds, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_maxDepthBounds) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthBounds,CMockString_maxDepthBounds); + UNITY_TEST_ASSERT_EQUAL_FLOAT(cmock_call_instance->Expected_maxDepthBounds, maxDepthBounds, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetDepthBounds_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDepthBounds_CallbackFunctionPointer(commandBuffer, minDepthBounds, maxDepthBounds, Mock.vkCmdSetDepthBounds_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetDepthBounds(CMOCK_vkCmdSetDepthBounds_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds); +void CMockExpectParameters_vkCmdSetDepthBounds(CMOCK_vkCmdSetDepthBounds_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_minDepthBounds = minDepthBounds; + cmock_call_instance->IgnoreArg_minDepthBounds = 0; + cmock_call_instance->Expected_maxDepthBounds = maxDepthBounds; + cmock_call_instance->IgnoreArg_maxDepthBounds = 0; +} + +void vkCmdSetDepthBounds_CMockIgnore(void) +{ + Mock.vkCmdSetDepthBounds_IgnoreBool = (char)1; +} + +void vkCmdSetDepthBounds_CMockStopIgnore(void) +{ + Mock.vkCmdSetDepthBounds_IgnoreBool = (char)0; +} + +void vkCmdSetDepthBounds_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDepthBounds_CALL_INSTANCE)); + CMOCK_vkCmdSetDepthBounds_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthBounds_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDepthBounds_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDepthBounds_CallInstance, cmock_guts_index); + Mock.vkCmdSetDepthBounds_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetDepthBounds_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDepthBounds_CALL_INSTANCE)); + CMOCK_vkCmdSetDepthBounds_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthBounds_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDepthBounds_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDepthBounds_CallInstance, cmock_guts_index); + Mock.vkCmdSetDepthBounds_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetDepthBounds(cmock_call_instance, commandBuffer, minDepthBounds, maxDepthBounds); +} + +void vkCmdSetDepthBounds_AddCallback(CMOCK_vkCmdSetDepthBounds_CALLBACK Callback) +{ + Mock.vkCmdSetDepthBounds_IgnoreBool = (char)0; + Mock.vkCmdSetDepthBounds_CallbackBool = (char)1; + Mock.vkCmdSetDepthBounds_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDepthBounds_Stub(CMOCK_vkCmdSetDepthBounds_CALLBACK Callback) +{ + Mock.vkCmdSetDepthBounds_IgnoreBool = (char)0; + Mock.vkCmdSetDepthBounds_CallbackBool = (char)0; + Mock.vkCmdSetDepthBounds_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDepthBounds_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthBounds_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthBounds_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthBounds_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetDepthBounds_CMockIgnoreArg_minDepthBounds(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthBounds_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthBounds_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthBounds_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_minDepthBounds = 1; +} + +void vkCmdSetDepthBounds_CMockIgnoreArg_maxDepthBounds(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthBounds_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthBounds_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthBounds_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_maxDepthBounds = 1; +} + +void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetStencilCompareMask_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetStencilCompareMask); + cmock_call_instance = (CMOCK_vkCmdSetStencilCompareMask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetStencilCompareMask_CallInstance); + Mock.vkCmdSetStencilCompareMask_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetStencilCompareMask_CallInstance); + if (Mock.vkCmdSetStencilCompareMask_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetStencilCompareMask_CallbackBool && + Mock.vkCmdSetStencilCompareMask_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetStencilCompareMask_CallbackFunctionPointer(commandBuffer, faceMask, compareMask, Mock.vkCmdSetStencilCompareMask_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetStencilCompareMask,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_faceMask) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetStencilCompareMask,CMockString_faceMask); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_faceMask), (void*)(&faceMask), sizeof(VkStencilFaceFlags), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_compareMask) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetStencilCompareMask,CMockString_compareMask); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_compareMask, compareMask, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetStencilCompareMask_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetStencilCompareMask_CallbackFunctionPointer(commandBuffer, faceMask, compareMask, Mock.vkCmdSetStencilCompareMask_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetStencilCompareMask(CMOCK_vkCmdSetStencilCompareMask_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask); +void CMockExpectParameters_vkCmdSetStencilCompareMask(CMOCK_vkCmdSetStencilCompareMask_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_faceMask), (void*)(&faceMask), + sizeof(VkStencilFaceFlags[sizeof(faceMask) == sizeof(VkStencilFaceFlags) ? 1 : -1])); /* add VkStencilFaceFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_faceMask = 0; + cmock_call_instance->Expected_compareMask = compareMask; + cmock_call_instance->IgnoreArg_compareMask = 0; +} + +void vkCmdSetStencilCompareMask_CMockIgnore(void) +{ + Mock.vkCmdSetStencilCompareMask_IgnoreBool = (char)1; +} + +void vkCmdSetStencilCompareMask_CMockStopIgnore(void) +{ + Mock.vkCmdSetStencilCompareMask_IgnoreBool = (char)0; +} + +void vkCmdSetStencilCompareMask_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetStencilCompareMask_CALL_INSTANCE)); + CMOCK_vkCmdSetStencilCompareMask_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilCompareMask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetStencilCompareMask_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetStencilCompareMask_CallInstance, cmock_guts_index); + Mock.vkCmdSetStencilCompareMask_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetStencilCompareMask_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetStencilCompareMask_CALL_INSTANCE)); + CMOCK_vkCmdSetStencilCompareMask_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilCompareMask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetStencilCompareMask_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetStencilCompareMask_CallInstance, cmock_guts_index); + Mock.vkCmdSetStencilCompareMask_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetStencilCompareMask(cmock_call_instance, commandBuffer, faceMask, compareMask); +} + +void vkCmdSetStencilCompareMask_AddCallback(CMOCK_vkCmdSetStencilCompareMask_CALLBACK Callback) +{ + Mock.vkCmdSetStencilCompareMask_IgnoreBool = (char)0; + Mock.vkCmdSetStencilCompareMask_CallbackBool = (char)1; + Mock.vkCmdSetStencilCompareMask_CallbackFunctionPointer = Callback; +} + +void vkCmdSetStencilCompareMask_Stub(CMOCK_vkCmdSetStencilCompareMask_CALLBACK Callback) +{ + Mock.vkCmdSetStencilCompareMask_IgnoreBool = (char)0; + Mock.vkCmdSetStencilCompareMask_CallbackBool = (char)0; + Mock.vkCmdSetStencilCompareMask_CallbackFunctionPointer = Callback; +} + +void vkCmdSetStencilCompareMask_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetStencilCompareMask_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilCompareMask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetStencilCompareMask_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetStencilCompareMask_CMockIgnoreArg_faceMask(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetStencilCompareMask_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilCompareMask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetStencilCompareMask_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_faceMask = 1; +} + +void vkCmdSetStencilCompareMask_CMockIgnoreArg_compareMask(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetStencilCompareMask_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilCompareMask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetStencilCompareMask_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_compareMask = 1; +} + +void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetStencilWriteMask_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetStencilWriteMask); + cmock_call_instance = (CMOCK_vkCmdSetStencilWriteMask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetStencilWriteMask_CallInstance); + Mock.vkCmdSetStencilWriteMask_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetStencilWriteMask_CallInstance); + if (Mock.vkCmdSetStencilWriteMask_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetStencilWriteMask_CallbackBool && + Mock.vkCmdSetStencilWriteMask_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetStencilWriteMask_CallbackFunctionPointer(commandBuffer, faceMask, writeMask, Mock.vkCmdSetStencilWriteMask_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetStencilWriteMask,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_faceMask) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetStencilWriteMask,CMockString_faceMask); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_faceMask), (void*)(&faceMask), sizeof(VkStencilFaceFlags), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_writeMask) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetStencilWriteMask,CMockString_writeMask); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_writeMask, writeMask, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetStencilWriteMask_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetStencilWriteMask_CallbackFunctionPointer(commandBuffer, faceMask, writeMask, Mock.vkCmdSetStencilWriteMask_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetStencilWriteMask(CMOCK_vkCmdSetStencilWriteMask_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask); +void CMockExpectParameters_vkCmdSetStencilWriteMask(CMOCK_vkCmdSetStencilWriteMask_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_faceMask), (void*)(&faceMask), + sizeof(VkStencilFaceFlags[sizeof(faceMask) == sizeof(VkStencilFaceFlags) ? 1 : -1])); /* add VkStencilFaceFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_faceMask = 0; + cmock_call_instance->Expected_writeMask = writeMask; + cmock_call_instance->IgnoreArg_writeMask = 0; +} + +void vkCmdSetStencilWriteMask_CMockIgnore(void) +{ + Mock.vkCmdSetStencilWriteMask_IgnoreBool = (char)1; +} + +void vkCmdSetStencilWriteMask_CMockStopIgnore(void) +{ + Mock.vkCmdSetStencilWriteMask_IgnoreBool = (char)0; +} + +void vkCmdSetStencilWriteMask_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetStencilWriteMask_CALL_INSTANCE)); + CMOCK_vkCmdSetStencilWriteMask_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilWriteMask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetStencilWriteMask_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetStencilWriteMask_CallInstance, cmock_guts_index); + Mock.vkCmdSetStencilWriteMask_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetStencilWriteMask_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetStencilWriteMask_CALL_INSTANCE)); + CMOCK_vkCmdSetStencilWriteMask_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilWriteMask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetStencilWriteMask_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetStencilWriteMask_CallInstance, cmock_guts_index); + Mock.vkCmdSetStencilWriteMask_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetStencilWriteMask(cmock_call_instance, commandBuffer, faceMask, writeMask); +} + +void vkCmdSetStencilWriteMask_AddCallback(CMOCK_vkCmdSetStencilWriteMask_CALLBACK Callback) +{ + Mock.vkCmdSetStencilWriteMask_IgnoreBool = (char)0; + Mock.vkCmdSetStencilWriteMask_CallbackBool = (char)1; + Mock.vkCmdSetStencilWriteMask_CallbackFunctionPointer = Callback; +} + +void vkCmdSetStencilWriteMask_Stub(CMOCK_vkCmdSetStencilWriteMask_CALLBACK Callback) +{ + Mock.vkCmdSetStencilWriteMask_IgnoreBool = (char)0; + Mock.vkCmdSetStencilWriteMask_CallbackBool = (char)0; + Mock.vkCmdSetStencilWriteMask_CallbackFunctionPointer = Callback; +} + +void vkCmdSetStencilWriteMask_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetStencilWriteMask_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilWriteMask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetStencilWriteMask_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetStencilWriteMask_CMockIgnoreArg_faceMask(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetStencilWriteMask_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilWriteMask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetStencilWriteMask_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_faceMask = 1; +} + +void vkCmdSetStencilWriteMask_CMockIgnoreArg_writeMask(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetStencilWriteMask_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilWriteMask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetStencilWriteMask_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_writeMask = 1; +} + +void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetStencilReference_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetStencilReference); + cmock_call_instance = (CMOCK_vkCmdSetStencilReference_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetStencilReference_CallInstance); + Mock.vkCmdSetStencilReference_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetStencilReference_CallInstance); + if (Mock.vkCmdSetStencilReference_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetStencilReference_CallbackBool && + Mock.vkCmdSetStencilReference_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetStencilReference_CallbackFunctionPointer(commandBuffer, faceMask, reference, Mock.vkCmdSetStencilReference_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetStencilReference,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_faceMask) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetStencilReference,CMockString_faceMask); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_faceMask), (void*)(&faceMask), sizeof(VkStencilFaceFlags), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_reference) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetStencilReference,CMockString_reference); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_reference, reference, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetStencilReference_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetStencilReference_CallbackFunctionPointer(commandBuffer, faceMask, reference, Mock.vkCmdSetStencilReference_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetStencilReference(CMOCK_vkCmdSetStencilReference_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference); +void CMockExpectParameters_vkCmdSetStencilReference(CMOCK_vkCmdSetStencilReference_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_faceMask), (void*)(&faceMask), + sizeof(VkStencilFaceFlags[sizeof(faceMask) == sizeof(VkStencilFaceFlags) ? 1 : -1])); /* add VkStencilFaceFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_faceMask = 0; + cmock_call_instance->Expected_reference = reference; + cmock_call_instance->IgnoreArg_reference = 0; +} + +void vkCmdSetStencilReference_CMockIgnore(void) +{ + Mock.vkCmdSetStencilReference_IgnoreBool = (char)1; +} + +void vkCmdSetStencilReference_CMockStopIgnore(void) +{ + Mock.vkCmdSetStencilReference_IgnoreBool = (char)0; +} + +void vkCmdSetStencilReference_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetStencilReference_CALL_INSTANCE)); + CMOCK_vkCmdSetStencilReference_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilReference_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetStencilReference_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetStencilReference_CallInstance, cmock_guts_index); + Mock.vkCmdSetStencilReference_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetStencilReference_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetStencilReference_CALL_INSTANCE)); + CMOCK_vkCmdSetStencilReference_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilReference_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetStencilReference_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetStencilReference_CallInstance, cmock_guts_index); + Mock.vkCmdSetStencilReference_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetStencilReference(cmock_call_instance, commandBuffer, faceMask, reference); +} + +void vkCmdSetStencilReference_AddCallback(CMOCK_vkCmdSetStencilReference_CALLBACK Callback) +{ + Mock.vkCmdSetStencilReference_IgnoreBool = (char)0; + Mock.vkCmdSetStencilReference_CallbackBool = (char)1; + Mock.vkCmdSetStencilReference_CallbackFunctionPointer = Callback; +} + +void vkCmdSetStencilReference_Stub(CMOCK_vkCmdSetStencilReference_CALLBACK Callback) +{ + Mock.vkCmdSetStencilReference_IgnoreBool = (char)0; + Mock.vkCmdSetStencilReference_CallbackBool = (char)0; + Mock.vkCmdSetStencilReference_CallbackFunctionPointer = Callback; +} + +void vkCmdSetStencilReference_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetStencilReference_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilReference_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetStencilReference_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetStencilReference_CMockIgnoreArg_faceMask(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetStencilReference_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilReference_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetStencilReference_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_faceMask = 1; +} + +void vkCmdSetStencilReference_CMockIgnoreArg_reference(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetStencilReference_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilReference_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetStencilReference_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_reference = 1; +} + +void vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBindDescriptorSets_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBindDescriptorSets); + cmock_call_instance = (CMOCK_vkCmdBindDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBindDescriptorSets_CallInstance); + Mock.vkCmdBindDescriptorSets_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBindDescriptorSets_CallInstance); + if (Mock.vkCmdBindDescriptorSets_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBindDescriptorSets_CallbackBool && + Mock.vkCmdBindDescriptorSets_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBindDescriptorSets_CallbackFunctionPointer(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets, Mock.vkCmdBindDescriptorSets_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindDescriptorSets,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pipelineBindPoint) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindDescriptorSets,CMockString_pipelineBindPoint); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_pipelineBindPoint), (void*)(&pipelineBindPoint), sizeof(VkPipelineBindPoint), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_layout) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindDescriptorSets,CMockString_layout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_layout), (void*)(&layout), sizeof(VkPipelineLayout), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstSet) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindDescriptorSets,CMockString_firstSet); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstSet, firstSet, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_descriptorSetCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindDescriptorSets,CMockString_descriptorSetCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_descriptorSetCount, descriptorSetCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDescriptorSets) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindDescriptorSets,CMockString_pDescriptorSets); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDescriptorSets), (void*)(pDescriptorSets), sizeof(const VkDescriptorSet), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dynamicOffsetCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindDescriptorSets,CMockString_dynamicOffsetCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_dynamicOffsetCount, dynamicOffsetCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDynamicOffsets) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindDescriptorSets,CMockString_pDynamicOffsets); + if (cmock_call_instance->Expected_pDynamicOffsets == NULL) + { UNITY_TEST_ASSERT_NULL(pDynamicOffsets, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pDynamicOffsets, pDynamicOffsets, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkCmdBindDescriptorSets_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBindDescriptorSets_CallbackFunctionPointer(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets, Mock.vkCmdBindDescriptorSets_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBindDescriptorSets(CMOCK_vkCmdBindDescriptorSets_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); +void CMockExpectParameters_vkCmdBindDescriptorSets(CMOCK_vkCmdBindDescriptorSets_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_pipelineBindPoint), (void*)(&pipelineBindPoint), + sizeof(VkPipelineBindPoint[sizeof(pipelineBindPoint) == sizeof(VkPipelineBindPoint) ? 1 : -1])); /* add VkPipelineBindPoint to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_pipelineBindPoint = 0; + memcpy((void*)(&cmock_call_instance->Expected_layout), (void*)(&layout), + sizeof(VkPipelineLayout[sizeof(layout) == sizeof(VkPipelineLayout) ? 1 : -1])); /* add VkPipelineLayout to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_layout = 0; + cmock_call_instance->Expected_firstSet = firstSet; + cmock_call_instance->IgnoreArg_firstSet = 0; + cmock_call_instance->Expected_descriptorSetCount = descriptorSetCount; + cmock_call_instance->IgnoreArg_descriptorSetCount = 0; + cmock_call_instance->Expected_pDescriptorSets = pDescriptorSets; + cmock_call_instance->IgnoreArg_pDescriptorSets = 0; + cmock_call_instance->Expected_dynamicOffsetCount = dynamicOffsetCount; + cmock_call_instance->IgnoreArg_dynamicOffsetCount = 0; + cmock_call_instance->Expected_pDynamicOffsets = pDynamicOffsets; + cmock_call_instance->IgnoreArg_pDynamicOffsets = 0; +} + +void vkCmdBindDescriptorSets_CMockIgnore(void) +{ + Mock.vkCmdBindDescriptorSets_IgnoreBool = (char)1; +} + +void vkCmdBindDescriptorSets_CMockStopIgnore(void) +{ + Mock.vkCmdBindDescriptorSets_IgnoreBool = (char)0; +} + +void vkCmdBindDescriptorSets_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBindDescriptorSets_CALL_INSTANCE)); + CMOCK_vkCmdBindDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBindDescriptorSets_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBindDescriptorSets_CallInstance, cmock_guts_index); + Mock.vkCmdBindDescriptorSets_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBindDescriptorSets_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBindDescriptorSets_CALL_INSTANCE)); + CMOCK_vkCmdBindDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBindDescriptorSets_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBindDescriptorSets_CallInstance, cmock_guts_index); + Mock.vkCmdBindDescriptorSets_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBindDescriptorSets(cmock_call_instance, commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); +} + +void vkCmdBindDescriptorSets_AddCallback(CMOCK_vkCmdBindDescriptorSets_CALLBACK Callback) +{ + Mock.vkCmdBindDescriptorSets_IgnoreBool = (char)0; + Mock.vkCmdBindDescriptorSets_CallbackBool = (char)1; + Mock.vkCmdBindDescriptorSets_CallbackFunctionPointer = Callback; +} + +void vkCmdBindDescriptorSets_Stub(CMOCK_vkCmdBindDescriptorSets_CALLBACK Callback) +{ + Mock.vkCmdBindDescriptorSets_IgnoreBool = (char)0; + Mock.vkCmdBindDescriptorSets_CallbackBool = (char)0; + Mock.vkCmdBindDescriptorSets_CallbackFunctionPointer = Callback; +} + +void vkCmdBindDescriptorSets_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindDescriptorSets_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBindDescriptorSets_CMockIgnoreArg_pipelineBindPoint(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindDescriptorSets_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pipelineBindPoint = 1; +} + +void vkCmdBindDescriptorSets_CMockIgnoreArg_layout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindDescriptorSets_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_layout = 1; +} + +void vkCmdBindDescriptorSets_CMockIgnoreArg_firstSet(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindDescriptorSets_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstSet = 1; +} + +void vkCmdBindDescriptorSets_CMockIgnoreArg_descriptorSetCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindDescriptorSets_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_descriptorSetCount = 1; +} + +void vkCmdBindDescriptorSets_CMockIgnoreArg_pDescriptorSets(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindDescriptorSets_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDescriptorSets = 1; +} + +void vkCmdBindDescriptorSets_CMockIgnoreArg_dynamicOffsetCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindDescriptorSets_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dynamicOffsetCount = 1; +} + +void vkCmdBindDescriptorSets_CMockIgnoreArg_pDynamicOffsets(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindDescriptorSets_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindDescriptorSets_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindDescriptorSets_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDynamicOffsets = 1; +} + +void vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBindIndexBuffer_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBindIndexBuffer); + cmock_call_instance = (CMOCK_vkCmdBindIndexBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBindIndexBuffer_CallInstance); + Mock.vkCmdBindIndexBuffer_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBindIndexBuffer_CallInstance); + if (Mock.vkCmdBindIndexBuffer_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBindIndexBuffer_CallbackBool && + Mock.vkCmdBindIndexBuffer_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBindIndexBuffer_CallbackFunctionPointer(commandBuffer, buffer, offset, indexType, Mock.vkCmdBindIndexBuffer_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindIndexBuffer,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_buffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindIndexBuffer,CMockString_buffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_offset) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindIndexBuffer,CMockString_offset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_indexType) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindIndexBuffer,CMockString_indexType); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_indexType), (void*)(&indexType), sizeof(VkIndexType), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdBindIndexBuffer_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBindIndexBuffer_CallbackFunctionPointer(commandBuffer, buffer, offset, indexType, Mock.vkCmdBindIndexBuffer_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBindIndexBuffer(CMOCK_vkCmdBindIndexBuffer_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); +void CMockExpectParameters_vkCmdBindIndexBuffer(CMOCK_vkCmdBindIndexBuffer_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), + sizeof(VkBuffer[sizeof(buffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_buffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), + sizeof(VkDeviceSize[sizeof(offset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_offset = 0; + memcpy((void*)(&cmock_call_instance->Expected_indexType), (void*)(&indexType), + sizeof(VkIndexType[sizeof(indexType) == sizeof(VkIndexType) ? 1 : -1])); /* add VkIndexType to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_indexType = 0; +} + +void vkCmdBindIndexBuffer_CMockIgnore(void) +{ + Mock.vkCmdBindIndexBuffer_IgnoreBool = (char)1; +} + +void vkCmdBindIndexBuffer_CMockStopIgnore(void) +{ + Mock.vkCmdBindIndexBuffer_IgnoreBool = (char)0; +} + +void vkCmdBindIndexBuffer_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBindIndexBuffer_CALL_INSTANCE)); + CMOCK_vkCmdBindIndexBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindIndexBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBindIndexBuffer_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBindIndexBuffer_CallInstance, cmock_guts_index); + Mock.vkCmdBindIndexBuffer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBindIndexBuffer_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBindIndexBuffer_CALL_INSTANCE)); + CMOCK_vkCmdBindIndexBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindIndexBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBindIndexBuffer_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBindIndexBuffer_CallInstance, cmock_guts_index); + Mock.vkCmdBindIndexBuffer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBindIndexBuffer(cmock_call_instance, commandBuffer, buffer, offset, indexType); +} + +void vkCmdBindIndexBuffer_AddCallback(CMOCK_vkCmdBindIndexBuffer_CALLBACK Callback) +{ + Mock.vkCmdBindIndexBuffer_IgnoreBool = (char)0; + Mock.vkCmdBindIndexBuffer_CallbackBool = (char)1; + Mock.vkCmdBindIndexBuffer_CallbackFunctionPointer = Callback; +} + +void vkCmdBindIndexBuffer_Stub(CMOCK_vkCmdBindIndexBuffer_CALLBACK Callback) +{ + Mock.vkCmdBindIndexBuffer_IgnoreBool = (char)0; + Mock.vkCmdBindIndexBuffer_CallbackBool = (char)0; + Mock.vkCmdBindIndexBuffer_CallbackFunctionPointer = Callback; +} + +void vkCmdBindIndexBuffer_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindIndexBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindIndexBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindIndexBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBindIndexBuffer_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindIndexBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindIndexBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindIndexBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_buffer = 1; +} + +void vkCmdBindIndexBuffer_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindIndexBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindIndexBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindIndexBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_offset = 1; +} + +void vkCmdBindIndexBuffer_CMockIgnoreArg_indexType(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindIndexBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindIndexBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindIndexBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_indexType = 1; +} + +void vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBindVertexBuffers_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBindVertexBuffers); + cmock_call_instance = (CMOCK_vkCmdBindVertexBuffers_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBindVertexBuffers_CallInstance); + Mock.vkCmdBindVertexBuffers_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBindVertexBuffers_CallInstance); + if (Mock.vkCmdBindVertexBuffers_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBindVertexBuffers_CallbackBool && + Mock.vkCmdBindVertexBuffers_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBindVertexBuffers_CallbackFunctionPointer(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, Mock.vkCmdBindVertexBuffers_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindVertexBuffers,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstBinding) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindVertexBuffers,CMockString_firstBinding); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstBinding, firstBinding, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_bindingCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindVertexBuffers,CMockString_bindingCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_bindingCount, bindingCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pBuffers) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindVertexBuffers,CMockString_pBuffers); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pBuffers), (void*)(pBuffers), sizeof(const VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pOffsets) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindVertexBuffers,CMockString_pOffsets); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pOffsets), (void*)(pOffsets), sizeof(const VkDeviceSize), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdBindVertexBuffers_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBindVertexBuffers_CallbackFunctionPointer(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, Mock.vkCmdBindVertexBuffers_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBindVertexBuffers(CMOCK_vkCmdBindVertexBuffers_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); +void CMockExpectParameters_vkCmdBindVertexBuffers(CMOCK_vkCmdBindVertexBuffers_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_firstBinding = firstBinding; + cmock_call_instance->IgnoreArg_firstBinding = 0; + cmock_call_instance->Expected_bindingCount = bindingCount; + cmock_call_instance->IgnoreArg_bindingCount = 0; + cmock_call_instance->Expected_pBuffers = pBuffers; + cmock_call_instance->IgnoreArg_pBuffers = 0; + cmock_call_instance->Expected_pOffsets = pOffsets; + cmock_call_instance->IgnoreArg_pOffsets = 0; +} + +void vkCmdBindVertexBuffers_CMockIgnore(void) +{ + Mock.vkCmdBindVertexBuffers_IgnoreBool = (char)1; +} + +void vkCmdBindVertexBuffers_CMockStopIgnore(void) +{ + Mock.vkCmdBindVertexBuffers_IgnoreBool = (char)0; +} + +void vkCmdBindVertexBuffers_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBindVertexBuffers_CALL_INSTANCE)); + CMOCK_vkCmdBindVertexBuffers_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindVertexBuffers_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBindVertexBuffers_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBindVertexBuffers_CallInstance, cmock_guts_index); + Mock.vkCmdBindVertexBuffers_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBindVertexBuffers_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBindVertexBuffers_CALL_INSTANCE)); + CMOCK_vkCmdBindVertexBuffers_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindVertexBuffers_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBindVertexBuffers_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBindVertexBuffers_CallInstance, cmock_guts_index); + Mock.vkCmdBindVertexBuffers_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBindVertexBuffers(cmock_call_instance, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); +} + +void vkCmdBindVertexBuffers_AddCallback(CMOCK_vkCmdBindVertexBuffers_CALLBACK Callback) +{ + Mock.vkCmdBindVertexBuffers_IgnoreBool = (char)0; + Mock.vkCmdBindVertexBuffers_CallbackBool = (char)1; + Mock.vkCmdBindVertexBuffers_CallbackFunctionPointer = Callback; +} + +void vkCmdBindVertexBuffers_Stub(CMOCK_vkCmdBindVertexBuffers_CALLBACK Callback) +{ + Mock.vkCmdBindVertexBuffers_IgnoreBool = (char)0; + Mock.vkCmdBindVertexBuffers_CallbackBool = (char)0; + Mock.vkCmdBindVertexBuffers_CallbackFunctionPointer = Callback; +} + +void vkCmdBindVertexBuffers_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindVertexBuffers_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindVertexBuffers_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindVertexBuffers_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBindVertexBuffers_CMockIgnoreArg_firstBinding(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindVertexBuffers_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindVertexBuffers_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindVertexBuffers_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstBinding = 1; +} + +void vkCmdBindVertexBuffers_CMockIgnoreArg_bindingCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindVertexBuffers_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindVertexBuffers_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindVertexBuffers_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_bindingCount = 1; +} + +void vkCmdBindVertexBuffers_CMockIgnoreArg_pBuffers(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindVertexBuffers_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindVertexBuffers_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindVertexBuffers_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pBuffers = 1; +} + +void vkCmdBindVertexBuffers_CMockIgnoreArg_pOffsets(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindVertexBuffers_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindVertexBuffers_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindVertexBuffers_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pOffsets = 1; +} + +void vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDraw_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDraw); + cmock_call_instance = (CMOCK_vkCmdDraw_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDraw_CallInstance); + Mock.vkCmdDraw_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDraw_CallInstance); + if (Mock.vkCmdDraw_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDraw_CallbackBool && + Mock.vkCmdDraw_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDraw_CallbackFunctionPointer(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance, Mock.vkCmdDraw_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDraw,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_vertexCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdDraw,CMockString_vertexCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_vertexCount, vertexCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_instanceCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdDraw,CMockString_instanceCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_instanceCount, instanceCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstVertex) + { + UNITY_SET_DETAILS(CMockString_vkCmdDraw,CMockString_firstVertex); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstVertex, firstVertex, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstInstance) + { + UNITY_SET_DETAILS(CMockString_vkCmdDraw,CMockString_firstInstance); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstInstance, firstInstance, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdDraw_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDraw_CallbackFunctionPointer(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance, Mock.vkCmdDraw_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDraw(CMOCK_vkCmdDraw_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); +void CMockExpectParameters_vkCmdDraw(CMOCK_vkCmdDraw_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_vertexCount = vertexCount; + cmock_call_instance->IgnoreArg_vertexCount = 0; + cmock_call_instance->Expected_instanceCount = instanceCount; + cmock_call_instance->IgnoreArg_instanceCount = 0; + cmock_call_instance->Expected_firstVertex = firstVertex; + cmock_call_instance->IgnoreArg_firstVertex = 0; + cmock_call_instance->Expected_firstInstance = firstInstance; + cmock_call_instance->IgnoreArg_firstInstance = 0; +} + +void vkCmdDraw_CMockIgnore(void) +{ + Mock.vkCmdDraw_IgnoreBool = (char)1; +} + +void vkCmdDraw_CMockStopIgnore(void) +{ + Mock.vkCmdDraw_IgnoreBool = (char)0; +} + +void vkCmdDraw_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDraw_CALL_INSTANCE)); + CMOCK_vkCmdDraw_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDraw_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDraw_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDraw_CallInstance, cmock_guts_index); + Mock.vkCmdDraw_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDraw_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDraw_CALL_INSTANCE)); + CMOCK_vkCmdDraw_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDraw_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDraw_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDraw_CallInstance, cmock_guts_index); + Mock.vkCmdDraw_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDraw(cmock_call_instance, commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); +} + +void vkCmdDraw_AddCallback(CMOCK_vkCmdDraw_CALLBACK Callback) +{ + Mock.vkCmdDraw_IgnoreBool = (char)0; + Mock.vkCmdDraw_CallbackBool = (char)1; + Mock.vkCmdDraw_CallbackFunctionPointer = Callback; +} + +void vkCmdDraw_Stub(CMOCK_vkCmdDraw_CALLBACK Callback) +{ + Mock.vkCmdDraw_IgnoreBool = (char)0; + Mock.vkCmdDraw_CallbackBool = (char)0; + Mock.vkCmdDraw_CallbackFunctionPointer = Callback; +} + +void vkCmdDraw_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDraw_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDraw_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDraw_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDraw_CMockIgnoreArg_vertexCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDraw_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDraw_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDraw_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_vertexCount = 1; +} + +void vkCmdDraw_CMockIgnoreArg_instanceCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDraw_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDraw_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDraw_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_instanceCount = 1; +} + +void vkCmdDraw_CMockIgnoreArg_firstVertex(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDraw_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDraw_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDraw_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstVertex = 1; +} + +void vkCmdDraw_CMockIgnoreArg_firstInstance(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDraw_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDraw_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDraw_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstInstance = 1; +} + +void vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDrawIndexed_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDrawIndexed); + cmock_call_instance = (CMOCK_vkCmdDrawIndexed_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDrawIndexed_CallInstance); + Mock.vkCmdDrawIndexed_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDrawIndexed_CallInstance); + if (Mock.vkCmdDrawIndexed_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDrawIndexed_CallbackBool && + Mock.vkCmdDrawIndexed_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawIndexed_CallbackFunctionPointer(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance, Mock.vkCmdDrawIndexed_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexed,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_indexCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexed,CMockString_indexCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_indexCount, indexCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_instanceCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexed,CMockString_instanceCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_instanceCount, instanceCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstIndex) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexed,CMockString_firstIndex); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstIndex, firstIndex, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_vertexOffset) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexed,CMockString_vertexOffset); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_vertexOffset, vertexOffset, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstInstance) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexed,CMockString_firstInstance); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstInstance, firstInstance, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdDrawIndexed_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawIndexed_CallbackFunctionPointer(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance, Mock.vkCmdDrawIndexed_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDrawIndexed(CMOCK_vkCmdDrawIndexed_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); +void CMockExpectParameters_vkCmdDrawIndexed(CMOCK_vkCmdDrawIndexed_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_indexCount = indexCount; + cmock_call_instance->IgnoreArg_indexCount = 0; + cmock_call_instance->Expected_instanceCount = instanceCount; + cmock_call_instance->IgnoreArg_instanceCount = 0; + cmock_call_instance->Expected_firstIndex = firstIndex; + cmock_call_instance->IgnoreArg_firstIndex = 0; + cmock_call_instance->Expected_vertexOffset = vertexOffset; + cmock_call_instance->IgnoreArg_vertexOffset = 0; + cmock_call_instance->Expected_firstInstance = firstInstance; + cmock_call_instance->IgnoreArg_firstInstance = 0; +} + +void vkCmdDrawIndexed_CMockIgnore(void) +{ + Mock.vkCmdDrawIndexed_IgnoreBool = (char)1; +} + +void vkCmdDrawIndexed_CMockStopIgnore(void) +{ + Mock.vkCmdDrawIndexed_IgnoreBool = (char)0; +} + +void vkCmdDrawIndexed_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawIndexed_CALL_INSTANCE)); + CMOCK_vkCmdDrawIndexed_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexed_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawIndexed_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawIndexed_CallInstance, cmock_guts_index); + Mock.vkCmdDrawIndexed_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDrawIndexed_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawIndexed_CALL_INSTANCE)); + CMOCK_vkCmdDrawIndexed_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexed_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawIndexed_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawIndexed_CallInstance, cmock_guts_index); + Mock.vkCmdDrawIndexed_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDrawIndexed(cmock_call_instance, commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); +} + +void vkCmdDrawIndexed_AddCallback(CMOCK_vkCmdDrawIndexed_CALLBACK Callback) +{ + Mock.vkCmdDrawIndexed_IgnoreBool = (char)0; + Mock.vkCmdDrawIndexed_CallbackBool = (char)1; + Mock.vkCmdDrawIndexed_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawIndexed_Stub(CMOCK_vkCmdDrawIndexed_CALLBACK Callback) +{ + Mock.vkCmdDrawIndexed_IgnoreBool = (char)0; + Mock.vkCmdDrawIndexed_CallbackBool = (char)0; + Mock.vkCmdDrawIndexed_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawIndexed_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexed_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexed_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexed_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDrawIndexed_CMockIgnoreArg_indexCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexed_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexed_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexed_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_indexCount = 1; +} + +void vkCmdDrawIndexed_CMockIgnoreArg_instanceCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexed_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexed_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexed_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_instanceCount = 1; +} + +void vkCmdDrawIndexed_CMockIgnoreArg_firstIndex(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexed_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexed_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexed_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstIndex = 1; +} + +void vkCmdDrawIndexed_CMockIgnoreArg_vertexOffset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexed_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexed_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexed_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_vertexOffset = 1; +} + +void vkCmdDrawIndexed_CMockIgnoreArg_firstInstance(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexed_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexed_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexed_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstInstance = 1; +} + +void vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDrawIndirect_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDrawIndirect); + cmock_call_instance = (CMOCK_vkCmdDrawIndirect_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDrawIndirect_CallInstance); + Mock.vkCmdDrawIndirect_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDrawIndirect_CallInstance); + if (Mock.vkCmdDrawIndirect_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDrawIndirect_CallbackBool && + Mock.vkCmdDrawIndirect_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawIndirect_CallbackFunctionPointer(commandBuffer, buffer, offset, drawCount, stride, Mock.vkCmdDrawIndirect_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirect,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_buffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirect,CMockString_buffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_offset) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirect,CMockString_offset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_drawCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirect,CMockString_drawCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_drawCount, drawCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_stride) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirect,CMockString_stride); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_stride, stride, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdDrawIndirect_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawIndirect_CallbackFunctionPointer(commandBuffer, buffer, offset, drawCount, stride, Mock.vkCmdDrawIndirect_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDrawIndirect(CMOCK_vkCmdDrawIndirect_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +void CMockExpectParameters_vkCmdDrawIndirect(CMOCK_vkCmdDrawIndirect_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), + sizeof(VkBuffer[sizeof(buffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_buffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), + sizeof(VkDeviceSize[sizeof(offset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_offset = 0; + cmock_call_instance->Expected_drawCount = drawCount; + cmock_call_instance->IgnoreArg_drawCount = 0; + cmock_call_instance->Expected_stride = stride; + cmock_call_instance->IgnoreArg_stride = 0; +} + +void vkCmdDrawIndirect_CMockIgnore(void) +{ + Mock.vkCmdDrawIndirect_IgnoreBool = (char)1; +} + +void vkCmdDrawIndirect_CMockStopIgnore(void) +{ + Mock.vkCmdDrawIndirect_IgnoreBool = (char)0; +} + +void vkCmdDrawIndirect_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawIndirect_CALL_INSTANCE)); + CMOCK_vkCmdDrawIndirect_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirect_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawIndirect_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawIndirect_CallInstance, cmock_guts_index); + Mock.vkCmdDrawIndirect_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDrawIndirect_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawIndirect_CALL_INSTANCE)); + CMOCK_vkCmdDrawIndirect_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirect_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawIndirect_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawIndirect_CallInstance, cmock_guts_index); + Mock.vkCmdDrawIndirect_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDrawIndirect(cmock_call_instance, commandBuffer, buffer, offset, drawCount, stride); +} + +void vkCmdDrawIndirect_AddCallback(CMOCK_vkCmdDrawIndirect_CALLBACK Callback) +{ + Mock.vkCmdDrawIndirect_IgnoreBool = (char)0; + Mock.vkCmdDrawIndirect_CallbackBool = (char)1; + Mock.vkCmdDrawIndirect_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawIndirect_Stub(CMOCK_vkCmdDrawIndirect_CALLBACK Callback) +{ + Mock.vkCmdDrawIndirect_IgnoreBool = (char)0; + Mock.vkCmdDrawIndirect_CallbackBool = (char)0; + Mock.vkCmdDrawIndirect_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawIndirect_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirect_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirect_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirect_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDrawIndirect_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirect_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirect_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirect_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_buffer = 1; +} + +void vkCmdDrawIndirect_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirect_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirect_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirect_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_offset = 1; +} + +void vkCmdDrawIndirect_CMockIgnoreArg_drawCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirect_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirect_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirect_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_drawCount = 1; +} + +void vkCmdDrawIndirect_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirect_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirect_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirect_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stride = 1; +} + +void vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDrawIndexedIndirect_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDrawIndexedIndirect); + cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirect_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDrawIndexedIndirect_CallInstance); + Mock.vkCmdDrawIndexedIndirect_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDrawIndexedIndirect_CallInstance); + if (Mock.vkCmdDrawIndexedIndirect_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDrawIndexedIndirect_CallbackBool && + Mock.vkCmdDrawIndexedIndirect_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawIndexedIndirect_CallbackFunctionPointer(commandBuffer, buffer, offset, drawCount, stride, Mock.vkCmdDrawIndexedIndirect_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexedIndirect,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_buffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexedIndirect,CMockString_buffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_offset) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexedIndirect,CMockString_offset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_drawCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexedIndirect,CMockString_drawCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_drawCount, drawCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_stride) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexedIndirect,CMockString_stride); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_stride, stride, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdDrawIndexedIndirect_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawIndexedIndirect_CallbackFunctionPointer(commandBuffer, buffer, offset, drawCount, stride, Mock.vkCmdDrawIndexedIndirect_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDrawIndexedIndirect(CMOCK_vkCmdDrawIndexedIndirect_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +void CMockExpectParameters_vkCmdDrawIndexedIndirect(CMOCK_vkCmdDrawIndexedIndirect_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), + sizeof(VkBuffer[sizeof(buffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_buffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), + sizeof(VkDeviceSize[sizeof(offset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_offset = 0; + cmock_call_instance->Expected_drawCount = drawCount; + cmock_call_instance->IgnoreArg_drawCount = 0; + cmock_call_instance->Expected_stride = stride; + cmock_call_instance->IgnoreArg_stride = 0; +} + +void vkCmdDrawIndexedIndirect_CMockIgnore(void) +{ + Mock.vkCmdDrawIndexedIndirect_IgnoreBool = (char)1; +} + +void vkCmdDrawIndexedIndirect_CMockStopIgnore(void) +{ + Mock.vkCmdDrawIndexedIndirect_IgnoreBool = (char)0; +} + +void vkCmdDrawIndexedIndirect_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawIndexedIndirect_CALL_INSTANCE)); + CMOCK_vkCmdDrawIndexedIndirect_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirect_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawIndexedIndirect_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawIndexedIndirect_CallInstance, cmock_guts_index); + Mock.vkCmdDrawIndexedIndirect_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDrawIndexedIndirect_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawIndexedIndirect_CALL_INSTANCE)); + CMOCK_vkCmdDrawIndexedIndirect_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirect_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawIndexedIndirect_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawIndexedIndirect_CallInstance, cmock_guts_index); + Mock.vkCmdDrawIndexedIndirect_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDrawIndexedIndirect(cmock_call_instance, commandBuffer, buffer, offset, drawCount, stride); +} + +void vkCmdDrawIndexedIndirect_AddCallback(CMOCK_vkCmdDrawIndexedIndirect_CALLBACK Callback) +{ + Mock.vkCmdDrawIndexedIndirect_IgnoreBool = (char)0; + Mock.vkCmdDrawIndexedIndirect_CallbackBool = (char)1; + Mock.vkCmdDrawIndexedIndirect_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawIndexedIndirect_Stub(CMOCK_vkCmdDrawIndexedIndirect_CALLBACK Callback) +{ + Mock.vkCmdDrawIndexedIndirect_IgnoreBool = (char)0; + Mock.vkCmdDrawIndexedIndirect_CallbackBool = (char)0; + Mock.vkCmdDrawIndexedIndirect_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawIndexedIndirect_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexedIndirect_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirect_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexedIndirect_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDrawIndexedIndirect_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexedIndirect_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirect_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexedIndirect_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_buffer = 1; +} + +void vkCmdDrawIndexedIndirect_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexedIndirect_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirect_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexedIndirect_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_offset = 1; +} + +void vkCmdDrawIndexedIndirect_CMockIgnoreArg_drawCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexedIndirect_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirect_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexedIndirect_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_drawCount = 1; +} + +void vkCmdDrawIndexedIndirect_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexedIndirect_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirect_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexedIndirect_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stride = 1; +} + +void vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDispatch_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDispatch); + cmock_call_instance = (CMOCK_vkCmdDispatch_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDispatch_CallInstance); + Mock.vkCmdDispatch_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDispatch_CallInstance); + if (Mock.vkCmdDispatch_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDispatch_CallbackBool && + Mock.vkCmdDispatch_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDispatch_CallbackFunctionPointer(commandBuffer, groupCountX, groupCountY, groupCountZ, Mock.vkCmdDispatch_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDispatch,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_groupCountX) + { + UNITY_SET_DETAILS(CMockString_vkCmdDispatch,CMockString_groupCountX); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_groupCountX, groupCountX, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_groupCountY) + { + UNITY_SET_DETAILS(CMockString_vkCmdDispatch,CMockString_groupCountY); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_groupCountY, groupCountY, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_groupCountZ) + { + UNITY_SET_DETAILS(CMockString_vkCmdDispatch,CMockString_groupCountZ); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_groupCountZ, groupCountZ, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdDispatch_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDispatch_CallbackFunctionPointer(commandBuffer, groupCountX, groupCountY, groupCountZ, Mock.vkCmdDispatch_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDispatch(CMOCK_vkCmdDispatch_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +void CMockExpectParameters_vkCmdDispatch(CMOCK_vkCmdDispatch_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_groupCountX = groupCountX; + cmock_call_instance->IgnoreArg_groupCountX = 0; + cmock_call_instance->Expected_groupCountY = groupCountY; + cmock_call_instance->IgnoreArg_groupCountY = 0; + cmock_call_instance->Expected_groupCountZ = groupCountZ; + cmock_call_instance->IgnoreArg_groupCountZ = 0; +} + +void vkCmdDispatch_CMockIgnore(void) +{ + Mock.vkCmdDispatch_IgnoreBool = (char)1; +} + +void vkCmdDispatch_CMockStopIgnore(void) +{ + Mock.vkCmdDispatch_IgnoreBool = (char)0; +} + +void vkCmdDispatch_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDispatch_CALL_INSTANCE)); + CMOCK_vkCmdDispatch_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDispatch_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDispatch_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDispatch_CallInstance, cmock_guts_index); + Mock.vkCmdDispatch_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDispatch_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDispatch_CALL_INSTANCE)); + CMOCK_vkCmdDispatch_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDispatch_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDispatch_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDispatch_CallInstance, cmock_guts_index); + Mock.vkCmdDispatch_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDispatch(cmock_call_instance, commandBuffer, groupCountX, groupCountY, groupCountZ); +} + +void vkCmdDispatch_AddCallback(CMOCK_vkCmdDispatch_CALLBACK Callback) +{ + Mock.vkCmdDispatch_IgnoreBool = (char)0; + Mock.vkCmdDispatch_CallbackBool = (char)1; + Mock.vkCmdDispatch_CallbackFunctionPointer = Callback; +} + +void vkCmdDispatch_Stub(CMOCK_vkCmdDispatch_CALLBACK Callback) +{ + Mock.vkCmdDispatch_IgnoreBool = (char)0; + Mock.vkCmdDispatch_CallbackBool = (char)0; + Mock.vkCmdDispatch_CallbackFunctionPointer = Callback; +} + +void vkCmdDispatch_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDispatch_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDispatch_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDispatch_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDispatch_CMockIgnoreArg_groupCountX(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDispatch_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDispatch_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDispatch_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_groupCountX = 1; +} + +void vkCmdDispatch_CMockIgnoreArg_groupCountY(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDispatch_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDispatch_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDispatch_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_groupCountY = 1; +} + +void vkCmdDispatch_CMockIgnoreArg_groupCountZ(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDispatch_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDispatch_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDispatch_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_groupCountZ = 1; +} + +void vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDispatchIndirect_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDispatchIndirect); + cmock_call_instance = (CMOCK_vkCmdDispatchIndirect_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDispatchIndirect_CallInstance); + Mock.vkCmdDispatchIndirect_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDispatchIndirect_CallInstance); + if (Mock.vkCmdDispatchIndirect_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDispatchIndirect_CallbackBool && + Mock.vkCmdDispatchIndirect_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDispatchIndirect_CallbackFunctionPointer(commandBuffer, buffer, offset, Mock.vkCmdDispatchIndirect_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDispatchIndirect,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_buffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDispatchIndirect,CMockString_buffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_offset) + { + UNITY_SET_DETAILS(CMockString_vkCmdDispatchIndirect,CMockString_offset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdDispatchIndirect_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDispatchIndirect_CallbackFunctionPointer(commandBuffer, buffer, offset, Mock.vkCmdDispatchIndirect_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDispatchIndirect(CMOCK_vkCmdDispatchIndirect_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); +void CMockExpectParameters_vkCmdDispatchIndirect(CMOCK_vkCmdDispatchIndirect_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), + sizeof(VkBuffer[sizeof(buffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_buffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), + sizeof(VkDeviceSize[sizeof(offset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_offset = 0; +} + +void vkCmdDispatchIndirect_CMockIgnore(void) +{ + Mock.vkCmdDispatchIndirect_IgnoreBool = (char)1; +} + +void vkCmdDispatchIndirect_CMockStopIgnore(void) +{ + Mock.vkCmdDispatchIndirect_IgnoreBool = (char)0; +} + +void vkCmdDispatchIndirect_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDispatchIndirect_CALL_INSTANCE)); + CMOCK_vkCmdDispatchIndirect_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDispatchIndirect_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDispatchIndirect_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDispatchIndirect_CallInstance, cmock_guts_index); + Mock.vkCmdDispatchIndirect_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDispatchIndirect_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDispatchIndirect_CALL_INSTANCE)); + CMOCK_vkCmdDispatchIndirect_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDispatchIndirect_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDispatchIndirect_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDispatchIndirect_CallInstance, cmock_guts_index); + Mock.vkCmdDispatchIndirect_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDispatchIndirect(cmock_call_instance, commandBuffer, buffer, offset); +} + +void vkCmdDispatchIndirect_AddCallback(CMOCK_vkCmdDispatchIndirect_CALLBACK Callback) +{ + Mock.vkCmdDispatchIndirect_IgnoreBool = (char)0; + Mock.vkCmdDispatchIndirect_CallbackBool = (char)1; + Mock.vkCmdDispatchIndirect_CallbackFunctionPointer = Callback; +} + +void vkCmdDispatchIndirect_Stub(CMOCK_vkCmdDispatchIndirect_CALLBACK Callback) +{ + Mock.vkCmdDispatchIndirect_IgnoreBool = (char)0; + Mock.vkCmdDispatchIndirect_CallbackBool = (char)0; + Mock.vkCmdDispatchIndirect_CallbackFunctionPointer = Callback; +} + +void vkCmdDispatchIndirect_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDispatchIndirect_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDispatchIndirect_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDispatchIndirect_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDispatchIndirect_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDispatchIndirect_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDispatchIndirect_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDispatchIndirect_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_buffer = 1; +} + +void vkCmdDispatchIndirect_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDispatchIndirect_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDispatchIndirect_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDispatchIndirect_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_offset = 1; +} + +void vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdCopyBuffer_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdCopyBuffer); + cmock_call_instance = (CMOCK_vkCmdCopyBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdCopyBuffer_CallInstance); + Mock.vkCmdCopyBuffer_CallInstance = CMock_Guts_MemNext(Mock.vkCmdCopyBuffer_CallInstance); + if (Mock.vkCmdCopyBuffer_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdCopyBuffer_CallbackBool && + Mock.vkCmdCopyBuffer_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyBuffer_CallbackFunctionPointer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions, Mock.vkCmdCopyBuffer_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyBuffer,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_srcBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyBuffer,CMockString_srcBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_srcBuffer), (void*)(&srcBuffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dstBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyBuffer,CMockString_dstBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dstBuffer), (void*)(&dstBuffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_regionCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyBuffer,CMockString_regionCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_regionCount, regionCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pRegions) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyBuffer,CMockString_pRegions); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pRegions), (void*)(pRegions), sizeof(const VkBufferCopy), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdCopyBuffer_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyBuffer_CallbackFunctionPointer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions, Mock.vkCmdCopyBuffer_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdCopyBuffer(CMOCK_vkCmdCopyBuffer_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); +void CMockExpectParameters_vkCmdCopyBuffer(CMOCK_vkCmdCopyBuffer_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_srcBuffer), (void*)(&srcBuffer), + sizeof(VkBuffer[sizeof(srcBuffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_srcBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_dstBuffer), (void*)(&dstBuffer), + sizeof(VkBuffer[sizeof(dstBuffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dstBuffer = 0; + cmock_call_instance->Expected_regionCount = regionCount; + cmock_call_instance->IgnoreArg_regionCount = 0; + cmock_call_instance->Expected_pRegions = pRegions; + cmock_call_instance->IgnoreArg_pRegions = 0; +} + +void vkCmdCopyBuffer_CMockIgnore(void) +{ + Mock.vkCmdCopyBuffer_IgnoreBool = (char)1; +} + +void vkCmdCopyBuffer_CMockStopIgnore(void) +{ + Mock.vkCmdCopyBuffer_IgnoreBool = (char)0; +} + +void vkCmdCopyBuffer_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyBuffer_CALL_INSTANCE)); + CMOCK_vkCmdCopyBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyBuffer_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyBuffer_CallInstance, cmock_guts_index); + Mock.vkCmdCopyBuffer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdCopyBuffer_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyBuffer_CALL_INSTANCE)); + CMOCK_vkCmdCopyBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyBuffer_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyBuffer_CallInstance, cmock_guts_index); + Mock.vkCmdCopyBuffer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdCopyBuffer(cmock_call_instance, commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); +} + +void vkCmdCopyBuffer_AddCallback(CMOCK_vkCmdCopyBuffer_CALLBACK Callback) +{ + Mock.vkCmdCopyBuffer_IgnoreBool = (char)0; + Mock.vkCmdCopyBuffer_CallbackBool = (char)1; + Mock.vkCmdCopyBuffer_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyBuffer_Stub(CMOCK_vkCmdCopyBuffer_CALLBACK Callback) +{ + Mock.vkCmdCopyBuffer_IgnoreBool = (char)0; + Mock.vkCmdCopyBuffer_CallbackBool = (char)0; + Mock.vkCmdCopyBuffer_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyBuffer_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdCopyBuffer_CMockIgnoreArg_srcBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_srcBuffer = 1; +} + +void vkCmdCopyBuffer_CMockIgnoreArg_dstBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dstBuffer = 1; +} + +void vkCmdCopyBuffer_CMockIgnoreArg_regionCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_regionCount = 1; +} + +void vkCmdCopyBuffer_CMockIgnoreArg_pRegions(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pRegions = 1; +} + +void vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdCopyImage_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdCopyImage); + cmock_call_instance = (CMOCK_vkCmdCopyImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdCopyImage_CallInstance); + Mock.vkCmdCopyImage_CallInstance = CMock_Guts_MemNext(Mock.vkCmdCopyImage_CallInstance); + if (Mock.vkCmdCopyImage_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdCopyImage_CallbackBool && + Mock.vkCmdCopyImage_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyImage_CallbackFunctionPointer(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, Mock.vkCmdCopyImage_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyImage,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_srcImage) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyImage,CMockString_srcImage); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_srcImage), (void*)(&srcImage), sizeof(VkImage), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_srcImageLayout) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyImage,CMockString_srcImageLayout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_srcImageLayout), (void*)(&srcImageLayout), sizeof(VkImageLayout), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dstImage) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyImage,CMockString_dstImage); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dstImage), (void*)(&dstImage), sizeof(VkImage), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dstImageLayout) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyImage,CMockString_dstImageLayout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dstImageLayout), (void*)(&dstImageLayout), sizeof(VkImageLayout), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_regionCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyImage,CMockString_regionCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_regionCount, regionCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pRegions) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyImage,CMockString_pRegions); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pRegions), (void*)(pRegions), sizeof(const VkImageCopy), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdCopyImage_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyImage_CallbackFunctionPointer(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, Mock.vkCmdCopyImage_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdCopyImage(CMOCK_vkCmdCopyImage_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); +void CMockExpectParameters_vkCmdCopyImage(CMOCK_vkCmdCopyImage_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_srcImage), (void*)(&srcImage), + sizeof(VkImage[sizeof(srcImage) == sizeof(VkImage) ? 1 : -1])); /* add VkImage to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_srcImage = 0; + memcpy((void*)(&cmock_call_instance->Expected_srcImageLayout), (void*)(&srcImageLayout), + sizeof(VkImageLayout[sizeof(srcImageLayout) == sizeof(VkImageLayout) ? 1 : -1])); /* add VkImageLayout to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_srcImageLayout = 0; + memcpy((void*)(&cmock_call_instance->Expected_dstImage), (void*)(&dstImage), + sizeof(VkImage[sizeof(dstImage) == sizeof(VkImage) ? 1 : -1])); /* add VkImage to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dstImage = 0; + memcpy((void*)(&cmock_call_instance->Expected_dstImageLayout), (void*)(&dstImageLayout), + sizeof(VkImageLayout[sizeof(dstImageLayout) == sizeof(VkImageLayout) ? 1 : -1])); /* add VkImageLayout to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dstImageLayout = 0; + cmock_call_instance->Expected_regionCount = regionCount; + cmock_call_instance->IgnoreArg_regionCount = 0; + cmock_call_instance->Expected_pRegions = pRegions; + cmock_call_instance->IgnoreArg_pRegions = 0; +} + +void vkCmdCopyImage_CMockIgnore(void) +{ + Mock.vkCmdCopyImage_IgnoreBool = (char)1; +} + +void vkCmdCopyImage_CMockStopIgnore(void) +{ + Mock.vkCmdCopyImage_IgnoreBool = (char)0; +} + +void vkCmdCopyImage_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyImage_CALL_INSTANCE)); + CMOCK_vkCmdCopyImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyImage_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyImage_CallInstance, cmock_guts_index); + Mock.vkCmdCopyImage_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdCopyImage_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyImage_CALL_INSTANCE)); + CMOCK_vkCmdCopyImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyImage_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyImage_CallInstance, cmock_guts_index); + Mock.vkCmdCopyImage_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdCopyImage(cmock_call_instance, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); +} + +void vkCmdCopyImage_AddCallback(CMOCK_vkCmdCopyImage_CALLBACK Callback) +{ + Mock.vkCmdCopyImage_IgnoreBool = (char)0; + Mock.vkCmdCopyImage_CallbackBool = (char)1; + Mock.vkCmdCopyImage_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyImage_Stub(CMOCK_vkCmdCopyImage_CALLBACK Callback) +{ + Mock.vkCmdCopyImage_IgnoreBool = (char)0; + Mock.vkCmdCopyImage_CallbackBool = (char)0; + Mock.vkCmdCopyImage_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyImage_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdCopyImage_CMockIgnoreArg_srcImage(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_srcImage = 1; +} + +void vkCmdCopyImage_CMockIgnoreArg_srcImageLayout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_srcImageLayout = 1; +} + +void vkCmdCopyImage_CMockIgnoreArg_dstImage(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dstImage = 1; +} + +void vkCmdCopyImage_CMockIgnoreArg_dstImageLayout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dstImageLayout = 1; +} + +void vkCmdCopyImage_CMockIgnoreArg_regionCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_regionCount = 1; +} + +void vkCmdCopyImage_CMockIgnoreArg_pRegions(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pRegions = 1; +} + +void vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBlitImage_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBlitImage); + cmock_call_instance = (CMOCK_vkCmdBlitImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBlitImage_CallInstance); + Mock.vkCmdBlitImage_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBlitImage_CallInstance); + if (Mock.vkCmdBlitImage_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBlitImage_CallbackBool && + Mock.vkCmdBlitImage_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBlitImage_CallbackFunctionPointer(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter, Mock.vkCmdBlitImage_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBlitImage,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_srcImage) + { + UNITY_SET_DETAILS(CMockString_vkCmdBlitImage,CMockString_srcImage); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_srcImage), (void*)(&srcImage), sizeof(VkImage), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_srcImageLayout) + { + UNITY_SET_DETAILS(CMockString_vkCmdBlitImage,CMockString_srcImageLayout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_srcImageLayout), (void*)(&srcImageLayout), sizeof(VkImageLayout), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dstImage) + { + UNITY_SET_DETAILS(CMockString_vkCmdBlitImage,CMockString_dstImage); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dstImage), (void*)(&dstImage), sizeof(VkImage), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dstImageLayout) + { + UNITY_SET_DETAILS(CMockString_vkCmdBlitImage,CMockString_dstImageLayout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dstImageLayout), (void*)(&dstImageLayout), sizeof(VkImageLayout), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_regionCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdBlitImage,CMockString_regionCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_regionCount, regionCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pRegions) + { + UNITY_SET_DETAILS(CMockString_vkCmdBlitImage,CMockString_pRegions); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pRegions), (void*)(pRegions), sizeof(const VkImageBlit), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_filter) + { + UNITY_SET_DETAILS(CMockString_vkCmdBlitImage,CMockString_filter); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_filter), (void*)(&filter), sizeof(VkFilter), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdBlitImage_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBlitImage_CallbackFunctionPointer(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter, Mock.vkCmdBlitImage_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBlitImage(CMOCK_vkCmdBlitImage_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter); +void CMockExpectParameters_vkCmdBlitImage(CMOCK_vkCmdBlitImage_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_srcImage), (void*)(&srcImage), + sizeof(VkImage[sizeof(srcImage) == sizeof(VkImage) ? 1 : -1])); /* add VkImage to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_srcImage = 0; + memcpy((void*)(&cmock_call_instance->Expected_srcImageLayout), (void*)(&srcImageLayout), + sizeof(VkImageLayout[sizeof(srcImageLayout) == sizeof(VkImageLayout) ? 1 : -1])); /* add VkImageLayout to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_srcImageLayout = 0; + memcpy((void*)(&cmock_call_instance->Expected_dstImage), (void*)(&dstImage), + sizeof(VkImage[sizeof(dstImage) == sizeof(VkImage) ? 1 : -1])); /* add VkImage to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dstImage = 0; + memcpy((void*)(&cmock_call_instance->Expected_dstImageLayout), (void*)(&dstImageLayout), + sizeof(VkImageLayout[sizeof(dstImageLayout) == sizeof(VkImageLayout) ? 1 : -1])); /* add VkImageLayout to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dstImageLayout = 0; + cmock_call_instance->Expected_regionCount = regionCount; + cmock_call_instance->IgnoreArg_regionCount = 0; + cmock_call_instance->Expected_pRegions = pRegions; + cmock_call_instance->IgnoreArg_pRegions = 0; + memcpy((void*)(&cmock_call_instance->Expected_filter), (void*)(&filter), + sizeof(VkFilter[sizeof(filter) == sizeof(VkFilter) ? 1 : -1])); /* add VkFilter to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_filter = 0; +} + +void vkCmdBlitImage_CMockIgnore(void) +{ + Mock.vkCmdBlitImage_IgnoreBool = (char)1; +} + +void vkCmdBlitImage_CMockStopIgnore(void) +{ + Mock.vkCmdBlitImage_IgnoreBool = (char)0; +} + +void vkCmdBlitImage_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBlitImage_CALL_INSTANCE)); + CMOCK_vkCmdBlitImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBlitImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBlitImage_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBlitImage_CallInstance, cmock_guts_index); + Mock.vkCmdBlitImage_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBlitImage_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBlitImage_CALL_INSTANCE)); + CMOCK_vkCmdBlitImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBlitImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBlitImage_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBlitImage_CallInstance, cmock_guts_index); + Mock.vkCmdBlitImage_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBlitImage(cmock_call_instance, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); +} + +void vkCmdBlitImage_AddCallback(CMOCK_vkCmdBlitImage_CALLBACK Callback) +{ + Mock.vkCmdBlitImage_IgnoreBool = (char)0; + Mock.vkCmdBlitImage_CallbackBool = (char)1; + Mock.vkCmdBlitImage_CallbackFunctionPointer = Callback; +} + +void vkCmdBlitImage_Stub(CMOCK_vkCmdBlitImage_CALLBACK Callback) +{ + Mock.vkCmdBlitImage_IgnoreBool = (char)0; + Mock.vkCmdBlitImage_CallbackBool = (char)0; + Mock.vkCmdBlitImage_CallbackFunctionPointer = Callback; +} + +void vkCmdBlitImage_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBlitImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBlitImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBlitImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBlitImage_CMockIgnoreArg_srcImage(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBlitImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBlitImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBlitImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_srcImage = 1; +} + +void vkCmdBlitImage_CMockIgnoreArg_srcImageLayout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBlitImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBlitImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBlitImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_srcImageLayout = 1; +} + +void vkCmdBlitImage_CMockIgnoreArg_dstImage(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBlitImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBlitImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBlitImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dstImage = 1; +} + +void vkCmdBlitImage_CMockIgnoreArg_dstImageLayout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBlitImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBlitImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBlitImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dstImageLayout = 1; +} + +void vkCmdBlitImage_CMockIgnoreArg_regionCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBlitImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBlitImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBlitImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_regionCount = 1; +} + +void vkCmdBlitImage_CMockIgnoreArg_pRegions(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBlitImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBlitImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBlitImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pRegions = 1; +} + +void vkCmdBlitImage_CMockIgnoreArg_filter(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBlitImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBlitImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBlitImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_filter = 1; +} + +void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdCopyBufferToImage_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdCopyBufferToImage); + cmock_call_instance = (CMOCK_vkCmdCopyBufferToImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdCopyBufferToImage_CallInstance); + Mock.vkCmdCopyBufferToImage_CallInstance = CMock_Guts_MemNext(Mock.vkCmdCopyBufferToImage_CallInstance); + if (Mock.vkCmdCopyBufferToImage_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdCopyBufferToImage_CallbackBool && + Mock.vkCmdCopyBufferToImage_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyBufferToImage_CallbackFunctionPointer(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions, Mock.vkCmdCopyBufferToImage_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyBufferToImage,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_srcBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyBufferToImage,CMockString_srcBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_srcBuffer), (void*)(&srcBuffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dstImage) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyBufferToImage,CMockString_dstImage); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dstImage), (void*)(&dstImage), sizeof(VkImage), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dstImageLayout) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyBufferToImage,CMockString_dstImageLayout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dstImageLayout), (void*)(&dstImageLayout), sizeof(VkImageLayout), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_regionCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyBufferToImage,CMockString_regionCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_regionCount, regionCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pRegions) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyBufferToImage,CMockString_pRegions); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pRegions), (void*)(pRegions), sizeof(const VkBufferImageCopy), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdCopyBufferToImage_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyBufferToImage_CallbackFunctionPointer(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions, Mock.vkCmdCopyBufferToImage_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdCopyBufferToImage(CMOCK_vkCmdCopyBufferToImage_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); +void CMockExpectParameters_vkCmdCopyBufferToImage(CMOCK_vkCmdCopyBufferToImage_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_srcBuffer), (void*)(&srcBuffer), + sizeof(VkBuffer[sizeof(srcBuffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_srcBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_dstImage), (void*)(&dstImage), + sizeof(VkImage[sizeof(dstImage) == sizeof(VkImage) ? 1 : -1])); /* add VkImage to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dstImage = 0; + memcpy((void*)(&cmock_call_instance->Expected_dstImageLayout), (void*)(&dstImageLayout), + sizeof(VkImageLayout[sizeof(dstImageLayout) == sizeof(VkImageLayout) ? 1 : -1])); /* add VkImageLayout to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dstImageLayout = 0; + cmock_call_instance->Expected_regionCount = regionCount; + cmock_call_instance->IgnoreArg_regionCount = 0; + cmock_call_instance->Expected_pRegions = pRegions; + cmock_call_instance->IgnoreArg_pRegions = 0; +} + +void vkCmdCopyBufferToImage_CMockIgnore(void) +{ + Mock.vkCmdCopyBufferToImage_IgnoreBool = (char)1; +} + +void vkCmdCopyBufferToImage_CMockStopIgnore(void) +{ + Mock.vkCmdCopyBufferToImage_IgnoreBool = (char)0; +} + +void vkCmdCopyBufferToImage_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyBufferToImage_CALL_INSTANCE)); + CMOCK_vkCmdCopyBufferToImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBufferToImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyBufferToImage_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyBufferToImage_CallInstance, cmock_guts_index); + Mock.vkCmdCopyBufferToImage_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdCopyBufferToImage_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyBufferToImage_CALL_INSTANCE)); + CMOCK_vkCmdCopyBufferToImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBufferToImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyBufferToImage_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyBufferToImage_CallInstance, cmock_guts_index); + Mock.vkCmdCopyBufferToImage_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdCopyBufferToImage(cmock_call_instance, commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); +} + +void vkCmdCopyBufferToImage_AddCallback(CMOCK_vkCmdCopyBufferToImage_CALLBACK Callback) +{ + Mock.vkCmdCopyBufferToImage_IgnoreBool = (char)0; + Mock.vkCmdCopyBufferToImage_CallbackBool = (char)1; + Mock.vkCmdCopyBufferToImage_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyBufferToImage_Stub(CMOCK_vkCmdCopyBufferToImage_CALLBACK Callback) +{ + Mock.vkCmdCopyBufferToImage_IgnoreBool = (char)0; + Mock.vkCmdCopyBufferToImage_CallbackBool = (char)0; + Mock.vkCmdCopyBufferToImage_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyBufferToImage_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyBufferToImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBufferToImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyBufferToImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdCopyBufferToImage_CMockIgnoreArg_srcBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyBufferToImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBufferToImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyBufferToImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_srcBuffer = 1; +} + +void vkCmdCopyBufferToImage_CMockIgnoreArg_dstImage(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyBufferToImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBufferToImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyBufferToImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dstImage = 1; +} + +void vkCmdCopyBufferToImage_CMockIgnoreArg_dstImageLayout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyBufferToImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBufferToImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyBufferToImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dstImageLayout = 1; +} + +void vkCmdCopyBufferToImage_CMockIgnoreArg_regionCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyBufferToImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBufferToImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyBufferToImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_regionCount = 1; +} + +void vkCmdCopyBufferToImage_CMockIgnoreArg_pRegions(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyBufferToImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBufferToImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyBufferToImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pRegions = 1; +} + +void vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdCopyImageToBuffer_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdCopyImageToBuffer); + cmock_call_instance = (CMOCK_vkCmdCopyImageToBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdCopyImageToBuffer_CallInstance); + Mock.vkCmdCopyImageToBuffer_CallInstance = CMock_Guts_MemNext(Mock.vkCmdCopyImageToBuffer_CallInstance); + if (Mock.vkCmdCopyImageToBuffer_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdCopyImageToBuffer_CallbackBool && + Mock.vkCmdCopyImageToBuffer_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyImageToBuffer_CallbackFunctionPointer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions, Mock.vkCmdCopyImageToBuffer_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyImageToBuffer,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_srcImage) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyImageToBuffer,CMockString_srcImage); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_srcImage), (void*)(&srcImage), sizeof(VkImage), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_srcImageLayout) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyImageToBuffer,CMockString_srcImageLayout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_srcImageLayout), (void*)(&srcImageLayout), sizeof(VkImageLayout), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dstBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyImageToBuffer,CMockString_dstBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dstBuffer), (void*)(&dstBuffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_regionCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyImageToBuffer,CMockString_regionCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_regionCount, regionCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pRegions) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyImageToBuffer,CMockString_pRegions); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pRegions), (void*)(pRegions), sizeof(const VkBufferImageCopy), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdCopyImageToBuffer_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyImageToBuffer_CallbackFunctionPointer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions, Mock.vkCmdCopyImageToBuffer_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdCopyImageToBuffer(CMOCK_vkCmdCopyImageToBuffer_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); +void CMockExpectParameters_vkCmdCopyImageToBuffer(CMOCK_vkCmdCopyImageToBuffer_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_srcImage), (void*)(&srcImage), + sizeof(VkImage[sizeof(srcImage) == sizeof(VkImage) ? 1 : -1])); /* add VkImage to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_srcImage = 0; + memcpy((void*)(&cmock_call_instance->Expected_srcImageLayout), (void*)(&srcImageLayout), + sizeof(VkImageLayout[sizeof(srcImageLayout) == sizeof(VkImageLayout) ? 1 : -1])); /* add VkImageLayout to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_srcImageLayout = 0; + memcpy((void*)(&cmock_call_instance->Expected_dstBuffer), (void*)(&dstBuffer), + sizeof(VkBuffer[sizeof(dstBuffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dstBuffer = 0; + cmock_call_instance->Expected_regionCount = regionCount; + cmock_call_instance->IgnoreArg_regionCount = 0; + cmock_call_instance->Expected_pRegions = pRegions; + cmock_call_instance->IgnoreArg_pRegions = 0; +} + +void vkCmdCopyImageToBuffer_CMockIgnore(void) +{ + Mock.vkCmdCopyImageToBuffer_IgnoreBool = (char)1; +} + +void vkCmdCopyImageToBuffer_CMockStopIgnore(void) +{ + Mock.vkCmdCopyImageToBuffer_IgnoreBool = (char)0; +} + +void vkCmdCopyImageToBuffer_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyImageToBuffer_CALL_INSTANCE)); + CMOCK_vkCmdCopyImageToBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImageToBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyImageToBuffer_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyImageToBuffer_CallInstance, cmock_guts_index); + Mock.vkCmdCopyImageToBuffer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdCopyImageToBuffer_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyImageToBuffer_CALL_INSTANCE)); + CMOCK_vkCmdCopyImageToBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImageToBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyImageToBuffer_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyImageToBuffer_CallInstance, cmock_guts_index); + Mock.vkCmdCopyImageToBuffer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdCopyImageToBuffer(cmock_call_instance, commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); +} + +void vkCmdCopyImageToBuffer_AddCallback(CMOCK_vkCmdCopyImageToBuffer_CALLBACK Callback) +{ + Mock.vkCmdCopyImageToBuffer_IgnoreBool = (char)0; + Mock.vkCmdCopyImageToBuffer_CallbackBool = (char)1; + Mock.vkCmdCopyImageToBuffer_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyImageToBuffer_Stub(CMOCK_vkCmdCopyImageToBuffer_CALLBACK Callback) +{ + Mock.vkCmdCopyImageToBuffer_IgnoreBool = (char)0; + Mock.vkCmdCopyImageToBuffer_CallbackBool = (char)0; + Mock.vkCmdCopyImageToBuffer_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyImageToBuffer_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyImageToBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImageToBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyImageToBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdCopyImageToBuffer_CMockIgnoreArg_srcImage(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyImageToBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImageToBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyImageToBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_srcImage = 1; +} + +void vkCmdCopyImageToBuffer_CMockIgnoreArg_srcImageLayout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyImageToBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImageToBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyImageToBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_srcImageLayout = 1; +} + +void vkCmdCopyImageToBuffer_CMockIgnoreArg_dstBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyImageToBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImageToBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyImageToBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dstBuffer = 1; +} + +void vkCmdCopyImageToBuffer_CMockIgnoreArg_regionCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyImageToBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImageToBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyImageToBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_regionCount = 1; +} + +void vkCmdCopyImageToBuffer_CMockIgnoreArg_pRegions(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyImageToBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImageToBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyImageToBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pRegions = 1; +} + +void vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdUpdateBuffer_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdUpdateBuffer); + cmock_call_instance = (CMOCK_vkCmdUpdateBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdUpdateBuffer_CallInstance); + Mock.vkCmdUpdateBuffer_CallInstance = CMock_Guts_MemNext(Mock.vkCmdUpdateBuffer_CallInstance); + if (Mock.vkCmdUpdateBuffer_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdUpdateBuffer_CallbackBool && + Mock.vkCmdUpdateBuffer_CallbackFunctionPointer != NULL) + { + Mock.vkCmdUpdateBuffer_CallbackFunctionPointer(commandBuffer, dstBuffer, dstOffset, dataSize, pData, Mock.vkCmdUpdateBuffer_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdUpdateBuffer,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dstBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdUpdateBuffer,CMockString_dstBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dstBuffer), (void*)(&dstBuffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dstOffset) + { + UNITY_SET_DETAILS(CMockString_vkCmdUpdateBuffer,CMockString_dstOffset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dstOffset), (void*)(&dstOffset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dataSize) + { + UNITY_SET_DETAILS(CMockString_vkCmdUpdateBuffer,CMockString_dataSize); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dataSize), (void*)(&dataSize), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pData) + { + UNITY_SET_DETAILS(CMockString_vkCmdUpdateBuffer,CMockString_pData); + if (cmock_call_instance->Expected_pData == NULL) + { UNITY_TEST_ASSERT_NULL(pData, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(cmock_call_instance->Expected_pData, pData, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkCmdUpdateBuffer_CallbackFunctionPointer != NULL) + { + Mock.vkCmdUpdateBuffer_CallbackFunctionPointer(commandBuffer, dstBuffer, dstOffset, dataSize, pData, Mock.vkCmdUpdateBuffer_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdUpdateBuffer(CMOCK_vkCmdUpdateBuffer_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData); +void CMockExpectParameters_vkCmdUpdateBuffer(CMOCK_vkCmdUpdateBuffer_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_dstBuffer), (void*)(&dstBuffer), + sizeof(VkBuffer[sizeof(dstBuffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dstBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_dstOffset), (void*)(&dstOffset), + sizeof(VkDeviceSize[sizeof(dstOffset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dstOffset = 0; + memcpy((void*)(&cmock_call_instance->Expected_dataSize), (void*)(&dataSize), + sizeof(VkDeviceSize[sizeof(dataSize) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dataSize = 0; + cmock_call_instance->Expected_pData = pData; + cmock_call_instance->IgnoreArg_pData = 0; +} + +void vkCmdUpdateBuffer_CMockIgnore(void) +{ + Mock.vkCmdUpdateBuffer_IgnoreBool = (char)1; +} + +void vkCmdUpdateBuffer_CMockStopIgnore(void) +{ + Mock.vkCmdUpdateBuffer_IgnoreBool = (char)0; +} + +void vkCmdUpdateBuffer_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdUpdateBuffer_CALL_INSTANCE)); + CMOCK_vkCmdUpdateBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdUpdateBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdUpdateBuffer_CallInstance = CMock_Guts_MemChain(Mock.vkCmdUpdateBuffer_CallInstance, cmock_guts_index); + Mock.vkCmdUpdateBuffer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdUpdateBuffer_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdUpdateBuffer_CALL_INSTANCE)); + CMOCK_vkCmdUpdateBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdUpdateBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdUpdateBuffer_CallInstance = CMock_Guts_MemChain(Mock.vkCmdUpdateBuffer_CallInstance, cmock_guts_index); + Mock.vkCmdUpdateBuffer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdUpdateBuffer(cmock_call_instance, commandBuffer, dstBuffer, dstOffset, dataSize, pData); +} + +void vkCmdUpdateBuffer_AddCallback(CMOCK_vkCmdUpdateBuffer_CALLBACK Callback) +{ + Mock.vkCmdUpdateBuffer_IgnoreBool = (char)0; + Mock.vkCmdUpdateBuffer_CallbackBool = (char)1; + Mock.vkCmdUpdateBuffer_CallbackFunctionPointer = Callback; +} + +void vkCmdUpdateBuffer_Stub(CMOCK_vkCmdUpdateBuffer_CALLBACK Callback) +{ + Mock.vkCmdUpdateBuffer_IgnoreBool = (char)0; + Mock.vkCmdUpdateBuffer_CallbackBool = (char)0; + Mock.vkCmdUpdateBuffer_CallbackFunctionPointer = Callback; +} + +void vkCmdUpdateBuffer_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdUpdateBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdUpdateBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdUpdateBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdUpdateBuffer_CMockIgnoreArg_dstBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdUpdateBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdUpdateBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdUpdateBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dstBuffer = 1; +} + +void vkCmdUpdateBuffer_CMockIgnoreArg_dstOffset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdUpdateBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdUpdateBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdUpdateBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dstOffset = 1; +} + +void vkCmdUpdateBuffer_CMockIgnoreArg_dataSize(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdUpdateBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdUpdateBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdUpdateBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dataSize = 1; +} + +void vkCmdUpdateBuffer_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdUpdateBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdUpdateBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdUpdateBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pData = 1; +} + +void vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdFillBuffer_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdFillBuffer); + cmock_call_instance = (CMOCK_vkCmdFillBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdFillBuffer_CallInstance); + Mock.vkCmdFillBuffer_CallInstance = CMock_Guts_MemNext(Mock.vkCmdFillBuffer_CallInstance); + if (Mock.vkCmdFillBuffer_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdFillBuffer_CallbackBool && + Mock.vkCmdFillBuffer_CallbackFunctionPointer != NULL) + { + Mock.vkCmdFillBuffer_CallbackFunctionPointer(commandBuffer, dstBuffer, dstOffset, size, data, Mock.vkCmdFillBuffer_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdFillBuffer,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dstBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdFillBuffer,CMockString_dstBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dstBuffer), (void*)(&dstBuffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dstOffset) + { + UNITY_SET_DETAILS(CMockString_vkCmdFillBuffer,CMockString_dstOffset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dstOffset), (void*)(&dstOffset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_size) + { + UNITY_SET_DETAILS(CMockString_vkCmdFillBuffer,CMockString_size); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_size), (void*)(&size), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_data) + { + UNITY_SET_DETAILS(CMockString_vkCmdFillBuffer,CMockString_data); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_data, data, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdFillBuffer_CallbackFunctionPointer != NULL) + { + Mock.vkCmdFillBuffer_CallbackFunctionPointer(commandBuffer, dstBuffer, dstOffset, size, data, Mock.vkCmdFillBuffer_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdFillBuffer(CMOCK_vkCmdFillBuffer_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); +void CMockExpectParameters_vkCmdFillBuffer(CMOCK_vkCmdFillBuffer_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_dstBuffer), (void*)(&dstBuffer), + sizeof(VkBuffer[sizeof(dstBuffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dstBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_dstOffset), (void*)(&dstOffset), + sizeof(VkDeviceSize[sizeof(dstOffset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dstOffset = 0; + memcpy((void*)(&cmock_call_instance->Expected_size), (void*)(&size), + sizeof(VkDeviceSize[sizeof(size) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_size = 0; + cmock_call_instance->Expected_data = data; + cmock_call_instance->IgnoreArg_data = 0; +} + +void vkCmdFillBuffer_CMockIgnore(void) +{ + Mock.vkCmdFillBuffer_IgnoreBool = (char)1; +} + +void vkCmdFillBuffer_CMockStopIgnore(void) +{ + Mock.vkCmdFillBuffer_IgnoreBool = (char)0; +} + +void vkCmdFillBuffer_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdFillBuffer_CALL_INSTANCE)); + CMOCK_vkCmdFillBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdFillBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdFillBuffer_CallInstance = CMock_Guts_MemChain(Mock.vkCmdFillBuffer_CallInstance, cmock_guts_index); + Mock.vkCmdFillBuffer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdFillBuffer_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdFillBuffer_CALL_INSTANCE)); + CMOCK_vkCmdFillBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdFillBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdFillBuffer_CallInstance = CMock_Guts_MemChain(Mock.vkCmdFillBuffer_CallInstance, cmock_guts_index); + Mock.vkCmdFillBuffer_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdFillBuffer(cmock_call_instance, commandBuffer, dstBuffer, dstOffset, size, data); +} + +void vkCmdFillBuffer_AddCallback(CMOCK_vkCmdFillBuffer_CALLBACK Callback) +{ + Mock.vkCmdFillBuffer_IgnoreBool = (char)0; + Mock.vkCmdFillBuffer_CallbackBool = (char)1; + Mock.vkCmdFillBuffer_CallbackFunctionPointer = Callback; +} + +void vkCmdFillBuffer_Stub(CMOCK_vkCmdFillBuffer_CALLBACK Callback) +{ + Mock.vkCmdFillBuffer_IgnoreBool = (char)0; + Mock.vkCmdFillBuffer_CallbackBool = (char)0; + Mock.vkCmdFillBuffer_CallbackFunctionPointer = Callback; +} + +void vkCmdFillBuffer_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdFillBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdFillBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdFillBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdFillBuffer_CMockIgnoreArg_dstBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdFillBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdFillBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdFillBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dstBuffer = 1; +} + +void vkCmdFillBuffer_CMockIgnoreArg_dstOffset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdFillBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdFillBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdFillBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dstOffset = 1; +} + +void vkCmdFillBuffer_CMockIgnoreArg_size(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdFillBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdFillBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdFillBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_size = 1; +} + +void vkCmdFillBuffer_CMockIgnoreArg_data(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdFillBuffer_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdFillBuffer_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdFillBuffer_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_data = 1; +} + +void vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdClearColorImage_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdClearColorImage); + cmock_call_instance = (CMOCK_vkCmdClearColorImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdClearColorImage_CallInstance); + Mock.vkCmdClearColorImage_CallInstance = CMock_Guts_MemNext(Mock.vkCmdClearColorImage_CallInstance); + if (Mock.vkCmdClearColorImage_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdClearColorImage_CallbackBool && + Mock.vkCmdClearColorImage_CallbackFunctionPointer != NULL) + { + Mock.vkCmdClearColorImage_CallbackFunctionPointer(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges, Mock.vkCmdClearColorImage_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdClearColorImage,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_image) + { + UNITY_SET_DETAILS(CMockString_vkCmdClearColorImage,CMockString_image); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_image), (void*)(&image), sizeof(VkImage), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_imageLayout) + { + UNITY_SET_DETAILS(CMockString_vkCmdClearColorImage,CMockString_imageLayout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_imageLayout), (void*)(&imageLayout), sizeof(VkImageLayout), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pColor) + { + UNITY_SET_DETAILS(CMockString_vkCmdClearColorImage,CMockString_pColor); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pColor), (void*)(pColor), sizeof(const VkClearColorValue), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_rangeCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdClearColorImage,CMockString_rangeCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_rangeCount, rangeCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pRanges) + { + UNITY_SET_DETAILS(CMockString_vkCmdClearColorImage,CMockString_pRanges); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pRanges), (void*)(pRanges), sizeof(const VkImageSubresourceRange), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdClearColorImage_CallbackFunctionPointer != NULL) + { + Mock.vkCmdClearColorImage_CallbackFunctionPointer(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges, Mock.vkCmdClearColorImage_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdClearColorImage(CMOCK_vkCmdClearColorImage_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +void CMockExpectParameters_vkCmdClearColorImage(CMOCK_vkCmdClearColorImage_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_image), (void*)(&image), + sizeof(VkImage[sizeof(image) == sizeof(VkImage) ? 1 : -1])); /* add VkImage to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_image = 0; + memcpy((void*)(&cmock_call_instance->Expected_imageLayout), (void*)(&imageLayout), + sizeof(VkImageLayout[sizeof(imageLayout) == sizeof(VkImageLayout) ? 1 : -1])); /* add VkImageLayout to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_imageLayout = 0; + cmock_call_instance->Expected_pColor = pColor; + cmock_call_instance->IgnoreArg_pColor = 0; + cmock_call_instance->Expected_rangeCount = rangeCount; + cmock_call_instance->IgnoreArg_rangeCount = 0; + cmock_call_instance->Expected_pRanges = pRanges; + cmock_call_instance->IgnoreArg_pRanges = 0; +} + +void vkCmdClearColorImage_CMockIgnore(void) +{ + Mock.vkCmdClearColorImage_IgnoreBool = (char)1; +} + +void vkCmdClearColorImage_CMockStopIgnore(void) +{ + Mock.vkCmdClearColorImage_IgnoreBool = (char)0; +} + +void vkCmdClearColorImage_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdClearColorImage_CALL_INSTANCE)); + CMOCK_vkCmdClearColorImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdClearColorImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdClearColorImage_CallInstance = CMock_Guts_MemChain(Mock.vkCmdClearColorImage_CallInstance, cmock_guts_index); + Mock.vkCmdClearColorImage_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdClearColorImage_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdClearColorImage_CALL_INSTANCE)); + CMOCK_vkCmdClearColorImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdClearColorImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdClearColorImage_CallInstance = CMock_Guts_MemChain(Mock.vkCmdClearColorImage_CallInstance, cmock_guts_index); + Mock.vkCmdClearColorImage_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdClearColorImage(cmock_call_instance, commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); +} + +void vkCmdClearColorImage_AddCallback(CMOCK_vkCmdClearColorImage_CALLBACK Callback) +{ + Mock.vkCmdClearColorImage_IgnoreBool = (char)0; + Mock.vkCmdClearColorImage_CallbackBool = (char)1; + Mock.vkCmdClearColorImage_CallbackFunctionPointer = Callback; +} + +void vkCmdClearColorImage_Stub(CMOCK_vkCmdClearColorImage_CALLBACK Callback) +{ + Mock.vkCmdClearColorImage_IgnoreBool = (char)0; + Mock.vkCmdClearColorImage_CallbackBool = (char)0; + Mock.vkCmdClearColorImage_CallbackFunctionPointer = Callback; +} + +void vkCmdClearColorImage_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdClearColorImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdClearColorImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdClearColorImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdClearColorImage_CMockIgnoreArg_image(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdClearColorImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdClearColorImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdClearColorImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_image = 1; +} + +void vkCmdClearColorImage_CMockIgnoreArg_imageLayout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdClearColorImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdClearColorImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdClearColorImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_imageLayout = 1; +} + +void vkCmdClearColorImage_CMockIgnoreArg_pColor(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdClearColorImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdClearColorImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdClearColorImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pColor = 1; +} + +void vkCmdClearColorImage_CMockIgnoreArg_rangeCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdClearColorImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdClearColorImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdClearColorImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_rangeCount = 1; +} + +void vkCmdClearColorImage_CMockIgnoreArg_pRanges(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdClearColorImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdClearColorImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdClearColorImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pRanges = 1; +} + +void vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdClearDepthStencilImage_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdClearDepthStencilImage); + cmock_call_instance = (CMOCK_vkCmdClearDepthStencilImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdClearDepthStencilImage_CallInstance); + Mock.vkCmdClearDepthStencilImage_CallInstance = CMock_Guts_MemNext(Mock.vkCmdClearDepthStencilImage_CallInstance); + if (Mock.vkCmdClearDepthStencilImage_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdClearDepthStencilImage_CallbackBool && + Mock.vkCmdClearDepthStencilImage_CallbackFunctionPointer != NULL) + { + Mock.vkCmdClearDepthStencilImage_CallbackFunctionPointer(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges, Mock.vkCmdClearDepthStencilImage_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdClearDepthStencilImage,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_image) + { + UNITY_SET_DETAILS(CMockString_vkCmdClearDepthStencilImage,CMockString_image); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_image), (void*)(&image), sizeof(VkImage), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_imageLayout) + { + UNITY_SET_DETAILS(CMockString_vkCmdClearDepthStencilImage,CMockString_imageLayout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_imageLayout), (void*)(&imageLayout), sizeof(VkImageLayout), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDepthStencil) + { + UNITY_SET_DETAILS(CMockString_vkCmdClearDepthStencilImage,CMockString_pDepthStencil); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDepthStencil), (void*)(pDepthStencil), sizeof(const VkClearDepthStencilValue), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_rangeCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdClearDepthStencilImage,CMockString_rangeCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_rangeCount, rangeCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pRanges) + { + UNITY_SET_DETAILS(CMockString_vkCmdClearDepthStencilImage,CMockString_pRanges); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pRanges), (void*)(pRanges), sizeof(const VkImageSubresourceRange), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdClearDepthStencilImage_CallbackFunctionPointer != NULL) + { + Mock.vkCmdClearDepthStencilImage_CallbackFunctionPointer(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges, Mock.vkCmdClearDepthStencilImage_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdClearDepthStencilImage(CMOCK_vkCmdClearDepthStencilImage_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +void CMockExpectParameters_vkCmdClearDepthStencilImage(CMOCK_vkCmdClearDepthStencilImage_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_image), (void*)(&image), + sizeof(VkImage[sizeof(image) == sizeof(VkImage) ? 1 : -1])); /* add VkImage to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_image = 0; + memcpy((void*)(&cmock_call_instance->Expected_imageLayout), (void*)(&imageLayout), + sizeof(VkImageLayout[sizeof(imageLayout) == sizeof(VkImageLayout) ? 1 : -1])); /* add VkImageLayout to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_imageLayout = 0; + cmock_call_instance->Expected_pDepthStencil = pDepthStencil; + cmock_call_instance->IgnoreArg_pDepthStencil = 0; + cmock_call_instance->Expected_rangeCount = rangeCount; + cmock_call_instance->IgnoreArg_rangeCount = 0; + cmock_call_instance->Expected_pRanges = pRanges; + cmock_call_instance->IgnoreArg_pRanges = 0; +} + +void vkCmdClearDepthStencilImage_CMockIgnore(void) +{ + Mock.vkCmdClearDepthStencilImage_IgnoreBool = (char)1; +} + +void vkCmdClearDepthStencilImage_CMockStopIgnore(void) +{ + Mock.vkCmdClearDepthStencilImage_IgnoreBool = (char)0; +} + +void vkCmdClearDepthStencilImage_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdClearDepthStencilImage_CALL_INSTANCE)); + CMOCK_vkCmdClearDepthStencilImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdClearDepthStencilImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdClearDepthStencilImage_CallInstance = CMock_Guts_MemChain(Mock.vkCmdClearDepthStencilImage_CallInstance, cmock_guts_index); + Mock.vkCmdClearDepthStencilImage_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdClearDepthStencilImage_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdClearDepthStencilImage_CALL_INSTANCE)); + CMOCK_vkCmdClearDepthStencilImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdClearDepthStencilImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdClearDepthStencilImage_CallInstance = CMock_Guts_MemChain(Mock.vkCmdClearDepthStencilImage_CallInstance, cmock_guts_index); + Mock.vkCmdClearDepthStencilImage_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdClearDepthStencilImage(cmock_call_instance, commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); +} + +void vkCmdClearDepthStencilImage_AddCallback(CMOCK_vkCmdClearDepthStencilImage_CALLBACK Callback) +{ + Mock.vkCmdClearDepthStencilImage_IgnoreBool = (char)0; + Mock.vkCmdClearDepthStencilImage_CallbackBool = (char)1; + Mock.vkCmdClearDepthStencilImage_CallbackFunctionPointer = Callback; +} + +void vkCmdClearDepthStencilImage_Stub(CMOCK_vkCmdClearDepthStencilImage_CALLBACK Callback) +{ + Mock.vkCmdClearDepthStencilImage_IgnoreBool = (char)0; + Mock.vkCmdClearDepthStencilImage_CallbackBool = (char)0; + Mock.vkCmdClearDepthStencilImage_CallbackFunctionPointer = Callback; +} + +void vkCmdClearDepthStencilImage_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdClearDepthStencilImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdClearDepthStencilImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdClearDepthStencilImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdClearDepthStencilImage_CMockIgnoreArg_image(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdClearDepthStencilImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdClearDepthStencilImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdClearDepthStencilImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_image = 1; +} + +void vkCmdClearDepthStencilImage_CMockIgnoreArg_imageLayout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdClearDepthStencilImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdClearDepthStencilImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdClearDepthStencilImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_imageLayout = 1; +} + +void vkCmdClearDepthStencilImage_CMockIgnoreArg_pDepthStencil(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdClearDepthStencilImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdClearDepthStencilImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdClearDepthStencilImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDepthStencil = 1; +} + +void vkCmdClearDepthStencilImage_CMockIgnoreArg_rangeCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdClearDepthStencilImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdClearDepthStencilImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdClearDepthStencilImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_rangeCount = 1; +} + +void vkCmdClearDepthStencilImage_CMockIgnoreArg_pRanges(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdClearDepthStencilImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdClearDepthStencilImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdClearDepthStencilImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pRanges = 1; +} + +void vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdClearAttachments_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdClearAttachments); + cmock_call_instance = (CMOCK_vkCmdClearAttachments_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdClearAttachments_CallInstance); + Mock.vkCmdClearAttachments_CallInstance = CMock_Guts_MemNext(Mock.vkCmdClearAttachments_CallInstance); + if (Mock.vkCmdClearAttachments_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdClearAttachments_CallbackBool && + Mock.vkCmdClearAttachments_CallbackFunctionPointer != NULL) + { + Mock.vkCmdClearAttachments_CallbackFunctionPointer(commandBuffer, attachmentCount, pAttachments, rectCount, pRects, Mock.vkCmdClearAttachments_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdClearAttachments,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_attachmentCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdClearAttachments,CMockString_attachmentCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_attachmentCount, attachmentCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAttachments) + { + UNITY_SET_DETAILS(CMockString_vkCmdClearAttachments,CMockString_pAttachments); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAttachments), (void*)(pAttachments), sizeof(const VkClearAttachment), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_rectCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdClearAttachments,CMockString_rectCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_rectCount, rectCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pRects) + { + UNITY_SET_DETAILS(CMockString_vkCmdClearAttachments,CMockString_pRects); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pRects), (void*)(pRects), sizeof(const VkClearRect), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdClearAttachments_CallbackFunctionPointer != NULL) + { + Mock.vkCmdClearAttachments_CallbackFunctionPointer(commandBuffer, attachmentCount, pAttachments, rectCount, pRects, Mock.vkCmdClearAttachments_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdClearAttachments(CMOCK_vkCmdClearAttachments_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects); +void CMockExpectParameters_vkCmdClearAttachments(CMOCK_vkCmdClearAttachments_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_attachmentCount = attachmentCount; + cmock_call_instance->IgnoreArg_attachmentCount = 0; + cmock_call_instance->Expected_pAttachments = pAttachments; + cmock_call_instance->IgnoreArg_pAttachments = 0; + cmock_call_instance->Expected_rectCount = rectCount; + cmock_call_instance->IgnoreArg_rectCount = 0; + cmock_call_instance->Expected_pRects = pRects; + cmock_call_instance->IgnoreArg_pRects = 0; +} + +void vkCmdClearAttachments_CMockIgnore(void) +{ + Mock.vkCmdClearAttachments_IgnoreBool = (char)1; +} + +void vkCmdClearAttachments_CMockStopIgnore(void) +{ + Mock.vkCmdClearAttachments_IgnoreBool = (char)0; +} + +void vkCmdClearAttachments_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdClearAttachments_CALL_INSTANCE)); + CMOCK_vkCmdClearAttachments_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdClearAttachments_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdClearAttachments_CallInstance = CMock_Guts_MemChain(Mock.vkCmdClearAttachments_CallInstance, cmock_guts_index); + Mock.vkCmdClearAttachments_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdClearAttachments_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdClearAttachments_CALL_INSTANCE)); + CMOCK_vkCmdClearAttachments_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdClearAttachments_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdClearAttachments_CallInstance = CMock_Guts_MemChain(Mock.vkCmdClearAttachments_CallInstance, cmock_guts_index); + Mock.vkCmdClearAttachments_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdClearAttachments(cmock_call_instance, commandBuffer, attachmentCount, pAttachments, rectCount, pRects); +} + +void vkCmdClearAttachments_AddCallback(CMOCK_vkCmdClearAttachments_CALLBACK Callback) +{ + Mock.vkCmdClearAttachments_IgnoreBool = (char)0; + Mock.vkCmdClearAttachments_CallbackBool = (char)1; + Mock.vkCmdClearAttachments_CallbackFunctionPointer = Callback; +} + +void vkCmdClearAttachments_Stub(CMOCK_vkCmdClearAttachments_CALLBACK Callback) +{ + Mock.vkCmdClearAttachments_IgnoreBool = (char)0; + Mock.vkCmdClearAttachments_CallbackBool = (char)0; + Mock.vkCmdClearAttachments_CallbackFunctionPointer = Callback; +} + +void vkCmdClearAttachments_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdClearAttachments_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdClearAttachments_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdClearAttachments_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdClearAttachments_CMockIgnoreArg_attachmentCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdClearAttachments_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdClearAttachments_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdClearAttachments_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_attachmentCount = 1; +} + +void vkCmdClearAttachments_CMockIgnoreArg_pAttachments(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdClearAttachments_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdClearAttachments_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdClearAttachments_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAttachments = 1; +} + +void vkCmdClearAttachments_CMockIgnoreArg_rectCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdClearAttachments_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdClearAttachments_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdClearAttachments_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_rectCount = 1; +} + +void vkCmdClearAttachments_CMockIgnoreArg_pRects(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdClearAttachments_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdClearAttachments_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdClearAttachments_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pRects = 1; +} + +void vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdResolveImage_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdResolveImage); + cmock_call_instance = (CMOCK_vkCmdResolveImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdResolveImage_CallInstance); + Mock.vkCmdResolveImage_CallInstance = CMock_Guts_MemNext(Mock.vkCmdResolveImage_CallInstance); + if (Mock.vkCmdResolveImage_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdResolveImage_CallbackBool && + Mock.vkCmdResolveImage_CallbackFunctionPointer != NULL) + { + Mock.vkCmdResolveImage_CallbackFunctionPointer(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, Mock.vkCmdResolveImage_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdResolveImage,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_srcImage) + { + UNITY_SET_DETAILS(CMockString_vkCmdResolveImage,CMockString_srcImage); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_srcImage), (void*)(&srcImage), sizeof(VkImage), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_srcImageLayout) + { + UNITY_SET_DETAILS(CMockString_vkCmdResolveImage,CMockString_srcImageLayout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_srcImageLayout), (void*)(&srcImageLayout), sizeof(VkImageLayout), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dstImage) + { + UNITY_SET_DETAILS(CMockString_vkCmdResolveImage,CMockString_dstImage); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dstImage), (void*)(&dstImage), sizeof(VkImage), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dstImageLayout) + { + UNITY_SET_DETAILS(CMockString_vkCmdResolveImage,CMockString_dstImageLayout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dstImageLayout), (void*)(&dstImageLayout), sizeof(VkImageLayout), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_regionCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdResolveImage,CMockString_regionCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_regionCount, regionCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pRegions) + { + UNITY_SET_DETAILS(CMockString_vkCmdResolveImage,CMockString_pRegions); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pRegions), (void*)(pRegions), sizeof(const VkImageResolve), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdResolveImage_CallbackFunctionPointer != NULL) + { + Mock.vkCmdResolveImage_CallbackFunctionPointer(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, Mock.vkCmdResolveImage_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdResolveImage(CMOCK_vkCmdResolveImage_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); +void CMockExpectParameters_vkCmdResolveImage(CMOCK_vkCmdResolveImage_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_srcImage), (void*)(&srcImage), + sizeof(VkImage[sizeof(srcImage) == sizeof(VkImage) ? 1 : -1])); /* add VkImage to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_srcImage = 0; + memcpy((void*)(&cmock_call_instance->Expected_srcImageLayout), (void*)(&srcImageLayout), + sizeof(VkImageLayout[sizeof(srcImageLayout) == sizeof(VkImageLayout) ? 1 : -1])); /* add VkImageLayout to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_srcImageLayout = 0; + memcpy((void*)(&cmock_call_instance->Expected_dstImage), (void*)(&dstImage), + sizeof(VkImage[sizeof(dstImage) == sizeof(VkImage) ? 1 : -1])); /* add VkImage to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dstImage = 0; + memcpy((void*)(&cmock_call_instance->Expected_dstImageLayout), (void*)(&dstImageLayout), + sizeof(VkImageLayout[sizeof(dstImageLayout) == sizeof(VkImageLayout) ? 1 : -1])); /* add VkImageLayout to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dstImageLayout = 0; + cmock_call_instance->Expected_regionCount = regionCount; + cmock_call_instance->IgnoreArg_regionCount = 0; + cmock_call_instance->Expected_pRegions = pRegions; + cmock_call_instance->IgnoreArg_pRegions = 0; +} + +void vkCmdResolveImage_CMockIgnore(void) +{ + Mock.vkCmdResolveImage_IgnoreBool = (char)1; +} + +void vkCmdResolveImage_CMockStopIgnore(void) +{ + Mock.vkCmdResolveImage_IgnoreBool = (char)0; +} + +void vkCmdResolveImage_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdResolveImage_CALL_INSTANCE)); + CMOCK_vkCmdResolveImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResolveImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdResolveImage_CallInstance = CMock_Guts_MemChain(Mock.vkCmdResolveImage_CallInstance, cmock_guts_index); + Mock.vkCmdResolveImage_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdResolveImage_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdResolveImage_CALL_INSTANCE)); + CMOCK_vkCmdResolveImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResolveImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdResolveImage_CallInstance = CMock_Guts_MemChain(Mock.vkCmdResolveImage_CallInstance, cmock_guts_index); + Mock.vkCmdResolveImage_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdResolveImage(cmock_call_instance, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); +} + +void vkCmdResolveImage_AddCallback(CMOCK_vkCmdResolveImage_CALLBACK Callback) +{ + Mock.vkCmdResolveImage_IgnoreBool = (char)0; + Mock.vkCmdResolveImage_CallbackBool = (char)1; + Mock.vkCmdResolveImage_CallbackFunctionPointer = Callback; +} + +void vkCmdResolveImage_Stub(CMOCK_vkCmdResolveImage_CALLBACK Callback) +{ + Mock.vkCmdResolveImage_IgnoreBool = (char)0; + Mock.vkCmdResolveImage_CallbackBool = (char)0; + Mock.vkCmdResolveImage_CallbackFunctionPointer = Callback; +} + +void vkCmdResolveImage_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdResolveImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResolveImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdResolveImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdResolveImage_CMockIgnoreArg_srcImage(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdResolveImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResolveImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdResolveImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_srcImage = 1; +} + +void vkCmdResolveImage_CMockIgnoreArg_srcImageLayout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdResolveImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResolveImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdResolveImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_srcImageLayout = 1; +} + +void vkCmdResolveImage_CMockIgnoreArg_dstImage(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdResolveImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResolveImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdResolveImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dstImage = 1; +} + +void vkCmdResolveImage_CMockIgnoreArg_dstImageLayout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdResolveImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResolveImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdResolveImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dstImageLayout = 1; +} + +void vkCmdResolveImage_CMockIgnoreArg_regionCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdResolveImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResolveImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdResolveImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_regionCount = 1; +} + +void vkCmdResolveImage_CMockIgnoreArg_pRegions(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdResolveImage_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResolveImage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdResolveImage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pRegions = 1; +} + +void vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetEvent_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetEvent); + cmock_call_instance = (CMOCK_vkCmdSetEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetEvent_CallInstance); + Mock.vkCmdSetEvent_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetEvent_CallInstance); + if (Mock.vkCmdSetEvent_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetEvent_CallbackBool && + Mock.vkCmdSetEvent_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetEvent_CallbackFunctionPointer(commandBuffer, event, stageMask, Mock.vkCmdSetEvent_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetEvent,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_event) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetEvent,CMockString_event); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_event), (void*)(&event), sizeof(VkEvent), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_stageMask) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetEvent,CMockString_stageMask); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_stageMask), (void*)(&stageMask), sizeof(VkPipelineStageFlags), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetEvent_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetEvent_CallbackFunctionPointer(commandBuffer, event, stageMask, Mock.vkCmdSetEvent_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetEvent(CMOCK_vkCmdSetEvent_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); +void CMockExpectParameters_vkCmdSetEvent(CMOCK_vkCmdSetEvent_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_event), (void*)(&event), + sizeof(VkEvent[sizeof(event) == sizeof(VkEvent) ? 1 : -1])); /* add VkEvent to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_event = 0; + memcpy((void*)(&cmock_call_instance->Expected_stageMask), (void*)(&stageMask), + sizeof(VkPipelineStageFlags[sizeof(stageMask) == sizeof(VkPipelineStageFlags) ? 1 : -1])); /* add VkPipelineStageFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_stageMask = 0; +} + +void vkCmdSetEvent_CMockIgnore(void) +{ + Mock.vkCmdSetEvent_IgnoreBool = (char)1; +} + +void vkCmdSetEvent_CMockStopIgnore(void) +{ + Mock.vkCmdSetEvent_IgnoreBool = (char)0; +} + +void vkCmdSetEvent_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetEvent_CALL_INSTANCE)); + CMOCK_vkCmdSetEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetEvent_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetEvent_CallInstance, cmock_guts_index); + Mock.vkCmdSetEvent_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetEvent_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetEvent_CALL_INSTANCE)); + CMOCK_vkCmdSetEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetEvent_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetEvent_CallInstance, cmock_guts_index); + Mock.vkCmdSetEvent_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetEvent(cmock_call_instance, commandBuffer, event, stageMask); +} + +void vkCmdSetEvent_AddCallback(CMOCK_vkCmdSetEvent_CALLBACK Callback) +{ + Mock.vkCmdSetEvent_IgnoreBool = (char)0; + Mock.vkCmdSetEvent_CallbackBool = (char)1; + Mock.vkCmdSetEvent_CallbackFunctionPointer = Callback; +} + +void vkCmdSetEvent_Stub(CMOCK_vkCmdSetEvent_CALLBACK Callback) +{ + Mock.vkCmdSetEvent_IgnoreBool = (char)0; + Mock.vkCmdSetEvent_CallbackBool = (char)0; + Mock.vkCmdSetEvent_CallbackFunctionPointer = Callback; +} + +void vkCmdSetEvent_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetEvent_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetEvent_CMockIgnoreArg_event(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetEvent_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_event = 1; +} + +void vkCmdSetEvent_CMockIgnoreArg_stageMask(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetEvent_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stageMask = 1; +} + +void vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdResetEvent_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdResetEvent); + cmock_call_instance = (CMOCK_vkCmdResetEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdResetEvent_CallInstance); + Mock.vkCmdResetEvent_CallInstance = CMock_Guts_MemNext(Mock.vkCmdResetEvent_CallInstance); + if (Mock.vkCmdResetEvent_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdResetEvent_CallbackBool && + Mock.vkCmdResetEvent_CallbackFunctionPointer != NULL) + { + Mock.vkCmdResetEvent_CallbackFunctionPointer(commandBuffer, event, stageMask, Mock.vkCmdResetEvent_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdResetEvent,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_event) + { + UNITY_SET_DETAILS(CMockString_vkCmdResetEvent,CMockString_event); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_event), (void*)(&event), sizeof(VkEvent), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_stageMask) + { + UNITY_SET_DETAILS(CMockString_vkCmdResetEvent,CMockString_stageMask); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_stageMask), (void*)(&stageMask), sizeof(VkPipelineStageFlags), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdResetEvent_CallbackFunctionPointer != NULL) + { + Mock.vkCmdResetEvent_CallbackFunctionPointer(commandBuffer, event, stageMask, Mock.vkCmdResetEvent_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdResetEvent(CMOCK_vkCmdResetEvent_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); +void CMockExpectParameters_vkCmdResetEvent(CMOCK_vkCmdResetEvent_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_event), (void*)(&event), + sizeof(VkEvent[sizeof(event) == sizeof(VkEvent) ? 1 : -1])); /* add VkEvent to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_event = 0; + memcpy((void*)(&cmock_call_instance->Expected_stageMask), (void*)(&stageMask), + sizeof(VkPipelineStageFlags[sizeof(stageMask) == sizeof(VkPipelineStageFlags) ? 1 : -1])); /* add VkPipelineStageFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_stageMask = 0; +} + +void vkCmdResetEvent_CMockIgnore(void) +{ + Mock.vkCmdResetEvent_IgnoreBool = (char)1; +} + +void vkCmdResetEvent_CMockStopIgnore(void) +{ + Mock.vkCmdResetEvent_IgnoreBool = (char)0; +} + +void vkCmdResetEvent_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdResetEvent_CALL_INSTANCE)); + CMOCK_vkCmdResetEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResetEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdResetEvent_CallInstance = CMock_Guts_MemChain(Mock.vkCmdResetEvent_CallInstance, cmock_guts_index); + Mock.vkCmdResetEvent_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdResetEvent_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdResetEvent_CALL_INSTANCE)); + CMOCK_vkCmdResetEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResetEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdResetEvent_CallInstance = CMock_Guts_MemChain(Mock.vkCmdResetEvent_CallInstance, cmock_guts_index); + Mock.vkCmdResetEvent_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdResetEvent(cmock_call_instance, commandBuffer, event, stageMask); +} + +void vkCmdResetEvent_AddCallback(CMOCK_vkCmdResetEvent_CALLBACK Callback) +{ + Mock.vkCmdResetEvent_IgnoreBool = (char)0; + Mock.vkCmdResetEvent_CallbackBool = (char)1; + Mock.vkCmdResetEvent_CallbackFunctionPointer = Callback; +} + +void vkCmdResetEvent_Stub(CMOCK_vkCmdResetEvent_CALLBACK Callback) +{ + Mock.vkCmdResetEvent_IgnoreBool = (char)0; + Mock.vkCmdResetEvent_CallbackBool = (char)0; + Mock.vkCmdResetEvent_CallbackFunctionPointer = Callback; +} + +void vkCmdResetEvent_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdResetEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResetEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdResetEvent_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdResetEvent_CMockIgnoreArg_event(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdResetEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResetEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdResetEvent_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_event = 1; +} + +void vkCmdResetEvent_CMockIgnoreArg_stageMask(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdResetEvent_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResetEvent_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdResetEvent_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stageMask = 1; +} + +void vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdWaitEvents_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdWaitEvents); + cmock_call_instance = (CMOCK_vkCmdWaitEvents_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdWaitEvents_CallInstance); + Mock.vkCmdWaitEvents_CallInstance = CMock_Guts_MemNext(Mock.vkCmdWaitEvents_CallInstance); + if (Mock.vkCmdWaitEvents_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdWaitEvents_CallbackBool && + Mock.vkCmdWaitEvents_CallbackFunctionPointer != NULL) + { + Mock.vkCmdWaitEvents_CallbackFunctionPointer(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers, Mock.vkCmdWaitEvents_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdWaitEvents,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_eventCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdWaitEvents,CMockString_eventCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_eventCount, eventCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pEvents) + { + UNITY_SET_DETAILS(CMockString_vkCmdWaitEvents,CMockString_pEvents); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pEvents), (void*)(pEvents), sizeof(const VkEvent), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_srcStageMask) + { + UNITY_SET_DETAILS(CMockString_vkCmdWaitEvents,CMockString_srcStageMask); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_srcStageMask), (void*)(&srcStageMask), sizeof(VkPipelineStageFlags), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dstStageMask) + { + UNITY_SET_DETAILS(CMockString_vkCmdWaitEvents,CMockString_dstStageMask); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dstStageMask), (void*)(&dstStageMask), sizeof(VkPipelineStageFlags), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_memoryBarrierCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdWaitEvents,CMockString_memoryBarrierCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_memoryBarrierCount, memoryBarrierCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMemoryBarriers) + { + UNITY_SET_DETAILS(CMockString_vkCmdWaitEvents,CMockString_pMemoryBarriers); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMemoryBarriers), (void*)(pMemoryBarriers), sizeof(const VkMemoryBarrier), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_bufferMemoryBarrierCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdWaitEvents,CMockString_bufferMemoryBarrierCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_bufferMemoryBarrierCount, bufferMemoryBarrierCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pBufferMemoryBarriers) + { + UNITY_SET_DETAILS(CMockString_vkCmdWaitEvents,CMockString_pBufferMemoryBarriers); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pBufferMemoryBarriers), (void*)(pBufferMemoryBarriers), sizeof(const VkBufferMemoryBarrier), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_imageMemoryBarrierCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdWaitEvents,CMockString_imageMemoryBarrierCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_imageMemoryBarrierCount, imageMemoryBarrierCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pImageMemoryBarriers) + { + UNITY_SET_DETAILS(CMockString_vkCmdWaitEvents,CMockString_pImageMemoryBarriers); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pImageMemoryBarriers), (void*)(pImageMemoryBarriers), sizeof(const VkImageMemoryBarrier), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdWaitEvents_CallbackFunctionPointer != NULL) + { + Mock.vkCmdWaitEvents_CallbackFunctionPointer(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers, Mock.vkCmdWaitEvents_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdWaitEvents(CMOCK_vkCmdWaitEvents_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); +void CMockExpectParameters_vkCmdWaitEvents(CMOCK_vkCmdWaitEvents_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_eventCount = eventCount; + cmock_call_instance->IgnoreArg_eventCount = 0; + cmock_call_instance->Expected_pEvents = pEvents; + cmock_call_instance->IgnoreArg_pEvents = 0; + memcpy((void*)(&cmock_call_instance->Expected_srcStageMask), (void*)(&srcStageMask), + sizeof(VkPipelineStageFlags[sizeof(srcStageMask) == sizeof(VkPipelineStageFlags) ? 1 : -1])); /* add VkPipelineStageFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_srcStageMask = 0; + memcpy((void*)(&cmock_call_instance->Expected_dstStageMask), (void*)(&dstStageMask), + sizeof(VkPipelineStageFlags[sizeof(dstStageMask) == sizeof(VkPipelineStageFlags) ? 1 : -1])); /* add VkPipelineStageFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dstStageMask = 0; + cmock_call_instance->Expected_memoryBarrierCount = memoryBarrierCount; + cmock_call_instance->IgnoreArg_memoryBarrierCount = 0; + cmock_call_instance->Expected_pMemoryBarriers = pMemoryBarriers; + cmock_call_instance->IgnoreArg_pMemoryBarriers = 0; + cmock_call_instance->Expected_bufferMemoryBarrierCount = bufferMemoryBarrierCount; + cmock_call_instance->IgnoreArg_bufferMemoryBarrierCount = 0; + cmock_call_instance->Expected_pBufferMemoryBarriers = pBufferMemoryBarriers; + cmock_call_instance->IgnoreArg_pBufferMemoryBarriers = 0; + cmock_call_instance->Expected_imageMemoryBarrierCount = imageMemoryBarrierCount; + cmock_call_instance->IgnoreArg_imageMemoryBarrierCount = 0; + cmock_call_instance->Expected_pImageMemoryBarriers = pImageMemoryBarriers; + cmock_call_instance->IgnoreArg_pImageMemoryBarriers = 0; +} + +void vkCmdWaitEvents_CMockIgnore(void) +{ + Mock.vkCmdWaitEvents_IgnoreBool = (char)1; +} + +void vkCmdWaitEvents_CMockStopIgnore(void) +{ + Mock.vkCmdWaitEvents_IgnoreBool = (char)0; +} + +void vkCmdWaitEvents_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdWaitEvents_CALL_INSTANCE)); + CMOCK_vkCmdWaitEvents_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWaitEvents_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdWaitEvents_CallInstance = CMock_Guts_MemChain(Mock.vkCmdWaitEvents_CallInstance, cmock_guts_index); + Mock.vkCmdWaitEvents_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdWaitEvents_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdWaitEvents_CALL_INSTANCE)); + CMOCK_vkCmdWaitEvents_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWaitEvents_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdWaitEvents_CallInstance = CMock_Guts_MemChain(Mock.vkCmdWaitEvents_CallInstance, cmock_guts_index); + Mock.vkCmdWaitEvents_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdWaitEvents(cmock_call_instance, commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); +} + +void vkCmdWaitEvents_AddCallback(CMOCK_vkCmdWaitEvents_CALLBACK Callback) +{ + Mock.vkCmdWaitEvents_IgnoreBool = (char)0; + Mock.vkCmdWaitEvents_CallbackBool = (char)1; + Mock.vkCmdWaitEvents_CallbackFunctionPointer = Callback; +} + +void vkCmdWaitEvents_Stub(CMOCK_vkCmdWaitEvents_CALLBACK Callback) +{ + Mock.vkCmdWaitEvents_IgnoreBool = (char)0; + Mock.vkCmdWaitEvents_CallbackBool = (char)0; + Mock.vkCmdWaitEvents_CallbackFunctionPointer = Callback; +} + +void vkCmdWaitEvents_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWaitEvents_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWaitEvents_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWaitEvents_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdWaitEvents_CMockIgnoreArg_eventCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWaitEvents_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWaitEvents_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWaitEvents_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_eventCount = 1; +} + +void vkCmdWaitEvents_CMockIgnoreArg_pEvents(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWaitEvents_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWaitEvents_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWaitEvents_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pEvents = 1; +} + +void vkCmdWaitEvents_CMockIgnoreArg_srcStageMask(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWaitEvents_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWaitEvents_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWaitEvents_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_srcStageMask = 1; +} + +void vkCmdWaitEvents_CMockIgnoreArg_dstStageMask(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWaitEvents_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWaitEvents_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWaitEvents_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dstStageMask = 1; +} + +void vkCmdWaitEvents_CMockIgnoreArg_memoryBarrierCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWaitEvents_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWaitEvents_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWaitEvents_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_memoryBarrierCount = 1; +} + +void vkCmdWaitEvents_CMockIgnoreArg_pMemoryBarriers(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWaitEvents_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWaitEvents_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWaitEvents_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMemoryBarriers = 1; +} + +void vkCmdWaitEvents_CMockIgnoreArg_bufferMemoryBarrierCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWaitEvents_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWaitEvents_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWaitEvents_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_bufferMemoryBarrierCount = 1; +} + +void vkCmdWaitEvents_CMockIgnoreArg_pBufferMemoryBarriers(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWaitEvents_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWaitEvents_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWaitEvents_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pBufferMemoryBarriers = 1; +} + +void vkCmdWaitEvents_CMockIgnoreArg_imageMemoryBarrierCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWaitEvents_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWaitEvents_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWaitEvents_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_imageMemoryBarrierCount = 1; +} + +void vkCmdWaitEvents_CMockIgnoreArg_pImageMemoryBarriers(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWaitEvents_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWaitEvents_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWaitEvents_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pImageMemoryBarriers = 1; +} + +void vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdPipelineBarrier); + cmock_call_instance = (CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdPipelineBarrier_CallInstance); + Mock.vkCmdPipelineBarrier_CallInstance = CMock_Guts_MemNext(Mock.vkCmdPipelineBarrier_CallInstance); + if (Mock.vkCmdPipelineBarrier_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdPipelineBarrier_CallbackBool && + Mock.vkCmdPipelineBarrier_CallbackFunctionPointer != NULL) + { + Mock.vkCmdPipelineBarrier_CallbackFunctionPointer(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers, Mock.vkCmdPipelineBarrier_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdPipelineBarrier,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_srcStageMask) + { + UNITY_SET_DETAILS(CMockString_vkCmdPipelineBarrier,CMockString_srcStageMask); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_srcStageMask), (void*)(&srcStageMask), sizeof(VkPipelineStageFlags), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dstStageMask) + { + UNITY_SET_DETAILS(CMockString_vkCmdPipelineBarrier,CMockString_dstStageMask); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dstStageMask), (void*)(&dstStageMask), sizeof(VkPipelineStageFlags), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dependencyFlags) + { + UNITY_SET_DETAILS(CMockString_vkCmdPipelineBarrier,CMockString_dependencyFlags); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dependencyFlags), (void*)(&dependencyFlags), sizeof(VkDependencyFlags), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_memoryBarrierCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdPipelineBarrier,CMockString_memoryBarrierCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_memoryBarrierCount, memoryBarrierCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMemoryBarriers) + { + UNITY_SET_DETAILS(CMockString_vkCmdPipelineBarrier,CMockString_pMemoryBarriers); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMemoryBarriers), (void*)(pMemoryBarriers), sizeof(const VkMemoryBarrier), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_bufferMemoryBarrierCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdPipelineBarrier,CMockString_bufferMemoryBarrierCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_bufferMemoryBarrierCount, bufferMemoryBarrierCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pBufferMemoryBarriers) + { + UNITY_SET_DETAILS(CMockString_vkCmdPipelineBarrier,CMockString_pBufferMemoryBarriers); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pBufferMemoryBarriers), (void*)(pBufferMemoryBarriers), sizeof(const VkBufferMemoryBarrier), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_imageMemoryBarrierCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdPipelineBarrier,CMockString_imageMemoryBarrierCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_imageMemoryBarrierCount, imageMemoryBarrierCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pImageMemoryBarriers) + { + UNITY_SET_DETAILS(CMockString_vkCmdPipelineBarrier,CMockString_pImageMemoryBarriers); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pImageMemoryBarriers), (void*)(pImageMemoryBarriers), sizeof(const VkImageMemoryBarrier), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdPipelineBarrier_CallbackFunctionPointer != NULL) + { + Mock.vkCmdPipelineBarrier_CallbackFunctionPointer(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers, Mock.vkCmdPipelineBarrier_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdPipelineBarrier(CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); +void CMockExpectParameters_vkCmdPipelineBarrier(CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_srcStageMask), (void*)(&srcStageMask), + sizeof(VkPipelineStageFlags[sizeof(srcStageMask) == sizeof(VkPipelineStageFlags) ? 1 : -1])); /* add VkPipelineStageFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_srcStageMask = 0; + memcpy((void*)(&cmock_call_instance->Expected_dstStageMask), (void*)(&dstStageMask), + sizeof(VkPipelineStageFlags[sizeof(dstStageMask) == sizeof(VkPipelineStageFlags) ? 1 : -1])); /* add VkPipelineStageFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dstStageMask = 0; + memcpy((void*)(&cmock_call_instance->Expected_dependencyFlags), (void*)(&dependencyFlags), + sizeof(VkDependencyFlags[sizeof(dependencyFlags) == sizeof(VkDependencyFlags) ? 1 : -1])); /* add VkDependencyFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dependencyFlags = 0; + cmock_call_instance->Expected_memoryBarrierCount = memoryBarrierCount; + cmock_call_instance->IgnoreArg_memoryBarrierCount = 0; + cmock_call_instance->Expected_pMemoryBarriers = pMemoryBarriers; + cmock_call_instance->IgnoreArg_pMemoryBarriers = 0; + cmock_call_instance->Expected_bufferMemoryBarrierCount = bufferMemoryBarrierCount; + cmock_call_instance->IgnoreArg_bufferMemoryBarrierCount = 0; + cmock_call_instance->Expected_pBufferMemoryBarriers = pBufferMemoryBarriers; + cmock_call_instance->IgnoreArg_pBufferMemoryBarriers = 0; + cmock_call_instance->Expected_imageMemoryBarrierCount = imageMemoryBarrierCount; + cmock_call_instance->IgnoreArg_imageMemoryBarrierCount = 0; + cmock_call_instance->Expected_pImageMemoryBarriers = pImageMemoryBarriers; + cmock_call_instance->IgnoreArg_pImageMemoryBarriers = 0; +} + +void vkCmdPipelineBarrier_CMockIgnore(void) +{ + Mock.vkCmdPipelineBarrier_IgnoreBool = (char)1; +} + +void vkCmdPipelineBarrier_CMockStopIgnore(void) +{ + Mock.vkCmdPipelineBarrier_IgnoreBool = (char)0; +} + +void vkCmdPipelineBarrier_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE)); + CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdPipelineBarrier_CallInstance = CMock_Guts_MemChain(Mock.vkCmdPipelineBarrier_CallInstance, cmock_guts_index); + Mock.vkCmdPipelineBarrier_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdPipelineBarrier_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE)); + CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdPipelineBarrier_CallInstance = CMock_Guts_MemChain(Mock.vkCmdPipelineBarrier_CallInstance, cmock_guts_index); + Mock.vkCmdPipelineBarrier_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdPipelineBarrier(cmock_call_instance, commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); +} + +void vkCmdPipelineBarrier_AddCallback(CMOCK_vkCmdPipelineBarrier_CALLBACK Callback) +{ + Mock.vkCmdPipelineBarrier_IgnoreBool = (char)0; + Mock.vkCmdPipelineBarrier_CallbackBool = (char)1; + Mock.vkCmdPipelineBarrier_CallbackFunctionPointer = Callback; +} + +void vkCmdPipelineBarrier_Stub(CMOCK_vkCmdPipelineBarrier_CALLBACK Callback) +{ + Mock.vkCmdPipelineBarrier_IgnoreBool = (char)0; + Mock.vkCmdPipelineBarrier_CallbackBool = (char)0; + Mock.vkCmdPipelineBarrier_CallbackFunctionPointer = Callback; +} + +void vkCmdPipelineBarrier_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPipelineBarrier_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdPipelineBarrier_CMockIgnoreArg_srcStageMask(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPipelineBarrier_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_srcStageMask = 1; +} + +void vkCmdPipelineBarrier_CMockIgnoreArg_dstStageMask(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPipelineBarrier_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dstStageMask = 1; +} + +void vkCmdPipelineBarrier_CMockIgnoreArg_dependencyFlags(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPipelineBarrier_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dependencyFlags = 1; +} + +void vkCmdPipelineBarrier_CMockIgnoreArg_memoryBarrierCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPipelineBarrier_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_memoryBarrierCount = 1; +} + +void vkCmdPipelineBarrier_CMockIgnoreArg_pMemoryBarriers(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPipelineBarrier_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMemoryBarriers = 1; +} + +void vkCmdPipelineBarrier_CMockIgnoreArg_bufferMemoryBarrierCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPipelineBarrier_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_bufferMemoryBarrierCount = 1; +} + +void vkCmdPipelineBarrier_CMockIgnoreArg_pBufferMemoryBarriers(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPipelineBarrier_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pBufferMemoryBarriers = 1; +} + +void vkCmdPipelineBarrier_CMockIgnoreArg_imageMemoryBarrierCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPipelineBarrier_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_imageMemoryBarrierCount = 1; +} + +void vkCmdPipelineBarrier_CMockIgnoreArg_pImageMemoryBarriers(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPipelineBarrier_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPipelineBarrier_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pImageMemoryBarriers = 1; +} + +void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBeginQuery_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBeginQuery); + cmock_call_instance = (CMOCK_vkCmdBeginQuery_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBeginQuery_CallInstance); + Mock.vkCmdBeginQuery_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBeginQuery_CallInstance); + if (Mock.vkCmdBeginQuery_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBeginQuery_CallbackBool && + Mock.vkCmdBeginQuery_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBeginQuery_CallbackFunctionPointer(commandBuffer, queryPool, query, flags, Mock.vkCmdBeginQuery_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginQuery,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queryPool) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginQuery,CMockString_queryPool); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), sizeof(VkQueryPool), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_query) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginQuery,CMockString_query); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_query, query, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_flags) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginQuery,CMockString_flags); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_flags), (void*)(&flags), sizeof(VkQueryControlFlags), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdBeginQuery_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBeginQuery_CallbackFunctionPointer(commandBuffer, queryPool, query, flags, Mock.vkCmdBeginQuery_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBeginQuery(CMOCK_vkCmdBeginQuery_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags); +void CMockExpectParameters_vkCmdBeginQuery(CMOCK_vkCmdBeginQuery_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), + sizeof(VkQueryPool[sizeof(queryPool) == sizeof(VkQueryPool) ? 1 : -1])); /* add VkQueryPool to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queryPool = 0; + cmock_call_instance->Expected_query = query; + cmock_call_instance->IgnoreArg_query = 0; + memcpy((void*)(&cmock_call_instance->Expected_flags), (void*)(&flags), + sizeof(VkQueryControlFlags[sizeof(flags) == sizeof(VkQueryControlFlags) ? 1 : -1])); /* add VkQueryControlFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_flags = 0; +} + +void vkCmdBeginQuery_CMockIgnore(void) +{ + Mock.vkCmdBeginQuery_IgnoreBool = (char)1; +} + +void vkCmdBeginQuery_CMockStopIgnore(void) +{ + Mock.vkCmdBeginQuery_IgnoreBool = (char)0; +} + +void vkCmdBeginQuery_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBeginQuery_CALL_INSTANCE)); + CMOCK_vkCmdBeginQuery_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginQuery_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBeginQuery_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBeginQuery_CallInstance, cmock_guts_index); + Mock.vkCmdBeginQuery_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBeginQuery_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBeginQuery_CALL_INSTANCE)); + CMOCK_vkCmdBeginQuery_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginQuery_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBeginQuery_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBeginQuery_CallInstance, cmock_guts_index); + Mock.vkCmdBeginQuery_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBeginQuery(cmock_call_instance, commandBuffer, queryPool, query, flags); +} + +void vkCmdBeginQuery_AddCallback(CMOCK_vkCmdBeginQuery_CALLBACK Callback) +{ + Mock.vkCmdBeginQuery_IgnoreBool = (char)0; + Mock.vkCmdBeginQuery_CallbackBool = (char)1; + Mock.vkCmdBeginQuery_CallbackFunctionPointer = Callback; +} + +void vkCmdBeginQuery_Stub(CMOCK_vkCmdBeginQuery_CALLBACK Callback) +{ + Mock.vkCmdBeginQuery_IgnoreBool = (char)0; + Mock.vkCmdBeginQuery_CallbackBool = (char)0; + Mock.vkCmdBeginQuery_CallbackFunctionPointer = Callback; +} + +void vkCmdBeginQuery_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginQuery_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginQuery_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginQuery_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBeginQuery_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginQuery_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginQuery_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginQuery_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queryPool = 1; +} + +void vkCmdBeginQuery_CMockIgnoreArg_query(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginQuery_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginQuery_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginQuery_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_query = 1; +} + +void vkCmdBeginQuery_CMockIgnoreArg_flags(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginQuery_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginQuery_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginQuery_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_flags = 1; +} + +void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdEndQuery_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdEndQuery); + cmock_call_instance = (CMOCK_vkCmdEndQuery_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdEndQuery_CallInstance); + Mock.vkCmdEndQuery_CallInstance = CMock_Guts_MemNext(Mock.vkCmdEndQuery_CallInstance); + if (Mock.vkCmdEndQuery_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdEndQuery_CallbackBool && + Mock.vkCmdEndQuery_CallbackFunctionPointer != NULL) + { + Mock.vkCmdEndQuery_CallbackFunctionPointer(commandBuffer, queryPool, query, Mock.vkCmdEndQuery_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdEndQuery,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queryPool) + { + UNITY_SET_DETAILS(CMockString_vkCmdEndQuery,CMockString_queryPool); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), sizeof(VkQueryPool), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_query) + { + UNITY_SET_DETAILS(CMockString_vkCmdEndQuery,CMockString_query); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_query, query, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdEndQuery_CallbackFunctionPointer != NULL) + { + Mock.vkCmdEndQuery_CallbackFunctionPointer(commandBuffer, queryPool, query, Mock.vkCmdEndQuery_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdEndQuery(CMOCK_vkCmdEndQuery_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query); +void CMockExpectParameters_vkCmdEndQuery(CMOCK_vkCmdEndQuery_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), + sizeof(VkQueryPool[sizeof(queryPool) == sizeof(VkQueryPool) ? 1 : -1])); /* add VkQueryPool to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queryPool = 0; + cmock_call_instance->Expected_query = query; + cmock_call_instance->IgnoreArg_query = 0; +} + +void vkCmdEndQuery_CMockIgnore(void) +{ + Mock.vkCmdEndQuery_IgnoreBool = (char)1; +} + +void vkCmdEndQuery_CMockStopIgnore(void) +{ + Mock.vkCmdEndQuery_IgnoreBool = (char)0; +} + +void vkCmdEndQuery_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdEndQuery_CALL_INSTANCE)); + CMOCK_vkCmdEndQuery_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndQuery_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdEndQuery_CallInstance = CMock_Guts_MemChain(Mock.vkCmdEndQuery_CallInstance, cmock_guts_index); + Mock.vkCmdEndQuery_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdEndQuery_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdEndQuery_CALL_INSTANCE)); + CMOCK_vkCmdEndQuery_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndQuery_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdEndQuery_CallInstance = CMock_Guts_MemChain(Mock.vkCmdEndQuery_CallInstance, cmock_guts_index); + Mock.vkCmdEndQuery_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdEndQuery(cmock_call_instance, commandBuffer, queryPool, query); +} + +void vkCmdEndQuery_AddCallback(CMOCK_vkCmdEndQuery_CALLBACK Callback) +{ + Mock.vkCmdEndQuery_IgnoreBool = (char)0; + Mock.vkCmdEndQuery_CallbackBool = (char)1; + Mock.vkCmdEndQuery_CallbackFunctionPointer = Callback; +} + +void vkCmdEndQuery_Stub(CMOCK_vkCmdEndQuery_CALLBACK Callback) +{ + Mock.vkCmdEndQuery_IgnoreBool = (char)0; + Mock.vkCmdEndQuery_CallbackBool = (char)0; + Mock.vkCmdEndQuery_CallbackFunctionPointer = Callback; +} + +void vkCmdEndQuery_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdEndQuery_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndQuery_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdEndQuery_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdEndQuery_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdEndQuery_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndQuery_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdEndQuery_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queryPool = 1; +} + +void vkCmdEndQuery_CMockIgnoreArg_query(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdEndQuery_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndQuery_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdEndQuery_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_query = 1; +} + +void vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdResetQueryPool_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdResetQueryPool); + cmock_call_instance = (CMOCK_vkCmdResetQueryPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdResetQueryPool_CallInstance); + Mock.vkCmdResetQueryPool_CallInstance = CMock_Guts_MemNext(Mock.vkCmdResetQueryPool_CallInstance); + if (Mock.vkCmdResetQueryPool_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdResetQueryPool_CallbackBool && + Mock.vkCmdResetQueryPool_CallbackFunctionPointer != NULL) + { + Mock.vkCmdResetQueryPool_CallbackFunctionPointer(commandBuffer, queryPool, firstQuery, queryCount, Mock.vkCmdResetQueryPool_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdResetQueryPool,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queryPool) + { + UNITY_SET_DETAILS(CMockString_vkCmdResetQueryPool,CMockString_queryPool); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), sizeof(VkQueryPool), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstQuery) + { + UNITY_SET_DETAILS(CMockString_vkCmdResetQueryPool,CMockString_firstQuery); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstQuery, firstQuery, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queryCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdResetQueryPool,CMockString_queryCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_queryCount, queryCount, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdResetQueryPool_CallbackFunctionPointer != NULL) + { + Mock.vkCmdResetQueryPool_CallbackFunctionPointer(commandBuffer, queryPool, firstQuery, queryCount, Mock.vkCmdResetQueryPool_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdResetQueryPool(CMOCK_vkCmdResetQueryPool_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); +void CMockExpectParameters_vkCmdResetQueryPool(CMOCK_vkCmdResetQueryPool_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), + sizeof(VkQueryPool[sizeof(queryPool) == sizeof(VkQueryPool) ? 1 : -1])); /* add VkQueryPool to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queryPool = 0; + cmock_call_instance->Expected_firstQuery = firstQuery; + cmock_call_instance->IgnoreArg_firstQuery = 0; + cmock_call_instance->Expected_queryCount = queryCount; + cmock_call_instance->IgnoreArg_queryCount = 0; +} + +void vkCmdResetQueryPool_CMockIgnore(void) +{ + Mock.vkCmdResetQueryPool_IgnoreBool = (char)1; +} + +void vkCmdResetQueryPool_CMockStopIgnore(void) +{ + Mock.vkCmdResetQueryPool_IgnoreBool = (char)0; +} + +void vkCmdResetQueryPool_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdResetQueryPool_CALL_INSTANCE)); + CMOCK_vkCmdResetQueryPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResetQueryPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdResetQueryPool_CallInstance = CMock_Guts_MemChain(Mock.vkCmdResetQueryPool_CallInstance, cmock_guts_index); + Mock.vkCmdResetQueryPool_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdResetQueryPool_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdResetQueryPool_CALL_INSTANCE)); + CMOCK_vkCmdResetQueryPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResetQueryPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdResetQueryPool_CallInstance = CMock_Guts_MemChain(Mock.vkCmdResetQueryPool_CallInstance, cmock_guts_index); + Mock.vkCmdResetQueryPool_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdResetQueryPool(cmock_call_instance, commandBuffer, queryPool, firstQuery, queryCount); +} + +void vkCmdResetQueryPool_AddCallback(CMOCK_vkCmdResetQueryPool_CALLBACK Callback) +{ + Mock.vkCmdResetQueryPool_IgnoreBool = (char)0; + Mock.vkCmdResetQueryPool_CallbackBool = (char)1; + Mock.vkCmdResetQueryPool_CallbackFunctionPointer = Callback; +} + +void vkCmdResetQueryPool_Stub(CMOCK_vkCmdResetQueryPool_CALLBACK Callback) +{ + Mock.vkCmdResetQueryPool_IgnoreBool = (char)0; + Mock.vkCmdResetQueryPool_CallbackBool = (char)0; + Mock.vkCmdResetQueryPool_CallbackFunctionPointer = Callback; +} + +void vkCmdResetQueryPool_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdResetQueryPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResetQueryPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdResetQueryPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdResetQueryPool_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdResetQueryPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResetQueryPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdResetQueryPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queryPool = 1; +} + +void vkCmdResetQueryPool_CMockIgnoreArg_firstQuery(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdResetQueryPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResetQueryPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdResetQueryPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstQuery = 1; +} + +void vkCmdResetQueryPool_CMockIgnoreArg_queryCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdResetQueryPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResetQueryPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdResetQueryPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queryCount = 1; +} + +void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdWriteTimestamp_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdWriteTimestamp); + cmock_call_instance = (CMOCK_vkCmdWriteTimestamp_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdWriteTimestamp_CallInstance); + Mock.vkCmdWriteTimestamp_CallInstance = CMock_Guts_MemNext(Mock.vkCmdWriteTimestamp_CallInstance); + if (Mock.vkCmdWriteTimestamp_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdWriteTimestamp_CallbackBool && + Mock.vkCmdWriteTimestamp_CallbackFunctionPointer != NULL) + { + Mock.vkCmdWriteTimestamp_CallbackFunctionPointer(commandBuffer, pipelineStage, queryPool, query, Mock.vkCmdWriteTimestamp_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteTimestamp,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pipelineStage) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteTimestamp,CMockString_pipelineStage); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_pipelineStage), (void*)(&pipelineStage), sizeof(VkPipelineStageFlagBits), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queryPool) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteTimestamp,CMockString_queryPool); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), sizeof(VkQueryPool), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_query) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteTimestamp,CMockString_query); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_query, query, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdWriteTimestamp_CallbackFunctionPointer != NULL) + { + Mock.vkCmdWriteTimestamp_CallbackFunctionPointer(commandBuffer, pipelineStage, queryPool, query, Mock.vkCmdWriteTimestamp_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdWriteTimestamp(CMOCK_vkCmdWriteTimestamp_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query); +void CMockExpectParameters_vkCmdWriteTimestamp(CMOCK_vkCmdWriteTimestamp_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_pipelineStage), (void*)(&pipelineStage), + sizeof(VkPipelineStageFlagBits[sizeof(pipelineStage) == sizeof(VkPipelineStageFlagBits) ? 1 : -1])); /* add VkPipelineStageFlagBits to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_pipelineStage = 0; + memcpy((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), + sizeof(VkQueryPool[sizeof(queryPool) == sizeof(VkQueryPool) ? 1 : -1])); /* add VkQueryPool to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queryPool = 0; + cmock_call_instance->Expected_query = query; + cmock_call_instance->IgnoreArg_query = 0; +} + +void vkCmdWriteTimestamp_CMockIgnore(void) +{ + Mock.vkCmdWriteTimestamp_IgnoreBool = (char)1; +} + +void vkCmdWriteTimestamp_CMockStopIgnore(void) +{ + Mock.vkCmdWriteTimestamp_IgnoreBool = (char)0; +} + +void vkCmdWriteTimestamp_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdWriteTimestamp_CALL_INSTANCE)); + CMOCK_vkCmdWriteTimestamp_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteTimestamp_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdWriteTimestamp_CallInstance = CMock_Guts_MemChain(Mock.vkCmdWriteTimestamp_CallInstance, cmock_guts_index); + Mock.vkCmdWriteTimestamp_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdWriteTimestamp_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdWriteTimestamp_CALL_INSTANCE)); + CMOCK_vkCmdWriteTimestamp_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteTimestamp_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdWriteTimestamp_CallInstance = CMock_Guts_MemChain(Mock.vkCmdWriteTimestamp_CallInstance, cmock_guts_index); + Mock.vkCmdWriteTimestamp_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdWriteTimestamp(cmock_call_instance, commandBuffer, pipelineStage, queryPool, query); +} + +void vkCmdWriteTimestamp_AddCallback(CMOCK_vkCmdWriteTimestamp_CALLBACK Callback) +{ + Mock.vkCmdWriteTimestamp_IgnoreBool = (char)0; + Mock.vkCmdWriteTimestamp_CallbackBool = (char)1; + Mock.vkCmdWriteTimestamp_CallbackFunctionPointer = Callback; +} + +void vkCmdWriteTimestamp_Stub(CMOCK_vkCmdWriteTimestamp_CALLBACK Callback) +{ + Mock.vkCmdWriteTimestamp_IgnoreBool = (char)0; + Mock.vkCmdWriteTimestamp_CallbackBool = (char)0; + Mock.vkCmdWriteTimestamp_CallbackFunctionPointer = Callback; +} + +void vkCmdWriteTimestamp_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteTimestamp_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteTimestamp_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteTimestamp_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdWriteTimestamp_CMockIgnoreArg_pipelineStage(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteTimestamp_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteTimestamp_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteTimestamp_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pipelineStage = 1; +} + +void vkCmdWriteTimestamp_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteTimestamp_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteTimestamp_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteTimestamp_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queryPool = 1; +} + +void vkCmdWriteTimestamp_CMockIgnoreArg_query(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteTimestamp_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteTimestamp_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteTimestamp_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_query = 1; +} + +void vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdCopyQueryPoolResults_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdCopyQueryPoolResults); + cmock_call_instance = (CMOCK_vkCmdCopyQueryPoolResults_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdCopyQueryPoolResults_CallInstance); + Mock.vkCmdCopyQueryPoolResults_CallInstance = CMock_Guts_MemNext(Mock.vkCmdCopyQueryPoolResults_CallInstance); + if (Mock.vkCmdCopyQueryPoolResults_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdCopyQueryPoolResults_CallbackBool && + Mock.vkCmdCopyQueryPoolResults_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyQueryPoolResults_CallbackFunctionPointer(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags, Mock.vkCmdCopyQueryPoolResults_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyQueryPoolResults,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queryPool) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyQueryPoolResults,CMockString_queryPool); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), sizeof(VkQueryPool), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstQuery) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyQueryPoolResults,CMockString_firstQuery); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstQuery, firstQuery, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queryCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyQueryPoolResults,CMockString_queryCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_queryCount, queryCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dstBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyQueryPoolResults,CMockString_dstBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dstBuffer), (void*)(&dstBuffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dstOffset) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyQueryPoolResults,CMockString_dstOffset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dstOffset), (void*)(&dstOffset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_stride) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyQueryPoolResults,CMockString_stride); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_stride), (void*)(&stride), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_flags) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyQueryPoolResults,CMockString_flags); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_flags), (void*)(&flags), sizeof(VkQueryResultFlags), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdCopyQueryPoolResults_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyQueryPoolResults_CallbackFunctionPointer(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags, Mock.vkCmdCopyQueryPoolResults_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdCopyQueryPoolResults(CMOCK_vkCmdCopyQueryPoolResults_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags); +void CMockExpectParameters_vkCmdCopyQueryPoolResults(CMOCK_vkCmdCopyQueryPoolResults_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), + sizeof(VkQueryPool[sizeof(queryPool) == sizeof(VkQueryPool) ? 1 : -1])); /* add VkQueryPool to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queryPool = 0; + cmock_call_instance->Expected_firstQuery = firstQuery; + cmock_call_instance->IgnoreArg_firstQuery = 0; + cmock_call_instance->Expected_queryCount = queryCount; + cmock_call_instance->IgnoreArg_queryCount = 0; + memcpy((void*)(&cmock_call_instance->Expected_dstBuffer), (void*)(&dstBuffer), + sizeof(VkBuffer[sizeof(dstBuffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dstBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_dstOffset), (void*)(&dstOffset), + sizeof(VkDeviceSize[sizeof(dstOffset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dstOffset = 0; + memcpy((void*)(&cmock_call_instance->Expected_stride), (void*)(&stride), + sizeof(VkDeviceSize[sizeof(stride) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_stride = 0; + memcpy((void*)(&cmock_call_instance->Expected_flags), (void*)(&flags), + sizeof(VkQueryResultFlags[sizeof(flags) == sizeof(VkQueryResultFlags) ? 1 : -1])); /* add VkQueryResultFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_flags = 0; +} + +void vkCmdCopyQueryPoolResults_CMockIgnore(void) +{ + Mock.vkCmdCopyQueryPoolResults_IgnoreBool = (char)1; +} + +void vkCmdCopyQueryPoolResults_CMockStopIgnore(void) +{ + Mock.vkCmdCopyQueryPoolResults_IgnoreBool = (char)0; +} + +void vkCmdCopyQueryPoolResults_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyQueryPoolResults_CALL_INSTANCE)); + CMOCK_vkCmdCopyQueryPoolResults_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyQueryPoolResults_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyQueryPoolResults_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyQueryPoolResults_CallInstance, cmock_guts_index); + Mock.vkCmdCopyQueryPoolResults_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdCopyQueryPoolResults_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyQueryPoolResults_CALL_INSTANCE)); + CMOCK_vkCmdCopyQueryPoolResults_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyQueryPoolResults_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyQueryPoolResults_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyQueryPoolResults_CallInstance, cmock_guts_index); + Mock.vkCmdCopyQueryPoolResults_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdCopyQueryPoolResults(cmock_call_instance, commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); +} + +void vkCmdCopyQueryPoolResults_AddCallback(CMOCK_vkCmdCopyQueryPoolResults_CALLBACK Callback) +{ + Mock.vkCmdCopyQueryPoolResults_IgnoreBool = (char)0; + Mock.vkCmdCopyQueryPoolResults_CallbackBool = (char)1; + Mock.vkCmdCopyQueryPoolResults_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyQueryPoolResults_Stub(CMOCK_vkCmdCopyQueryPoolResults_CALLBACK Callback) +{ + Mock.vkCmdCopyQueryPoolResults_IgnoreBool = (char)0; + Mock.vkCmdCopyQueryPoolResults_CallbackBool = (char)0; + Mock.vkCmdCopyQueryPoolResults_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyQueryPoolResults_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyQueryPoolResults_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyQueryPoolResults_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyQueryPoolResults_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdCopyQueryPoolResults_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyQueryPoolResults_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyQueryPoolResults_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyQueryPoolResults_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queryPool = 1; +} + +void vkCmdCopyQueryPoolResults_CMockIgnoreArg_firstQuery(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyQueryPoolResults_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyQueryPoolResults_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyQueryPoolResults_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstQuery = 1; +} + +void vkCmdCopyQueryPoolResults_CMockIgnoreArg_queryCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyQueryPoolResults_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyQueryPoolResults_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyQueryPoolResults_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queryCount = 1; +} + +void vkCmdCopyQueryPoolResults_CMockIgnoreArg_dstBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyQueryPoolResults_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyQueryPoolResults_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyQueryPoolResults_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dstBuffer = 1; +} + +void vkCmdCopyQueryPoolResults_CMockIgnoreArg_dstOffset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyQueryPoolResults_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyQueryPoolResults_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyQueryPoolResults_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dstOffset = 1; +} + +void vkCmdCopyQueryPoolResults_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyQueryPoolResults_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyQueryPoolResults_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyQueryPoolResults_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stride = 1; +} + +void vkCmdCopyQueryPoolResults_CMockIgnoreArg_flags(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyQueryPoolResults_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyQueryPoolResults_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyQueryPoolResults_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_flags = 1; +} + +void vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdPushConstants_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdPushConstants); + cmock_call_instance = (CMOCK_vkCmdPushConstants_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdPushConstants_CallInstance); + Mock.vkCmdPushConstants_CallInstance = CMock_Guts_MemNext(Mock.vkCmdPushConstants_CallInstance); + if (Mock.vkCmdPushConstants_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdPushConstants_CallbackBool && + Mock.vkCmdPushConstants_CallbackFunctionPointer != NULL) + { + Mock.vkCmdPushConstants_CallbackFunctionPointer(commandBuffer, layout, stageFlags, offset, size, pValues, Mock.vkCmdPushConstants_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdPushConstants,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_layout) + { + UNITY_SET_DETAILS(CMockString_vkCmdPushConstants,CMockString_layout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_layout), (void*)(&layout), sizeof(VkPipelineLayout), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_stageFlags) + { + UNITY_SET_DETAILS(CMockString_vkCmdPushConstants,CMockString_stageFlags); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_stageFlags), (void*)(&stageFlags), sizeof(VkShaderStageFlags), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_offset) + { + UNITY_SET_DETAILS(CMockString_vkCmdPushConstants,CMockString_offset); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_offset, offset, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_size) + { + UNITY_SET_DETAILS(CMockString_vkCmdPushConstants,CMockString_size); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_size, size, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pValues) + { + UNITY_SET_DETAILS(CMockString_vkCmdPushConstants,CMockString_pValues); + if (cmock_call_instance->Expected_pValues == NULL) + { UNITY_TEST_ASSERT_NULL(pValues, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(cmock_call_instance->Expected_pValues, pValues, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkCmdPushConstants_CallbackFunctionPointer != NULL) + { + Mock.vkCmdPushConstants_CallbackFunctionPointer(commandBuffer, layout, stageFlags, offset, size, pValues, Mock.vkCmdPushConstants_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdPushConstants(CMOCK_vkCmdPushConstants_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues); +void CMockExpectParameters_vkCmdPushConstants(CMOCK_vkCmdPushConstants_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_layout), (void*)(&layout), + sizeof(VkPipelineLayout[sizeof(layout) == sizeof(VkPipelineLayout) ? 1 : -1])); /* add VkPipelineLayout to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_layout = 0; + memcpy((void*)(&cmock_call_instance->Expected_stageFlags), (void*)(&stageFlags), + sizeof(VkShaderStageFlags[sizeof(stageFlags) == sizeof(VkShaderStageFlags) ? 1 : -1])); /* add VkShaderStageFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_stageFlags = 0; + cmock_call_instance->Expected_offset = offset; + cmock_call_instance->IgnoreArg_offset = 0; + cmock_call_instance->Expected_size = size; + cmock_call_instance->IgnoreArg_size = 0; + cmock_call_instance->Expected_pValues = pValues; + cmock_call_instance->IgnoreArg_pValues = 0; +} + +void vkCmdPushConstants_CMockIgnore(void) +{ + Mock.vkCmdPushConstants_IgnoreBool = (char)1; +} + +void vkCmdPushConstants_CMockStopIgnore(void) +{ + Mock.vkCmdPushConstants_IgnoreBool = (char)0; +} + +void vkCmdPushConstants_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdPushConstants_CALL_INSTANCE)); + CMOCK_vkCmdPushConstants_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPushConstants_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdPushConstants_CallInstance = CMock_Guts_MemChain(Mock.vkCmdPushConstants_CallInstance, cmock_guts_index); + Mock.vkCmdPushConstants_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdPushConstants_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdPushConstants_CALL_INSTANCE)); + CMOCK_vkCmdPushConstants_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPushConstants_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdPushConstants_CallInstance = CMock_Guts_MemChain(Mock.vkCmdPushConstants_CallInstance, cmock_guts_index); + Mock.vkCmdPushConstants_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdPushConstants(cmock_call_instance, commandBuffer, layout, stageFlags, offset, size, pValues); +} + +void vkCmdPushConstants_AddCallback(CMOCK_vkCmdPushConstants_CALLBACK Callback) +{ + Mock.vkCmdPushConstants_IgnoreBool = (char)0; + Mock.vkCmdPushConstants_CallbackBool = (char)1; + Mock.vkCmdPushConstants_CallbackFunctionPointer = Callback; +} + +void vkCmdPushConstants_Stub(CMOCK_vkCmdPushConstants_CALLBACK Callback) +{ + Mock.vkCmdPushConstants_IgnoreBool = (char)0; + Mock.vkCmdPushConstants_CallbackBool = (char)0; + Mock.vkCmdPushConstants_CallbackFunctionPointer = Callback; +} + +void vkCmdPushConstants_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPushConstants_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPushConstants_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPushConstants_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdPushConstants_CMockIgnoreArg_layout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPushConstants_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPushConstants_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPushConstants_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_layout = 1; +} + +void vkCmdPushConstants_CMockIgnoreArg_stageFlags(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPushConstants_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPushConstants_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPushConstants_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stageFlags = 1; +} + +void vkCmdPushConstants_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPushConstants_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPushConstants_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPushConstants_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_offset = 1; +} + +void vkCmdPushConstants_CMockIgnoreArg_size(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPushConstants_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPushConstants_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPushConstants_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_size = 1; +} + +void vkCmdPushConstants_CMockIgnoreArg_pValues(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPushConstants_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPushConstants_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPushConstants_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pValues = 1; +} + +void vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBeginRenderPass_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBeginRenderPass); + cmock_call_instance = (CMOCK_vkCmdBeginRenderPass_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBeginRenderPass_CallInstance); + Mock.vkCmdBeginRenderPass_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBeginRenderPass_CallInstance); + if (Mock.vkCmdBeginRenderPass_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBeginRenderPass_CallbackBool && + Mock.vkCmdBeginRenderPass_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBeginRenderPass_CallbackFunctionPointer(commandBuffer, pRenderPassBegin, contents, Mock.vkCmdBeginRenderPass_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginRenderPass,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pRenderPassBegin) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginRenderPass,CMockString_pRenderPassBegin); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pRenderPassBegin), (void*)(pRenderPassBegin), sizeof(const VkRenderPassBeginInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_contents) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginRenderPass,CMockString_contents); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_contents), (void*)(&contents), sizeof(VkSubpassContents), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdBeginRenderPass_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBeginRenderPass_CallbackFunctionPointer(commandBuffer, pRenderPassBegin, contents, Mock.vkCmdBeginRenderPass_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBeginRenderPass(CMOCK_vkCmdBeginRenderPass_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents); +void CMockExpectParameters_vkCmdBeginRenderPass(CMOCK_vkCmdBeginRenderPass_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pRenderPassBegin = pRenderPassBegin; + cmock_call_instance->IgnoreArg_pRenderPassBegin = 0; + memcpy((void*)(&cmock_call_instance->Expected_contents), (void*)(&contents), + sizeof(VkSubpassContents[sizeof(contents) == sizeof(VkSubpassContents) ? 1 : -1])); /* add VkSubpassContents to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_contents = 0; +} + +void vkCmdBeginRenderPass_CMockIgnore(void) +{ + Mock.vkCmdBeginRenderPass_IgnoreBool = (char)1; +} + +void vkCmdBeginRenderPass_CMockStopIgnore(void) +{ + Mock.vkCmdBeginRenderPass_IgnoreBool = (char)0; +} + +void vkCmdBeginRenderPass_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBeginRenderPass_CALL_INSTANCE)); + CMOCK_vkCmdBeginRenderPass_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginRenderPass_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBeginRenderPass_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBeginRenderPass_CallInstance, cmock_guts_index); + Mock.vkCmdBeginRenderPass_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBeginRenderPass_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBeginRenderPass_CALL_INSTANCE)); + CMOCK_vkCmdBeginRenderPass_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginRenderPass_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBeginRenderPass_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBeginRenderPass_CallInstance, cmock_guts_index); + Mock.vkCmdBeginRenderPass_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBeginRenderPass(cmock_call_instance, commandBuffer, pRenderPassBegin, contents); +} + +void vkCmdBeginRenderPass_AddCallback(CMOCK_vkCmdBeginRenderPass_CALLBACK Callback) +{ + Mock.vkCmdBeginRenderPass_IgnoreBool = (char)0; + Mock.vkCmdBeginRenderPass_CallbackBool = (char)1; + Mock.vkCmdBeginRenderPass_CallbackFunctionPointer = Callback; +} + +void vkCmdBeginRenderPass_Stub(CMOCK_vkCmdBeginRenderPass_CALLBACK Callback) +{ + Mock.vkCmdBeginRenderPass_IgnoreBool = (char)0; + Mock.vkCmdBeginRenderPass_CallbackBool = (char)0; + Mock.vkCmdBeginRenderPass_CallbackFunctionPointer = Callback; +} + +void vkCmdBeginRenderPass_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginRenderPass_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginRenderPass_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginRenderPass_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBeginRenderPass_CMockIgnoreArg_pRenderPassBegin(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginRenderPass_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginRenderPass_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginRenderPass_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pRenderPassBegin = 1; +} + +void vkCmdBeginRenderPass_CMockIgnoreArg_contents(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginRenderPass_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginRenderPass_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginRenderPass_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_contents = 1; +} + +void vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdNextSubpass_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdNextSubpass); + cmock_call_instance = (CMOCK_vkCmdNextSubpass_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdNextSubpass_CallInstance); + Mock.vkCmdNextSubpass_CallInstance = CMock_Guts_MemNext(Mock.vkCmdNextSubpass_CallInstance); + if (Mock.vkCmdNextSubpass_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdNextSubpass_CallbackBool && + Mock.vkCmdNextSubpass_CallbackFunctionPointer != NULL) + { + Mock.vkCmdNextSubpass_CallbackFunctionPointer(commandBuffer, contents, Mock.vkCmdNextSubpass_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdNextSubpass,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_contents) + { + UNITY_SET_DETAILS(CMockString_vkCmdNextSubpass,CMockString_contents); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_contents), (void*)(&contents), sizeof(VkSubpassContents), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdNextSubpass_CallbackFunctionPointer != NULL) + { + Mock.vkCmdNextSubpass_CallbackFunctionPointer(commandBuffer, contents, Mock.vkCmdNextSubpass_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdNextSubpass(CMOCK_vkCmdNextSubpass_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkSubpassContents contents); +void CMockExpectParameters_vkCmdNextSubpass(CMOCK_vkCmdNextSubpass_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkSubpassContents contents) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_contents), (void*)(&contents), + sizeof(VkSubpassContents[sizeof(contents) == sizeof(VkSubpassContents) ? 1 : -1])); /* add VkSubpassContents to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_contents = 0; +} + +void vkCmdNextSubpass_CMockIgnore(void) +{ + Mock.vkCmdNextSubpass_IgnoreBool = (char)1; +} + +void vkCmdNextSubpass_CMockStopIgnore(void) +{ + Mock.vkCmdNextSubpass_IgnoreBool = (char)0; +} + +void vkCmdNextSubpass_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdNextSubpass_CALL_INSTANCE)); + CMOCK_vkCmdNextSubpass_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdNextSubpass_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdNextSubpass_CallInstance = CMock_Guts_MemChain(Mock.vkCmdNextSubpass_CallInstance, cmock_guts_index); + Mock.vkCmdNextSubpass_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdNextSubpass_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkSubpassContents contents) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdNextSubpass_CALL_INSTANCE)); + CMOCK_vkCmdNextSubpass_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdNextSubpass_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdNextSubpass_CallInstance = CMock_Guts_MemChain(Mock.vkCmdNextSubpass_CallInstance, cmock_guts_index); + Mock.vkCmdNextSubpass_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdNextSubpass(cmock_call_instance, commandBuffer, contents); +} + +void vkCmdNextSubpass_AddCallback(CMOCK_vkCmdNextSubpass_CALLBACK Callback) +{ + Mock.vkCmdNextSubpass_IgnoreBool = (char)0; + Mock.vkCmdNextSubpass_CallbackBool = (char)1; + Mock.vkCmdNextSubpass_CallbackFunctionPointer = Callback; +} + +void vkCmdNextSubpass_Stub(CMOCK_vkCmdNextSubpass_CALLBACK Callback) +{ + Mock.vkCmdNextSubpass_IgnoreBool = (char)0; + Mock.vkCmdNextSubpass_CallbackBool = (char)0; + Mock.vkCmdNextSubpass_CallbackFunctionPointer = Callback; +} + +void vkCmdNextSubpass_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdNextSubpass_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdNextSubpass_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdNextSubpass_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdNextSubpass_CMockIgnoreArg_contents(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdNextSubpass_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdNextSubpass_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdNextSubpass_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_contents = 1; +} + +void vkCmdEndRenderPass(VkCommandBuffer commandBuffer) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdEndRenderPass_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdEndRenderPass); + cmock_call_instance = (CMOCK_vkCmdEndRenderPass_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdEndRenderPass_CallInstance); + Mock.vkCmdEndRenderPass_CallInstance = CMock_Guts_MemNext(Mock.vkCmdEndRenderPass_CallInstance); + if (Mock.vkCmdEndRenderPass_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdEndRenderPass_CallbackBool && + Mock.vkCmdEndRenderPass_CallbackFunctionPointer != NULL) + { + Mock.vkCmdEndRenderPass_CallbackFunctionPointer(commandBuffer, Mock.vkCmdEndRenderPass_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdEndRenderPass,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdEndRenderPass_CallbackFunctionPointer != NULL) + { + Mock.vkCmdEndRenderPass_CallbackFunctionPointer(commandBuffer, Mock.vkCmdEndRenderPass_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdEndRenderPass(CMOCK_vkCmdEndRenderPass_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer); +void CMockExpectParameters_vkCmdEndRenderPass(CMOCK_vkCmdEndRenderPass_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; +} + +void vkCmdEndRenderPass_CMockIgnore(void) +{ + Mock.vkCmdEndRenderPass_IgnoreBool = (char)1; +} + +void vkCmdEndRenderPass_CMockStopIgnore(void) +{ + Mock.vkCmdEndRenderPass_IgnoreBool = (char)0; +} + +void vkCmdEndRenderPass_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdEndRenderPass_CALL_INSTANCE)); + CMOCK_vkCmdEndRenderPass_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndRenderPass_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdEndRenderPass_CallInstance = CMock_Guts_MemChain(Mock.vkCmdEndRenderPass_CallInstance, cmock_guts_index); + Mock.vkCmdEndRenderPass_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdEndRenderPass_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdEndRenderPass_CALL_INSTANCE)); + CMOCK_vkCmdEndRenderPass_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndRenderPass_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdEndRenderPass_CallInstance = CMock_Guts_MemChain(Mock.vkCmdEndRenderPass_CallInstance, cmock_guts_index); + Mock.vkCmdEndRenderPass_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdEndRenderPass(cmock_call_instance, commandBuffer); +} + +void vkCmdEndRenderPass_AddCallback(CMOCK_vkCmdEndRenderPass_CALLBACK Callback) +{ + Mock.vkCmdEndRenderPass_IgnoreBool = (char)0; + Mock.vkCmdEndRenderPass_CallbackBool = (char)1; + Mock.vkCmdEndRenderPass_CallbackFunctionPointer = Callback; +} + +void vkCmdEndRenderPass_Stub(CMOCK_vkCmdEndRenderPass_CALLBACK Callback) +{ + Mock.vkCmdEndRenderPass_IgnoreBool = (char)0; + Mock.vkCmdEndRenderPass_CallbackBool = (char)0; + Mock.vkCmdEndRenderPass_CallbackFunctionPointer = Callback; +} + +void vkCmdEndRenderPass_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdEndRenderPass_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndRenderPass_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdEndRenderPass_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdExecuteCommands_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdExecuteCommands); + cmock_call_instance = (CMOCK_vkCmdExecuteCommands_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdExecuteCommands_CallInstance); + Mock.vkCmdExecuteCommands_CallInstance = CMock_Guts_MemNext(Mock.vkCmdExecuteCommands_CallInstance); + if (Mock.vkCmdExecuteCommands_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdExecuteCommands_CallbackBool && + Mock.vkCmdExecuteCommands_CallbackFunctionPointer != NULL) + { + Mock.vkCmdExecuteCommands_CallbackFunctionPointer(commandBuffer, commandBufferCount, pCommandBuffers, Mock.vkCmdExecuteCommands_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdExecuteCommands,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_commandBufferCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdExecuteCommands,CMockString_commandBufferCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_commandBufferCount, commandBufferCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCommandBuffers) + { + UNITY_SET_DETAILS(CMockString_vkCmdExecuteCommands,CMockString_pCommandBuffers); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCommandBuffers), (void*)(pCommandBuffers), sizeof(const VkCommandBuffer), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdExecuteCommands_CallbackFunctionPointer != NULL) + { + Mock.vkCmdExecuteCommands_CallbackFunctionPointer(commandBuffer, commandBufferCount, pCommandBuffers, Mock.vkCmdExecuteCommands_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdExecuteCommands(CMOCK_vkCmdExecuteCommands_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); +void CMockExpectParameters_vkCmdExecuteCommands(CMOCK_vkCmdExecuteCommands_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_commandBufferCount = commandBufferCount; + cmock_call_instance->IgnoreArg_commandBufferCount = 0; + cmock_call_instance->Expected_pCommandBuffers = pCommandBuffers; + cmock_call_instance->IgnoreArg_pCommandBuffers = 0; +} + +void vkCmdExecuteCommands_CMockIgnore(void) +{ + Mock.vkCmdExecuteCommands_IgnoreBool = (char)1; +} + +void vkCmdExecuteCommands_CMockStopIgnore(void) +{ + Mock.vkCmdExecuteCommands_IgnoreBool = (char)0; +} + +void vkCmdExecuteCommands_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdExecuteCommands_CALL_INSTANCE)); + CMOCK_vkCmdExecuteCommands_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdExecuteCommands_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdExecuteCommands_CallInstance = CMock_Guts_MemChain(Mock.vkCmdExecuteCommands_CallInstance, cmock_guts_index); + Mock.vkCmdExecuteCommands_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdExecuteCommands_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdExecuteCommands_CALL_INSTANCE)); + CMOCK_vkCmdExecuteCommands_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdExecuteCommands_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdExecuteCommands_CallInstance = CMock_Guts_MemChain(Mock.vkCmdExecuteCommands_CallInstance, cmock_guts_index); + Mock.vkCmdExecuteCommands_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdExecuteCommands(cmock_call_instance, commandBuffer, commandBufferCount, pCommandBuffers); +} + +void vkCmdExecuteCommands_AddCallback(CMOCK_vkCmdExecuteCommands_CALLBACK Callback) +{ + Mock.vkCmdExecuteCommands_IgnoreBool = (char)0; + Mock.vkCmdExecuteCommands_CallbackBool = (char)1; + Mock.vkCmdExecuteCommands_CallbackFunctionPointer = Callback; +} + +void vkCmdExecuteCommands_Stub(CMOCK_vkCmdExecuteCommands_CALLBACK Callback) +{ + Mock.vkCmdExecuteCommands_IgnoreBool = (char)0; + Mock.vkCmdExecuteCommands_CallbackBool = (char)0; + Mock.vkCmdExecuteCommands_CallbackFunctionPointer = Callback; +} + +void vkCmdExecuteCommands_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdExecuteCommands_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdExecuteCommands_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdExecuteCommands_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdExecuteCommands_CMockIgnoreArg_commandBufferCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdExecuteCommands_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdExecuteCommands_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdExecuteCommands_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBufferCount = 1; +} + +void vkCmdExecuteCommands_CMockIgnoreArg_pCommandBuffers(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdExecuteCommands_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdExecuteCommands_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdExecuteCommands_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCommandBuffers = 1; +} + +VkResult vkEnumerateInstanceVersion(uint32_t* pApiVersion) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkEnumerateInstanceVersion_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkEnumerateInstanceVersion); + cmock_call_instance = (CMOCK_vkEnumerateInstanceVersion_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkEnumerateInstanceVersion_CallInstance); + Mock.vkEnumerateInstanceVersion_CallInstance = CMock_Guts_MemNext(Mock.vkEnumerateInstanceVersion_CallInstance); + if (Mock.vkEnumerateInstanceVersion_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkEnumerateInstanceVersion_FinalReturn; + memcpy((void*)(&Mock.vkEnumerateInstanceVersion_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkEnumerateInstanceVersion_CallbackBool && + Mock.vkEnumerateInstanceVersion_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkEnumerateInstanceVersion_CallbackFunctionPointer(pApiVersion, Mock.vkEnumerateInstanceVersion_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_pApiVersion) + { + UNITY_SET_DETAILS(CMockString_vkEnumerateInstanceVersion,CMockString_pApiVersion); + if (cmock_call_instance->Expected_pApiVersion == NULL) + { UNITY_TEST_ASSERT_NULL(pApiVersion, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pApiVersion, pApiVersion, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkEnumerateInstanceVersion_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkEnumerateInstanceVersion_CallbackFunctionPointer(pApiVersion, Mock.vkEnumerateInstanceVersion_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pApiVersion_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pApiVersion, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pApiVersion, (const void*)cmock_call_instance->ReturnThruPtr_pApiVersion_Val, + cmock_call_instance->ReturnThruPtr_pApiVersion_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkEnumerateInstanceVersion(CMOCK_vkEnumerateInstanceVersion_CALL_INSTANCE* cmock_call_instance, uint32_t* pApiVersion); +void CMockExpectParameters_vkEnumerateInstanceVersion(CMOCK_vkEnumerateInstanceVersion_CALL_INSTANCE* cmock_call_instance, uint32_t* pApiVersion) +{ + cmock_call_instance->Expected_pApiVersion = pApiVersion; + cmock_call_instance->IgnoreArg_pApiVersion = 0; + cmock_call_instance->ReturnThruPtr_pApiVersion_Used = 0; +} + +void vkEnumerateInstanceVersion_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkEnumerateInstanceVersion_CALL_INSTANCE)); + CMOCK_vkEnumerateInstanceVersion_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateInstanceVersion_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkEnumerateInstanceVersion_CallInstance = CMock_Guts_MemChain(Mock.vkEnumerateInstanceVersion_CallInstance, cmock_guts_index); + Mock.vkEnumerateInstanceVersion_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkEnumerateInstanceVersion_IgnoreBool = (char)1; +} + +void vkEnumerateInstanceVersion_CMockStopIgnore(void) +{ + if(Mock.vkEnumerateInstanceVersion_IgnoreBool) + Mock.vkEnumerateInstanceVersion_CallInstance = CMock_Guts_MemNext(Mock.vkEnumerateInstanceVersion_CallInstance); + Mock.vkEnumerateInstanceVersion_IgnoreBool = (char)0; +} + +void vkEnumerateInstanceVersion_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkEnumerateInstanceVersion_CALL_INSTANCE)); + CMOCK_vkEnumerateInstanceVersion_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateInstanceVersion_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkEnumerateInstanceVersion_CallInstance = CMock_Guts_MemChain(Mock.vkEnumerateInstanceVersion_CallInstance, cmock_guts_index); + Mock.vkEnumerateInstanceVersion_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkEnumerateInstanceVersion_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, uint32_t* pApiVersion, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkEnumerateInstanceVersion_CALL_INSTANCE)); + CMOCK_vkEnumerateInstanceVersion_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateInstanceVersion_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkEnumerateInstanceVersion_CallInstance = CMock_Guts_MemChain(Mock.vkEnumerateInstanceVersion_CallInstance, cmock_guts_index); + Mock.vkEnumerateInstanceVersion_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkEnumerateInstanceVersion(cmock_call_instance, pApiVersion); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkEnumerateInstanceVersion_AddCallback(CMOCK_vkEnumerateInstanceVersion_CALLBACK Callback) +{ + Mock.vkEnumerateInstanceVersion_IgnoreBool = (char)0; + Mock.vkEnumerateInstanceVersion_CallbackBool = (char)1; + Mock.vkEnumerateInstanceVersion_CallbackFunctionPointer = Callback; +} + +void vkEnumerateInstanceVersion_Stub(CMOCK_vkEnumerateInstanceVersion_CALLBACK Callback) +{ + Mock.vkEnumerateInstanceVersion_IgnoreBool = (char)0; + Mock.vkEnumerateInstanceVersion_CallbackBool = (char)0; + Mock.vkEnumerateInstanceVersion_CallbackFunctionPointer = Callback; +} + +void vkEnumerateInstanceVersion_CMockReturnMemThruPtr_pApiVersion(UNITY_LINE_TYPE cmock_line, uint32_t const* pApiVersion, size_t cmock_size) +{ + CMOCK_vkEnumerateInstanceVersion_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateInstanceVersion_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumerateInstanceVersion_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pApiVersion_Used = 1; + cmock_call_instance->ReturnThruPtr_pApiVersion_Val = pApiVersion; + cmock_call_instance->ReturnThruPtr_pApiVersion_Size = cmock_size; +} + +void vkEnumerateInstanceVersion_CMockIgnoreArg_pApiVersion(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkEnumerateInstanceVersion_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumerateInstanceVersion_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumerateInstanceVersion_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pApiVersion = 1; +} + +VkResult vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkBindBufferMemory2_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkBindBufferMemory2); + cmock_call_instance = (CMOCK_vkBindBufferMemory2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkBindBufferMemory2_CallInstance); + Mock.vkBindBufferMemory2_CallInstance = CMock_Guts_MemNext(Mock.vkBindBufferMemory2_CallInstance); + if (Mock.vkBindBufferMemory2_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkBindBufferMemory2_FinalReturn; + memcpy((void*)(&Mock.vkBindBufferMemory2_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkBindBufferMemory2_CallbackBool && + Mock.vkBindBufferMemory2_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkBindBufferMemory2_CallbackFunctionPointer(device, bindInfoCount, pBindInfos, Mock.vkBindBufferMemory2_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkBindBufferMemory2,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_bindInfoCount) + { + UNITY_SET_DETAILS(CMockString_vkBindBufferMemory2,CMockString_bindInfoCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_bindInfoCount, bindInfoCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pBindInfos) + { + UNITY_SET_DETAILS(CMockString_vkBindBufferMemory2,CMockString_pBindInfos); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pBindInfos), (void*)(pBindInfos), sizeof(const VkBindBufferMemoryInfo), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkBindBufferMemory2_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkBindBufferMemory2_CallbackFunctionPointer(device, bindInfoCount, pBindInfos, Mock.vkBindBufferMemory2_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkBindBufferMemory2(CMOCK_vkBindBufferMemory2_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); +void CMockExpectParameters_vkBindBufferMemory2(CMOCK_vkBindBufferMemory2_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_bindInfoCount = bindInfoCount; + cmock_call_instance->IgnoreArg_bindInfoCount = 0; + cmock_call_instance->Expected_pBindInfos = pBindInfos; + cmock_call_instance->IgnoreArg_pBindInfos = 0; +} + +void vkBindBufferMemory2_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBindBufferMemory2_CALL_INSTANCE)); + CMOCK_vkBindBufferMemory2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindBufferMemory2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBindBufferMemory2_CallInstance = CMock_Guts_MemChain(Mock.vkBindBufferMemory2_CallInstance, cmock_guts_index); + Mock.vkBindBufferMemory2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkBindBufferMemory2_IgnoreBool = (char)1; +} + +void vkBindBufferMemory2_CMockStopIgnore(void) +{ + if(Mock.vkBindBufferMemory2_IgnoreBool) + Mock.vkBindBufferMemory2_CallInstance = CMock_Guts_MemNext(Mock.vkBindBufferMemory2_CallInstance); + Mock.vkBindBufferMemory2_IgnoreBool = (char)0; +} + +void vkBindBufferMemory2_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBindBufferMemory2_CALL_INSTANCE)); + CMOCK_vkBindBufferMemory2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindBufferMemory2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBindBufferMemory2_CallInstance = CMock_Guts_MemChain(Mock.vkBindBufferMemory2_CallInstance, cmock_guts_index); + Mock.vkBindBufferMemory2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkBindBufferMemory2_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBindBufferMemory2_CALL_INSTANCE)); + CMOCK_vkBindBufferMemory2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindBufferMemory2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBindBufferMemory2_CallInstance = CMock_Guts_MemChain(Mock.vkBindBufferMemory2_CallInstance, cmock_guts_index); + Mock.vkBindBufferMemory2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkBindBufferMemory2(cmock_call_instance, device, bindInfoCount, pBindInfos); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkBindBufferMemory2_AddCallback(CMOCK_vkBindBufferMemory2_CALLBACK Callback) +{ + Mock.vkBindBufferMemory2_IgnoreBool = (char)0; + Mock.vkBindBufferMemory2_CallbackBool = (char)1; + Mock.vkBindBufferMemory2_CallbackFunctionPointer = Callback; +} + +void vkBindBufferMemory2_Stub(CMOCK_vkBindBufferMemory2_CALLBACK Callback) +{ + Mock.vkBindBufferMemory2_IgnoreBool = (char)0; + Mock.vkBindBufferMemory2_CallbackBool = (char)0; + Mock.vkBindBufferMemory2_CallbackFunctionPointer = Callback; +} + +void vkBindBufferMemory2_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindBufferMemory2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindBufferMemory2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindBufferMemory2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkBindBufferMemory2_CMockIgnoreArg_bindInfoCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindBufferMemory2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindBufferMemory2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindBufferMemory2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_bindInfoCount = 1; +} + +void vkBindBufferMemory2_CMockIgnoreArg_pBindInfos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindBufferMemory2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindBufferMemory2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindBufferMemory2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pBindInfos = 1; +} + +VkResult vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkBindImageMemory2_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkBindImageMemory2); + cmock_call_instance = (CMOCK_vkBindImageMemory2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkBindImageMemory2_CallInstance); + Mock.vkBindImageMemory2_CallInstance = CMock_Guts_MemNext(Mock.vkBindImageMemory2_CallInstance); + if (Mock.vkBindImageMemory2_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkBindImageMemory2_FinalReturn; + memcpy((void*)(&Mock.vkBindImageMemory2_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkBindImageMemory2_CallbackBool && + Mock.vkBindImageMemory2_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkBindImageMemory2_CallbackFunctionPointer(device, bindInfoCount, pBindInfos, Mock.vkBindImageMemory2_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkBindImageMemory2,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_bindInfoCount) + { + UNITY_SET_DETAILS(CMockString_vkBindImageMemory2,CMockString_bindInfoCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_bindInfoCount, bindInfoCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pBindInfos) + { + UNITY_SET_DETAILS(CMockString_vkBindImageMemory2,CMockString_pBindInfos); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pBindInfos), (void*)(pBindInfos), sizeof(const VkBindImageMemoryInfo), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkBindImageMemory2_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkBindImageMemory2_CallbackFunctionPointer(device, bindInfoCount, pBindInfos, Mock.vkBindImageMemory2_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkBindImageMemory2(CMOCK_vkBindImageMemory2_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); +void CMockExpectParameters_vkBindImageMemory2(CMOCK_vkBindImageMemory2_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_bindInfoCount = bindInfoCount; + cmock_call_instance->IgnoreArg_bindInfoCount = 0; + cmock_call_instance->Expected_pBindInfos = pBindInfos; + cmock_call_instance->IgnoreArg_pBindInfos = 0; +} + +void vkBindImageMemory2_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBindImageMemory2_CALL_INSTANCE)); + CMOCK_vkBindImageMemory2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindImageMemory2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBindImageMemory2_CallInstance = CMock_Guts_MemChain(Mock.vkBindImageMemory2_CallInstance, cmock_guts_index); + Mock.vkBindImageMemory2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkBindImageMemory2_IgnoreBool = (char)1; +} + +void vkBindImageMemory2_CMockStopIgnore(void) +{ + if(Mock.vkBindImageMemory2_IgnoreBool) + Mock.vkBindImageMemory2_CallInstance = CMock_Guts_MemNext(Mock.vkBindImageMemory2_CallInstance); + Mock.vkBindImageMemory2_IgnoreBool = (char)0; +} + +void vkBindImageMemory2_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBindImageMemory2_CALL_INSTANCE)); + CMOCK_vkBindImageMemory2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindImageMemory2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBindImageMemory2_CallInstance = CMock_Guts_MemChain(Mock.vkBindImageMemory2_CallInstance, cmock_guts_index); + Mock.vkBindImageMemory2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkBindImageMemory2_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBindImageMemory2_CALL_INSTANCE)); + CMOCK_vkBindImageMemory2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindImageMemory2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBindImageMemory2_CallInstance = CMock_Guts_MemChain(Mock.vkBindImageMemory2_CallInstance, cmock_guts_index); + Mock.vkBindImageMemory2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkBindImageMemory2(cmock_call_instance, device, bindInfoCount, pBindInfos); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkBindImageMemory2_AddCallback(CMOCK_vkBindImageMemory2_CALLBACK Callback) +{ + Mock.vkBindImageMemory2_IgnoreBool = (char)0; + Mock.vkBindImageMemory2_CallbackBool = (char)1; + Mock.vkBindImageMemory2_CallbackFunctionPointer = Callback; +} + +void vkBindImageMemory2_Stub(CMOCK_vkBindImageMemory2_CALLBACK Callback) +{ + Mock.vkBindImageMemory2_IgnoreBool = (char)0; + Mock.vkBindImageMemory2_CallbackBool = (char)0; + Mock.vkBindImageMemory2_CallbackFunctionPointer = Callback; +} + +void vkBindImageMemory2_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindImageMemory2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindImageMemory2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindImageMemory2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkBindImageMemory2_CMockIgnoreArg_bindInfoCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindImageMemory2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindImageMemory2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindImageMemory2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_bindInfoCount = 1; +} + +void vkBindImageMemory2_CMockIgnoreArg_pBindInfos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindImageMemory2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindImageMemory2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindImageMemory2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pBindInfos = 1; +} + +void vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDeviceGroupPeerMemoryFeatures_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDeviceGroupPeerMemoryFeatures); + cmock_call_instance = (CMOCK_vkGetDeviceGroupPeerMemoryFeatures_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDeviceGroupPeerMemoryFeatures_CallInstance); + Mock.vkGetDeviceGroupPeerMemoryFeatures_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeviceGroupPeerMemoryFeatures_CallInstance); + if (Mock.vkGetDeviceGroupPeerMemoryFeatures_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetDeviceGroupPeerMemoryFeatures_CallbackBool && + Mock.vkGetDeviceGroupPeerMemoryFeatures_CallbackFunctionPointer != NULL) + { + Mock.vkGetDeviceGroupPeerMemoryFeatures_CallbackFunctionPointer(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures, Mock.vkGetDeviceGroupPeerMemoryFeatures_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceGroupPeerMemoryFeatures,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_heapIndex) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceGroupPeerMemoryFeatures,CMockString_heapIndex); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_heapIndex, heapIndex, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_localDeviceIndex) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceGroupPeerMemoryFeatures,CMockString_localDeviceIndex); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_localDeviceIndex, localDeviceIndex, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_remoteDeviceIndex) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceGroupPeerMemoryFeatures,CMockString_remoteDeviceIndex); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_remoteDeviceIndex, remoteDeviceIndex, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPeerMemoryFeatures) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceGroupPeerMemoryFeatures,CMockString_pPeerMemoryFeatures); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pPeerMemoryFeatures), (void*)(pPeerMemoryFeatures), sizeof(VkPeerMemoryFeatureFlags), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDeviceGroupPeerMemoryFeatures_CallbackFunctionPointer != NULL) + { + Mock.vkGetDeviceGroupPeerMemoryFeatures_CallbackFunctionPointer(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures, Mock.vkGetDeviceGroupPeerMemoryFeatures_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPeerMemoryFeatures_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPeerMemoryFeatures, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPeerMemoryFeatures, (const void*)cmock_call_instance->ReturnThruPtr_pPeerMemoryFeatures_Val, + cmock_call_instance->ReturnThruPtr_pPeerMemoryFeatures_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetDeviceGroupPeerMemoryFeatures(CMOCK_vkGetDeviceGroupPeerMemoryFeatures_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); +void CMockExpectParameters_vkGetDeviceGroupPeerMemoryFeatures(CMOCK_vkGetDeviceGroupPeerMemoryFeatures_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_heapIndex = heapIndex; + cmock_call_instance->IgnoreArg_heapIndex = 0; + cmock_call_instance->Expected_localDeviceIndex = localDeviceIndex; + cmock_call_instance->IgnoreArg_localDeviceIndex = 0; + cmock_call_instance->Expected_remoteDeviceIndex = remoteDeviceIndex; + cmock_call_instance->IgnoreArg_remoteDeviceIndex = 0; + cmock_call_instance->Expected_pPeerMemoryFeatures = pPeerMemoryFeatures; + cmock_call_instance->IgnoreArg_pPeerMemoryFeatures = 0; + cmock_call_instance->ReturnThruPtr_pPeerMemoryFeatures_Used = 0; +} + +void vkGetDeviceGroupPeerMemoryFeatures_CMockIgnore(void) +{ + Mock.vkGetDeviceGroupPeerMemoryFeatures_IgnoreBool = (char)1; +} + +void vkGetDeviceGroupPeerMemoryFeatures_CMockStopIgnore(void) +{ + Mock.vkGetDeviceGroupPeerMemoryFeatures_IgnoreBool = (char)0; +} + +void vkGetDeviceGroupPeerMemoryFeatures_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceGroupPeerMemoryFeatures_CALL_INSTANCE)); + CMOCK_vkGetDeviceGroupPeerMemoryFeatures_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceGroupPeerMemoryFeatures_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceGroupPeerMemoryFeatures_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceGroupPeerMemoryFeatures_CallInstance, cmock_guts_index); + Mock.vkGetDeviceGroupPeerMemoryFeatures_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDeviceGroupPeerMemoryFeatures_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceGroupPeerMemoryFeatures_CALL_INSTANCE)); + CMOCK_vkGetDeviceGroupPeerMemoryFeatures_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceGroupPeerMemoryFeatures_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceGroupPeerMemoryFeatures_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceGroupPeerMemoryFeatures_CallInstance, cmock_guts_index); + Mock.vkGetDeviceGroupPeerMemoryFeatures_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDeviceGroupPeerMemoryFeatures(cmock_call_instance, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); +} + +void vkGetDeviceGroupPeerMemoryFeatures_AddCallback(CMOCK_vkGetDeviceGroupPeerMemoryFeatures_CALLBACK Callback) +{ + Mock.vkGetDeviceGroupPeerMemoryFeatures_IgnoreBool = (char)0; + Mock.vkGetDeviceGroupPeerMemoryFeatures_CallbackBool = (char)1; + Mock.vkGetDeviceGroupPeerMemoryFeatures_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceGroupPeerMemoryFeatures_Stub(CMOCK_vkGetDeviceGroupPeerMemoryFeatures_CALLBACK Callback) +{ + Mock.vkGetDeviceGroupPeerMemoryFeatures_IgnoreBool = (char)0; + Mock.vkGetDeviceGroupPeerMemoryFeatures_CallbackBool = (char)0; + Mock.vkGetDeviceGroupPeerMemoryFeatures_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceGroupPeerMemoryFeatures_CMockReturnMemThruPtr_pPeerMemoryFeatures(UNITY_LINE_TYPE cmock_line, VkPeerMemoryFeatureFlags const* pPeerMemoryFeatures, size_t cmock_size) +{ + CMOCK_vkGetDeviceGroupPeerMemoryFeatures_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceGroupPeerMemoryFeatures_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceGroupPeerMemoryFeatures_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPeerMemoryFeatures_Used = 1; + cmock_call_instance->ReturnThruPtr_pPeerMemoryFeatures_Val = pPeerMemoryFeatures; + cmock_call_instance->ReturnThruPtr_pPeerMemoryFeatures_Size = cmock_size; +} + +void vkGetDeviceGroupPeerMemoryFeatures_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceGroupPeerMemoryFeatures_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceGroupPeerMemoryFeatures_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceGroupPeerMemoryFeatures_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetDeviceGroupPeerMemoryFeatures_CMockIgnoreArg_heapIndex(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceGroupPeerMemoryFeatures_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceGroupPeerMemoryFeatures_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceGroupPeerMemoryFeatures_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_heapIndex = 1; +} + +void vkGetDeviceGroupPeerMemoryFeatures_CMockIgnoreArg_localDeviceIndex(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceGroupPeerMemoryFeatures_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceGroupPeerMemoryFeatures_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceGroupPeerMemoryFeatures_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_localDeviceIndex = 1; +} + +void vkGetDeviceGroupPeerMemoryFeatures_CMockIgnoreArg_remoteDeviceIndex(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceGroupPeerMemoryFeatures_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceGroupPeerMemoryFeatures_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceGroupPeerMemoryFeatures_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_remoteDeviceIndex = 1; +} + +void vkGetDeviceGroupPeerMemoryFeatures_CMockIgnoreArg_pPeerMemoryFeatures(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceGroupPeerMemoryFeatures_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceGroupPeerMemoryFeatures_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceGroupPeerMemoryFeatures_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPeerMemoryFeatures = 1; +} + +void vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetDeviceMask_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetDeviceMask); + cmock_call_instance = (CMOCK_vkCmdSetDeviceMask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetDeviceMask_CallInstance); + Mock.vkCmdSetDeviceMask_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetDeviceMask_CallInstance); + if (Mock.vkCmdSetDeviceMask_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetDeviceMask_CallbackBool && + Mock.vkCmdSetDeviceMask_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDeviceMask_CallbackFunctionPointer(commandBuffer, deviceMask, Mock.vkCmdSetDeviceMask_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDeviceMask,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_deviceMask) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDeviceMask,CMockString_deviceMask); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_deviceMask, deviceMask, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetDeviceMask_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDeviceMask_CallbackFunctionPointer(commandBuffer, deviceMask, Mock.vkCmdSetDeviceMask_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetDeviceMask(CMOCK_vkCmdSetDeviceMask_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t deviceMask); +void CMockExpectParameters_vkCmdSetDeviceMask(CMOCK_vkCmdSetDeviceMask_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t deviceMask) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_deviceMask = deviceMask; + cmock_call_instance->IgnoreArg_deviceMask = 0; +} + +void vkCmdSetDeviceMask_CMockIgnore(void) +{ + Mock.vkCmdSetDeviceMask_IgnoreBool = (char)1; +} + +void vkCmdSetDeviceMask_CMockStopIgnore(void) +{ + Mock.vkCmdSetDeviceMask_IgnoreBool = (char)0; +} + +void vkCmdSetDeviceMask_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDeviceMask_CALL_INSTANCE)); + CMOCK_vkCmdSetDeviceMask_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDeviceMask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDeviceMask_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDeviceMask_CallInstance, cmock_guts_index); + Mock.vkCmdSetDeviceMask_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetDeviceMask_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t deviceMask) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDeviceMask_CALL_INSTANCE)); + CMOCK_vkCmdSetDeviceMask_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDeviceMask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDeviceMask_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDeviceMask_CallInstance, cmock_guts_index); + Mock.vkCmdSetDeviceMask_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetDeviceMask(cmock_call_instance, commandBuffer, deviceMask); +} + +void vkCmdSetDeviceMask_AddCallback(CMOCK_vkCmdSetDeviceMask_CALLBACK Callback) +{ + Mock.vkCmdSetDeviceMask_IgnoreBool = (char)0; + Mock.vkCmdSetDeviceMask_CallbackBool = (char)1; + Mock.vkCmdSetDeviceMask_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDeviceMask_Stub(CMOCK_vkCmdSetDeviceMask_CALLBACK Callback) +{ + Mock.vkCmdSetDeviceMask_IgnoreBool = (char)0; + Mock.vkCmdSetDeviceMask_CallbackBool = (char)0; + Mock.vkCmdSetDeviceMask_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDeviceMask_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDeviceMask_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDeviceMask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDeviceMask_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetDeviceMask_CMockIgnoreArg_deviceMask(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDeviceMask_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDeviceMask_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDeviceMask_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_deviceMask = 1; +} + +void vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDispatchBase_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDispatchBase); + cmock_call_instance = (CMOCK_vkCmdDispatchBase_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDispatchBase_CallInstance); + Mock.vkCmdDispatchBase_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDispatchBase_CallInstance); + if (Mock.vkCmdDispatchBase_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDispatchBase_CallbackBool && + Mock.vkCmdDispatchBase_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDispatchBase_CallbackFunctionPointer(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ, Mock.vkCmdDispatchBase_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDispatchBase,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_baseGroupX) + { + UNITY_SET_DETAILS(CMockString_vkCmdDispatchBase,CMockString_baseGroupX); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_baseGroupX, baseGroupX, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_baseGroupY) + { + UNITY_SET_DETAILS(CMockString_vkCmdDispatchBase,CMockString_baseGroupY); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_baseGroupY, baseGroupY, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_baseGroupZ) + { + UNITY_SET_DETAILS(CMockString_vkCmdDispatchBase,CMockString_baseGroupZ); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_baseGroupZ, baseGroupZ, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_groupCountX) + { + UNITY_SET_DETAILS(CMockString_vkCmdDispatchBase,CMockString_groupCountX); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_groupCountX, groupCountX, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_groupCountY) + { + UNITY_SET_DETAILS(CMockString_vkCmdDispatchBase,CMockString_groupCountY); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_groupCountY, groupCountY, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_groupCountZ) + { + UNITY_SET_DETAILS(CMockString_vkCmdDispatchBase,CMockString_groupCountZ); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_groupCountZ, groupCountZ, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdDispatchBase_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDispatchBase_CallbackFunctionPointer(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ, Mock.vkCmdDispatchBase_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDispatchBase(CMOCK_vkCmdDispatchBase_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +void CMockExpectParameters_vkCmdDispatchBase(CMOCK_vkCmdDispatchBase_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_baseGroupX = baseGroupX; + cmock_call_instance->IgnoreArg_baseGroupX = 0; + cmock_call_instance->Expected_baseGroupY = baseGroupY; + cmock_call_instance->IgnoreArg_baseGroupY = 0; + cmock_call_instance->Expected_baseGroupZ = baseGroupZ; + cmock_call_instance->IgnoreArg_baseGroupZ = 0; + cmock_call_instance->Expected_groupCountX = groupCountX; + cmock_call_instance->IgnoreArg_groupCountX = 0; + cmock_call_instance->Expected_groupCountY = groupCountY; + cmock_call_instance->IgnoreArg_groupCountY = 0; + cmock_call_instance->Expected_groupCountZ = groupCountZ; + cmock_call_instance->IgnoreArg_groupCountZ = 0; +} + +void vkCmdDispatchBase_CMockIgnore(void) +{ + Mock.vkCmdDispatchBase_IgnoreBool = (char)1; +} + +void vkCmdDispatchBase_CMockStopIgnore(void) +{ + Mock.vkCmdDispatchBase_IgnoreBool = (char)0; +} + +void vkCmdDispatchBase_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDispatchBase_CALL_INSTANCE)); + CMOCK_vkCmdDispatchBase_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDispatchBase_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDispatchBase_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDispatchBase_CallInstance, cmock_guts_index); + Mock.vkCmdDispatchBase_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDispatchBase_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDispatchBase_CALL_INSTANCE)); + CMOCK_vkCmdDispatchBase_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDispatchBase_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDispatchBase_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDispatchBase_CallInstance, cmock_guts_index); + Mock.vkCmdDispatchBase_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDispatchBase(cmock_call_instance, commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); +} + +void vkCmdDispatchBase_AddCallback(CMOCK_vkCmdDispatchBase_CALLBACK Callback) +{ + Mock.vkCmdDispatchBase_IgnoreBool = (char)0; + Mock.vkCmdDispatchBase_CallbackBool = (char)1; + Mock.vkCmdDispatchBase_CallbackFunctionPointer = Callback; +} + +void vkCmdDispatchBase_Stub(CMOCK_vkCmdDispatchBase_CALLBACK Callback) +{ + Mock.vkCmdDispatchBase_IgnoreBool = (char)0; + Mock.vkCmdDispatchBase_CallbackBool = (char)0; + Mock.vkCmdDispatchBase_CallbackFunctionPointer = Callback; +} + +void vkCmdDispatchBase_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDispatchBase_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDispatchBase_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDispatchBase_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDispatchBase_CMockIgnoreArg_baseGroupX(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDispatchBase_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDispatchBase_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDispatchBase_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_baseGroupX = 1; +} + +void vkCmdDispatchBase_CMockIgnoreArg_baseGroupY(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDispatchBase_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDispatchBase_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDispatchBase_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_baseGroupY = 1; +} + +void vkCmdDispatchBase_CMockIgnoreArg_baseGroupZ(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDispatchBase_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDispatchBase_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDispatchBase_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_baseGroupZ = 1; +} + +void vkCmdDispatchBase_CMockIgnoreArg_groupCountX(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDispatchBase_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDispatchBase_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDispatchBase_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_groupCountX = 1; +} + +void vkCmdDispatchBase_CMockIgnoreArg_groupCountY(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDispatchBase_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDispatchBase_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDispatchBase_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_groupCountY = 1; +} + +void vkCmdDispatchBase_CMockIgnoreArg_groupCountZ(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDispatchBase_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDispatchBase_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDispatchBase_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_groupCountZ = 1; +} + +VkResult vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkEnumeratePhysicalDeviceGroups_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkEnumeratePhysicalDeviceGroups); + cmock_call_instance = (CMOCK_vkEnumeratePhysicalDeviceGroups_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkEnumeratePhysicalDeviceGroups_CallInstance); + Mock.vkEnumeratePhysicalDeviceGroups_CallInstance = CMock_Guts_MemNext(Mock.vkEnumeratePhysicalDeviceGroups_CallInstance); + if (Mock.vkEnumeratePhysicalDeviceGroups_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkEnumeratePhysicalDeviceGroups_FinalReturn; + memcpy((void*)(&Mock.vkEnumeratePhysicalDeviceGroups_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkEnumeratePhysicalDeviceGroups_CallbackBool && + Mock.vkEnumeratePhysicalDeviceGroups_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkEnumeratePhysicalDeviceGroups_CallbackFunctionPointer(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, Mock.vkEnumeratePhysicalDeviceGroups_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_instance) + { + UNITY_SET_DETAILS(CMockString_vkEnumeratePhysicalDeviceGroups,CMockString_instance); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), sizeof(VkInstance), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPhysicalDeviceGroupCount) + { + UNITY_SET_DETAILS(CMockString_vkEnumeratePhysicalDeviceGroups,CMockString_pPhysicalDeviceGroupCount); + if (cmock_call_instance->Expected_pPhysicalDeviceGroupCount == NULL) + { UNITY_TEST_ASSERT_NULL(pPhysicalDeviceGroupCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pPhysicalDeviceGroupCount, pPhysicalDeviceGroupCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pPhysicalDeviceGroupProperties) + { + UNITY_SET_DETAILS(CMockString_vkEnumeratePhysicalDeviceGroups,CMockString_pPhysicalDeviceGroupProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pPhysicalDeviceGroupProperties), (void*)(pPhysicalDeviceGroupProperties), sizeof(VkPhysicalDeviceGroupProperties), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkEnumeratePhysicalDeviceGroups_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkEnumeratePhysicalDeviceGroups_CallbackFunctionPointer(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, Mock.vkEnumeratePhysicalDeviceGroups_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPhysicalDeviceGroupCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPhysicalDeviceGroupCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPhysicalDeviceGroupCount, (const void*)cmock_call_instance->ReturnThruPtr_pPhysicalDeviceGroupCount_Val, + cmock_call_instance->ReturnThruPtr_pPhysicalDeviceGroupCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pPhysicalDeviceGroupProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPhysicalDeviceGroupProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPhysicalDeviceGroupProperties, (const void*)cmock_call_instance->ReturnThruPtr_pPhysicalDeviceGroupProperties_Val, + cmock_call_instance->ReturnThruPtr_pPhysicalDeviceGroupProperties_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkEnumeratePhysicalDeviceGroups(CMOCK_vkEnumeratePhysicalDeviceGroups_CALL_INSTANCE* cmock_call_instance, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); +void CMockExpectParameters_vkEnumeratePhysicalDeviceGroups(CMOCK_vkEnumeratePhysicalDeviceGroups_CALL_INSTANCE* cmock_call_instance, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), + sizeof(VkInstance[sizeof(instance) == sizeof(VkInstance) ? 1 : -1])); /* add VkInstance to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_instance = 0; + cmock_call_instance->Expected_pPhysicalDeviceGroupCount = pPhysicalDeviceGroupCount; + cmock_call_instance->IgnoreArg_pPhysicalDeviceGroupCount = 0; + cmock_call_instance->ReturnThruPtr_pPhysicalDeviceGroupCount_Used = 0; + cmock_call_instance->Expected_pPhysicalDeviceGroupProperties = pPhysicalDeviceGroupProperties; + cmock_call_instance->IgnoreArg_pPhysicalDeviceGroupProperties = 0; + cmock_call_instance->ReturnThruPtr_pPhysicalDeviceGroupProperties_Used = 0; +} + +void vkEnumeratePhysicalDeviceGroups_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkEnumeratePhysicalDeviceGroups_CALL_INSTANCE)); + CMOCK_vkEnumeratePhysicalDeviceGroups_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDeviceGroups_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkEnumeratePhysicalDeviceGroups_CallInstance = CMock_Guts_MemChain(Mock.vkEnumeratePhysicalDeviceGroups_CallInstance, cmock_guts_index); + Mock.vkEnumeratePhysicalDeviceGroups_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkEnumeratePhysicalDeviceGroups_IgnoreBool = (char)1; +} + +void vkEnumeratePhysicalDeviceGroups_CMockStopIgnore(void) +{ + if(Mock.vkEnumeratePhysicalDeviceGroups_IgnoreBool) + Mock.vkEnumeratePhysicalDeviceGroups_CallInstance = CMock_Guts_MemNext(Mock.vkEnumeratePhysicalDeviceGroups_CallInstance); + Mock.vkEnumeratePhysicalDeviceGroups_IgnoreBool = (char)0; +} + +void vkEnumeratePhysicalDeviceGroups_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkEnumeratePhysicalDeviceGroups_CALL_INSTANCE)); + CMOCK_vkEnumeratePhysicalDeviceGroups_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDeviceGroups_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkEnumeratePhysicalDeviceGroups_CallInstance = CMock_Guts_MemChain(Mock.vkEnumeratePhysicalDeviceGroups_CallInstance, cmock_guts_index); + Mock.vkEnumeratePhysicalDeviceGroups_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkEnumeratePhysicalDeviceGroups_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkEnumeratePhysicalDeviceGroups_CALL_INSTANCE)); + CMOCK_vkEnumeratePhysicalDeviceGroups_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDeviceGroups_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkEnumeratePhysicalDeviceGroups_CallInstance = CMock_Guts_MemChain(Mock.vkEnumeratePhysicalDeviceGroups_CallInstance, cmock_guts_index); + Mock.vkEnumeratePhysicalDeviceGroups_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkEnumeratePhysicalDeviceGroups(cmock_call_instance, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkEnumeratePhysicalDeviceGroups_AddCallback(CMOCK_vkEnumeratePhysicalDeviceGroups_CALLBACK Callback) +{ + Mock.vkEnumeratePhysicalDeviceGroups_IgnoreBool = (char)0; + Mock.vkEnumeratePhysicalDeviceGroups_CallbackBool = (char)1; + Mock.vkEnumeratePhysicalDeviceGroups_CallbackFunctionPointer = Callback; +} + +void vkEnumeratePhysicalDeviceGroups_Stub(CMOCK_vkEnumeratePhysicalDeviceGroups_CALLBACK Callback) +{ + Mock.vkEnumeratePhysicalDeviceGroups_IgnoreBool = (char)0; + Mock.vkEnumeratePhysicalDeviceGroups_CallbackBool = (char)0; + Mock.vkEnumeratePhysicalDeviceGroups_CallbackFunctionPointer = Callback; +} + +void vkEnumeratePhysicalDeviceGroups_CMockReturnMemThruPtr_pPhysicalDeviceGroupCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPhysicalDeviceGroupCount, size_t cmock_size) +{ + CMOCK_vkEnumeratePhysicalDeviceGroups_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDeviceGroups_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumeratePhysicalDeviceGroups_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPhysicalDeviceGroupCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pPhysicalDeviceGroupCount_Val = pPhysicalDeviceGroupCount; + cmock_call_instance->ReturnThruPtr_pPhysicalDeviceGroupCount_Size = cmock_size; +} + +void vkEnumeratePhysicalDeviceGroups_CMockReturnMemThruPtr_pPhysicalDeviceGroupProperties(UNITY_LINE_TYPE cmock_line, VkPhysicalDeviceGroupProperties const* pPhysicalDeviceGroupProperties, size_t cmock_size) +{ + CMOCK_vkEnumeratePhysicalDeviceGroups_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDeviceGroups_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumeratePhysicalDeviceGroups_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPhysicalDeviceGroupProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pPhysicalDeviceGroupProperties_Val = pPhysicalDeviceGroupProperties; + cmock_call_instance->ReturnThruPtr_pPhysicalDeviceGroupProperties_Size = cmock_size; +} + +void vkEnumeratePhysicalDeviceGroups_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkEnumeratePhysicalDeviceGroups_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDeviceGroups_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumeratePhysicalDeviceGroups_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_instance = 1; +} + +void vkEnumeratePhysicalDeviceGroups_CMockIgnoreArg_pPhysicalDeviceGroupCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkEnumeratePhysicalDeviceGroups_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDeviceGroups_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumeratePhysicalDeviceGroups_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPhysicalDeviceGroupCount = 1; +} + +void vkEnumeratePhysicalDeviceGroups_CMockIgnoreArg_pPhysicalDeviceGroupProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkEnumeratePhysicalDeviceGroups_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDeviceGroups_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumeratePhysicalDeviceGroups_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPhysicalDeviceGroupProperties = 1; +} + +void vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetImageMemoryRequirements2_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetImageMemoryRequirements2); + cmock_call_instance = (CMOCK_vkGetImageMemoryRequirements2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetImageMemoryRequirements2_CallInstance); + Mock.vkGetImageMemoryRequirements2_CallInstance = CMock_Guts_MemNext(Mock.vkGetImageMemoryRequirements2_CallInstance); + if (Mock.vkGetImageMemoryRequirements2_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetImageMemoryRequirements2_CallbackBool && + Mock.vkGetImageMemoryRequirements2_CallbackFunctionPointer != NULL) + { + Mock.vkGetImageMemoryRequirements2_CallbackFunctionPointer(device, pInfo, pMemoryRequirements, Mock.vkGetImageMemoryRequirements2_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetImageMemoryRequirements2,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetImageMemoryRequirements2,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkImageMemoryRequirementsInfo2), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMemoryRequirements) + { + UNITY_SET_DETAILS(CMockString_vkGetImageMemoryRequirements2,CMockString_pMemoryRequirements); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMemoryRequirements), (void*)(pMemoryRequirements), sizeof(VkMemoryRequirements2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetImageMemoryRequirements2_CallbackFunctionPointer != NULL) + { + Mock.vkGetImageMemoryRequirements2_CallbackFunctionPointer(device, pInfo, pMemoryRequirements, Mock.vkGetImageMemoryRequirements2_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pMemoryRequirements, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pMemoryRequirements, (const void*)cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Val, + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetImageMemoryRequirements2(CMOCK_vkGetImageMemoryRequirements2_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +void CMockExpectParameters_vkGetImageMemoryRequirements2(CMOCK_vkGetImageMemoryRequirements2_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; + cmock_call_instance->Expected_pMemoryRequirements = pMemoryRequirements; + cmock_call_instance->IgnoreArg_pMemoryRequirements = 0; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used = 0; +} + +void vkGetImageMemoryRequirements2_CMockIgnore(void) +{ + Mock.vkGetImageMemoryRequirements2_IgnoreBool = (char)1; +} + +void vkGetImageMemoryRequirements2_CMockStopIgnore(void) +{ + Mock.vkGetImageMemoryRequirements2_IgnoreBool = (char)0; +} + +void vkGetImageMemoryRequirements2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageMemoryRequirements2_CALL_INSTANCE)); + CMOCK_vkGetImageMemoryRequirements2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageMemoryRequirements2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageMemoryRequirements2_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageMemoryRequirements2_CallInstance, cmock_guts_index); + Mock.vkGetImageMemoryRequirements2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetImageMemoryRequirements2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageMemoryRequirements2_CALL_INSTANCE)); + CMOCK_vkGetImageMemoryRequirements2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageMemoryRequirements2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageMemoryRequirements2_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageMemoryRequirements2_CallInstance, cmock_guts_index); + Mock.vkGetImageMemoryRequirements2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetImageMemoryRequirements2(cmock_call_instance, device, pInfo, pMemoryRequirements); +} + +void vkGetImageMemoryRequirements2_AddCallback(CMOCK_vkGetImageMemoryRequirements2_CALLBACK Callback) +{ + Mock.vkGetImageMemoryRequirements2_IgnoreBool = (char)0; + Mock.vkGetImageMemoryRequirements2_CallbackBool = (char)1; + Mock.vkGetImageMemoryRequirements2_CallbackFunctionPointer = Callback; +} + +void vkGetImageMemoryRequirements2_Stub(CMOCK_vkGetImageMemoryRequirements2_CALLBACK Callback) +{ + Mock.vkGetImageMemoryRequirements2_IgnoreBool = (char)0; + Mock.vkGetImageMemoryRequirements2_CallbackBool = (char)0; + Mock.vkGetImageMemoryRequirements2_CallbackFunctionPointer = Callback; +} + +void vkGetImageMemoryRequirements2_CMockReturnMemThruPtr_pMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkMemoryRequirements2 const* pMemoryRequirements, size_t cmock_size) +{ + CMOCK_vkGetImageMemoryRequirements2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageMemoryRequirements2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageMemoryRequirements2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used = 1; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Val = pMemoryRequirements; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Size = cmock_size; +} + +void vkGetImageMemoryRequirements2_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageMemoryRequirements2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageMemoryRequirements2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageMemoryRequirements2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetImageMemoryRequirements2_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageMemoryRequirements2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageMemoryRequirements2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageMemoryRequirements2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +void vkGetImageMemoryRequirements2_CMockIgnoreArg_pMemoryRequirements(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageMemoryRequirements2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageMemoryRequirements2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageMemoryRequirements2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMemoryRequirements = 1; +} + +void vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetBufferMemoryRequirements2_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetBufferMemoryRequirements2); + cmock_call_instance = (CMOCK_vkGetBufferMemoryRequirements2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetBufferMemoryRequirements2_CallInstance); + Mock.vkGetBufferMemoryRequirements2_CallInstance = CMock_Guts_MemNext(Mock.vkGetBufferMemoryRequirements2_CallInstance); + if (Mock.vkGetBufferMemoryRequirements2_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetBufferMemoryRequirements2_CallbackBool && + Mock.vkGetBufferMemoryRequirements2_CallbackFunctionPointer != NULL) + { + Mock.vkGetBufferMemoryRequirements2_CallbackFunctionPointer(device, pInfo, pMemoryRequirements, Mock.vkGetBufferMemoryRequirements2_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetBufferMemoryRequirements2,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetBufferMemoryRequirements2,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkBufferMemoryRequirementsInfo2), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMemoryRequirements) + { + UNITY_SET_DETAILS(CMockString_vkGetBufferMemoryRequirements2,CMockString_pMemoryRequirements); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMemoryRequirements), (void*)(pMemoryRequirements), sizeof(VkMemoryRequirements2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetBufferMemoryRequirements2_CallbackFunctionPointer != NULL) + { + Mock.vkGetBufferMemoryRequirements2_CallbackFunctionPointer(device, pInfo, pMemoryRequirements, Mock.vkGetBufferMemoryRequirements2_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pMemoryRequirements, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pMemoryRequirements, (const void*)cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Val, + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetBufferMemoryRequirements2(CMOCK_vkGetBufferMemoryRequirements2_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +void CMockExpectParameters_vkGetBufferMemoryRequirements2(CMOCK_vkGetBufferMemoryRequirements2_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; + cmock_call_instance->Expected_pMemoryRequirements = pMemoryRequirements; + cmock_call_instance->IgnoreArg_pMemoryRequirements = 0; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used = 0; +} + +void vkGetBufferMemoryRequirements2_CMockIgnore(void) +{ + Mock.vkGetBufferMemoryRequirements2_IgnoreBool = (char)1; +} + +void vkGetBufferMemoryRequirements2_CMockStopIgnore(void) +{ + Mock.vkGetBufferMemoryRequirements2_IgnoreBool = (char)0; +} + +void vkGetBufferMemoryRequirements2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetBufferMemoryRequirements2_CALL_INSTANCE)); + CMOCK_vkGetBufferMemoryRequirements2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferMemoryRequirements2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetBufferMemoryRequirements2_CallInstance = CMock_Guts_MemChain(Mock.vkGetBufferMemoryRequirements2_CallInstance, cmock_guts_index); + Mock.vkGetBufferMemoryRequirements2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetBufferMemoryRequirements2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetBufferMemoryRequirements2_CALL_INSTANCE)); + CMOCK_vkGetBufferMemoryRequirements2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferMemoryRequirements2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetBufferMemoryRequirements2_CallInstance = CMock_Guts_MemChain(Mock.vkGetBufferMemoryRequirements2_CallInstance, cmock_guts_index); + Mock.vkGetBufferMemoryRequirements2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetBufferMemoryRequirements2(cmock_call_instance, device, pInfo, pMemoryRequirements); +} + +void vkGetBufferMemoryRequirements2_AddCallback(CMOCK_vkGetBufferMemoryRequirements2_CALLBACK Callback) +{ + Mock.vkGetBufferMemoryRequirements2_IgnoreBool = (char)0; + Mock.vkGetBufferMemoryRequirements2_CallbackBool = (char)1; + Mock.vkGetBufferMemoryRequirements2_CallbackFunctionPointer = Callback; +} + +void vkGetBufferMemoryRequirements2_Stub(CMOCK_vkGetBufferMemoryRequirements2_CALLBACK Callback) +{ + Mock.vkGetBufferMemoryRequirements2_IgnoreBool = (char)0; + Mock.vkGetBufferMemoryRequirements2_CallbackBool = (char)0; + Mock.vkGetBufferMemoryRequirements2_CallbackFunctionPointer = Callback; +} + +void vkGetBufferMemoryRequirements2_CMockReturnMemThruPtr_pMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkMemoryRequirements2 const* pMemoryRequirements, size_t cmock_size) +{ + CMOCK_vkGetBufferMemoryRequirements2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferMemoryRequirements2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetBufferMemoryRequirements2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used = 1; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Val = pMemoryRequirements; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Size = cmock_size; +} + +void vkGetBufferMemoryRequirements2_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetBufferMemoryRequirements2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferMemoryRequirements2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetBufferMemoryRequirements2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetBufferMemoryRequirements2_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetBufferMemoryRequirements2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferMemoryRequirements2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetBufferMemoryRequirements2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +void vkGetBufferMemoryRequirements2_CMockIgnoreArg_pMemoryRequirements(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetBufferMemoryRequirements2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferMemoryRequirements2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetBufferMemoryRequirements2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMemoryRequirements = 1; +} + +void vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetImageSparseMemoryRequirements2_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetImageSparseMemoryRequirements2); + cmock_call_instance = (CMOCK_vkGetImageSparseMemoryRequirements2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetImageSparseMemoryRequirements2_CallInstance); + Mock.vkGetImageSparseMemoryRequirements2_CallInstance = CMock_Guts_MemNext(Mock.vkGetImageSparseMemoryRequirements2_CallInstance); + if (Mock.vkGetImageSparseMemoryRequirements2_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetImageSparseMemoryRequirements2_CallbackBool && + Mock.vkGetImageSparseMemoryRequirements2_CallbackFunctionPointer != NULL) + { + Mock.vkGetImageSparseMemoryRequirements2_CallbackFunctionPointer(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, Mock.vkGetImageSparseMemoryRequirements2_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetImageSparseMemoryRequirements2,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetImageSparseMemoryRequirements2,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkImageSparseMemoryRequirementsInfo2), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSparseMemoryRequirementCount) + { + UNITY_SET_DETAILS(CMockString_vkGetImageSparseMemoryRequirements2,CMockString_pSparseMemoryRequirementCount); + if (cmock_call_instance->Expected_pSparseMemoryRequirementCount == NULL) + { UNITY_TEST_ASSERT_NULL(pSparseMemoryRequirementCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pSparseMemoryRequirementCount, pSparseMemoryRequirementCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pSparseMemoryRequirements) + { + UNITY_SET_DETAILS(CMockString_vkGetImageSparseMemoryRequirements2,CMockString_pSparseMemoryRequirements); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSparseMemoryRequirements), (void*)(pSparseMemoryRequirements), sizeof(VkSparseImageMemoryRequirements2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetImageSparseMemoryRequirements2_CallbackFunctionPointer != NULL) + { + Mock.vkGetImageSparseMemoryRequirements2_CallbackFunctionPointer(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, Mock.vkGetImageSparseMemoryRequirements2_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSparseMemoryRequirementCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSparseMemoryRequirementCount, (const void*)cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Val, + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSparseMemoryRequirements, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSparseMemoryRequirements, (const void*)cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Val, + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetImageSparseMemoryRequirements2(CMOCK_vkGetImageSparseMemoryRequirements2_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +void CMockExpectParameters_vkGetImageSparseMemoryRequirements2(CMOCK_vkGetImageSparseMemoryRequirements2_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; + cmock_call_instance->Expected_pSparseMemoryRequirementCount = pSparseMemoryRequirementCount; + cmock_call_instance->IgnoreArg_pSparseMemoryRequirementCount = 0; + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Used = 0; + cmock_call_instance->Expected_pSparseMemoryRequirements = pSparseMemoryRequirements; + cmock_call_instance->IgnoreArg_pSparseMemoryRequirements = 0; + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Used = 0; +} + +void vkGetImageSparseMemoryRequirements2_CMockIgnore(void) +{ + Mock.vkGetImageSparseMemoryRequirements2_IgnoreBool = (char)1; +} + +void vkGetImageSparseMemoryRequirements2_CMockStopIgnore(void) +{ + Mock.vkGetImageSparseMemoryRequirements2_IgnoreBool = (char)0; +} + +void vkGetImageSparseMemoryRequirements2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageSparseMemoryRequirements2_CALL_INSTANCE)); + CMOCK_vkGetImageSparseMemoryRequirements2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSparseMemoryRequirements2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageSparseMemoryRequirements2_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageSparseMemoryRequirements2_CallInstance, cmock_guts_index); + Mock.vkGetImageSparseMemoryRequirements2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetImageSparseMemoryRequirements2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageSparseMemoryRequirements2_CALL_INSTANCE)); + CMOCK_vkGetImageSparseMemoryRequirements2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSparseMemoryRequirements2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageSparseMemoryRequirements2_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageSparseMemoryRequirements2_CallInstance, cmock_guts_index); + Mock.vkGetImageSparseMemoryRequirements2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetImageSparseMemoryRequirements2(cmock_call_instance, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); +} + +void vkGetImageSparseMemoryRequirements2_AddCallback(CMOCK_vkGetImageSparseMemoryRequirements2_CALLBACK Callback) +{ + Mock.vkGetImageSparseMemoryRequirements2_IgnoreBool = (char)0; + Mock.vkGetImageSparseMemoryRequirements2_CallbackBool = (char)1; + Mock.vkGetImageSparseMemoryRequirements2_CallbackFunctionPointer = Callback; +} + +void vkGetImageSparseMemoryRequirements2_Stub(CMOCK_vkGetImageSparseMemoryRequirements2_CALLBACK Callback) +{ + Mock.vkGetImageSparseMemoryRequirements2_IgnoreBool = (char)0; + Mock.vkGetImageSparseMemoryRequirements2_CallbackBool = (char)0; + Mock.vkGetImageSparseMemoryRequirements2_CallbackFunctionPointer = Callback; +} + +void vkGetImageSparseMemoryRequirements2_CMockReturnMemThruPtr_pSparseMemoryRequirementCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pSparseMemoryRequirementCount, size_t cmock_size) +{ + CMOCK_vkGetImageSparseMemoryRequirements2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSparseMemoryRequirements2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageSparseMemoryRequirements2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Val = pSparseMemoryRequirementCount; + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Size = cmock_size; +} + +void vkGetImageSparseMemoryRequirements2_CMockReturnMemThruPtr_pSparseMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkSparseImageMemoryRequirements2 const* pSparseMemoryRequirements, size_t cmock_size) +{ + CMOCK_vkGetImageSparseMemoryRequirements2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSparseMemoryRequirements2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageSparseMemoryRequirements2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Used = 1; + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Val = pSparseMemoryRequirements; + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Size = cmock_size; +} + +void vkGetImageSparseMemoryRequirements2_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageSparseMemoryRequirements2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSparseMemoryRequirements2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageSparseMemoryRequirements2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetImageSparseMemoryRequirements2_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageSparseMemoryRequirements2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSparseMemoryRequirements2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageSparseMemoryRequirements2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +void vkGetImageSparseMemoryRequirements2_CMockIgnoreArg_pSparseMemoryRequirementCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageSparseMemoryRequirements2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSparseMemoryRequirements2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageSparseMemoryRequirements2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSparseMemoryRequirementCount = 1; +} + +void vkGetImageSparseMemoryRequirements2_CMockIgnoreArg_pSparseMemoryRequirements(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageSparseMemoryRequirements2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSparseMemoryRequirements2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageSparseMemoryRequirements2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSparseMemoryRequirements = 1; +} + +void vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceFeatures2_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceFeatures2); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFeatures2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceFeatures2_CallInstance); + Mock.vkGetPhysicalDeviceFeatures2_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceFeatures2_CallInstance); + if (Mock.vkGetPhysicalDeviceFeatures2_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetPhysicalDeviceFeatures2_CallbackBool && + Mock.vkGetPhysicalDeviceFeatures2_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceFeatures2_CallbackFunctionPointer(physicalDevice, pFeatures, Mock.vkGetPhysicalDeviceFeatures2_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceFeatures2,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pFeatures) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceFeatures2,CMockString_pFeatures); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pFeatures), (void*)(pFeatures), sizeof(VkPhysicalDeviceFeatures2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceFeatures2_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceFeatures2_CallbackFunctionPointer(physicalDevice, pFeatures, Mock.vkGetPhysicalDeviceFeatures2_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pFeatures_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pFeatures, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pFeatures, (const void*)cmock_call_instance->ReturnThruPtr_pFeatures_Val, + cmock_call_instance->ReturnThruPtr_pFeatures_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetPhysicalDeviceFeatures2(CMOCK_vkGetPhysicalDeviceFeatures2_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); +void CMockExpectParameters_vkGetPhysicalDeviceFeatures2(CMOCK_vkGetPhysicalDeviceFeatures2_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pFeatures = pFeatures; + cmock_call_instance->IgnoreArg_pFeatures = 0; + cmock_call_instance->ReturnThruPtr_pFeatures_Used = 0; +} + +void vkGetPhysicalDeviceFeatures2_CMockIgnore(void) +{ + Mock.vkGetPhysicalDeviceFeatures2_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceFeatures2_CMockStopIgnore(void) +{ + Mock.vkGetPhysicalDeviceFeatures2_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceFeatures2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceFeatures2_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceFeatures2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFeatures2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceFeatures2_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceFeatures2_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceFeatures2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceFeatures2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceFeatures2_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceFeatures2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFeatures2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceFeatures2_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceFeatures2_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceFeatures2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceFeatures2(cmock_call_instance, physicalDevice, pFeatures); +} + +void vkGetPhysicalDeviceFeatures2_AddCallback(CMOCK_vkGetPhysicalDeviceFeatures2_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceFeatures2_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceFeatures2_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceFeatures2_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceFeatures2_Stub(CMOCK_vkGetPhysicalDeviceFeatures2_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceFeatures2_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceFeatures2_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceFeatures2_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceFeatures2_CMockReturnMemThruPtr_pFeatures(UNITY_LINE_TYPE cmock_line, VkPhysicalDeviceFeatures2 const* pFeatures, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceFeatures2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFeatures2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceFeatures2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pFeatures_Used = 1; + cmock_call_instance->ReturnThruPtr_pFeatures_Val = pFeatures; + cmock_call_instance->ReturnThruPtr_pFeatures_Size = cmock_size; +} + +void vkGetPhysicalDeviceFeatures2_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceFeatures2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFeatures2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceFeatures2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceFeatures2_CMockIgnoreArg_pFeatures(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceFeatures2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFeatures2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceFeatures2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pFeatures = 1; +} + +void vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceProperties2_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceProperties2); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceProperties2_CallInstance); + Mock.vkGetPhysicalDeviceProperties2_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceProperties2_CallInstance); + if (Mock.vkGetPhysicalDeviceProperties2_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetPhysicalDeviceProperties2_CallbackBool && + Mock.vkGetPhysicalDeviceProperties2_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceProperties2_CallbackFunctionPointer(physicalDevice, pProperties, Mock.vkGetPhysicalDeviceProperties2_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceProperties2,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceProperties2,CMockString_pProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pProperties), (void*)(pProperties), sizeof(VkPhysicalDeviceProperties2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceProperties2_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceProperties2_CallbackFunctionPointer(physicalDevice, pProperties, Mock.vkGetPhysicalDeviceProperties2_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pProperties, (const void*)cmock_call_instance->ReturnThruPtr_pProperties_Val, + cmock_call_instance->ReturnThruPtr_pProperties_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetPhysicalDeviceProperties2(CMOCK_vkGetPhysicalDeviceProperties2_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); +void CMockExpectParameters_vkGetPhysicalDeviceProperties2(CMOCK_vkGetPhysicalDeviceProperties2_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pProperties = pProperties; + cmock_call_instance->IgnoreArg_pProperties = 0; + cmock_call_instance->ReturnThruPtr_pProperties_Used = 0; +} + +void vkGetPhysicalDeviceProperties2_CMockIgnore(void) +{ + Mock.vkGetPhysicalDeviceProperties2_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceProperties2_CMockStopIgnore(void) +{ + Mock.vkGetPhysicalDeviceProperties2_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceProperties2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceProperties2_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceProperties2_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceProperties2_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceProperties2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceProperties2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceProperties2_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceProperties2_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceProperties2_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceProperties2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceProperties2(cmock_call_instance, physicalDevice, pProperties); +} + +void vkGetPhysicalDeviceProperties2_AddCallback(CMOCK_vkGetPhysicalDeviceProperties2_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceProperties2_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceProperties2_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceProperties2_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceProperties2_Stub(CMOCK_vkGetPhysicalDeviceProperties2_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceProperties2_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceProperties2_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceProperties2_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceProperties2_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkPhysicalDeviceProperties2 const* pProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceProperties2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pProperties_Val = pProperties; + cmock_call_instance->ReturnThruPtr_pProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceProperties2_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceProperties2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceProperties2_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceProperties2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pProperties = 1; +} + +void vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceFormatProperties2_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceFormatProperties2); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFormatProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceFormatProperties2_CallInstance); + Mock.vkGetPhysicalDeviceFormatProperties2_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceFormatProperties2_CallInstance); + if (Mock.vkGetPhysicalDeviceFormatProperties2_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetPhysicalDeviceFormatProperties2_CallbackBool && + Mock.vkGetPhysicalDeviceFormatProperties2_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceFormatProperties2_CallbackFunctionPointer(physicalDevice, format, pFormatProperties, Mock.vkGetPhysicalDeviceFormatProperties2_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceFormatProperties2,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_format) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceFormatProperties2,CMockString_format); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_format), (void*)(&format), sizeof(VkFormat), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pFormatProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceFormatProperties2,CMockString_pFormatProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pFormatProperties), (void*)(pFormatProperties), sizeof(VkFormatProperties2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceFormatProperties2_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceFormatProperties2_CallbackFunctionPointer(physicalDevice, format, pFormatProperties, Mock.vkGetPhysicalDeviceFormatProperties2_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pFormatProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pFormatProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pFormatProperties, (const void*)cmock_call_instance->ReturnThruPtr_pFormatProperties_Val, + cmock_call_instance->ReturnThruPtr_pFormatProperties_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetPhysicalDeviceFormatProperties2(CMOCK_vkGetPhysicalDeviceFormatProperties2_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); +void CMockExpectParameters_vkGetPhysicalDeviceFormatProperties2(CMOCK_vkGetPhysicalDeviceFormatProperties2_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + memcpy((void*)(&cmock_call_instance->Expected_format), (void*)(&format), + sizeof(VkFormat[sizeof(format) == sizeof(VkFormat) ? 1 : -1])); /* add VkFormat to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_format = 0; + cmock_call_instance->Expected_pFormatProperties = pFormatProperties; + cmock_call_instance->IgnoreArg_pFormatProperties = 0; + cmock_call_instance->ReturnThruPtr_pFormatProperties_Used = 0; +} + +void vkGetPhysicalDeviceFormatProperties2_CMockIgnore(void) +{ + Mock.vkGetPhysicalDeviceFormatProperties2_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceFormatProperties2_CMockStopIgnore(void) +{ + Mock.vkGetPhysicalDeviceFormatProperties2_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceFormatProperties2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceFormatProperties2_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceFormatProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFormatProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceFormatProperties2_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceFormatProperties2_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceFormatProperties2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceFormatProperties2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceFormatProperties2_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceFormatProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFormatProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceFormatProperties2_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceFormatProperties2_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceFormatProperties2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceFormatProperties2(cmock_call_instance, physicalDevice, format, pFormatProperties); +} + +void vkGetPhysicalDeviceFormatProperties2_AddCallback(CMOCK_vkGetPhysicalDeviceFormatProperties2_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceFormatProperties2_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceFormatProperties2_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceFormatProperties2_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceFormatProperties2_Stub(CMOCK_vkGetPhysicalDeviceFormatProperties2_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceFormatProperties2_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceFormatProperties2_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceFormatProperties2_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceFormatProperties2_CMockReturnMemThruPtr_pFormatProperties(UNITY_LINE_TYPE cmock_line, VkFormatProperties2 const* pFormatProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceFormatProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFormatProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceFormatProperties2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pFormatProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pFormatProperties_Val = pFormatProperties; + cmock_call_instance->ReturnThruPtr_pFormatProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceFormatProperties2_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceFormatProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFormatProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceFormatProperties2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceFormatProperties2_CMockIgnoreArg_format(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceFormatProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFormatProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceFormatProperties2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_format = 1; +} + +void vkGetPhysicalDeviceFormatProperties2_CMockIgnoreArg_pFormatProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceFormatProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFormatProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceFormatProperties2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pFormatProperties = 1; +} + +VkResult vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceImageFormatProperties2_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceImageFormatProperties2); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceImageFormatProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceImageFormatProperties2_CallInstance); + Mock.vkGetPhysicalDeviceImageFormatProperties2_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceImageFormatProperties2_CallInstance); + if (Mock.vkGetPhysicalDeviceImageFormatProperties2_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPhysicalDeviceImageFormatProperties2_FinalReturn; + memcpy((void*)(&Mock.vkGetPhysicalDeviceImageFormatProperties2_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPhysicalDeviceImageFormatProperties2_CallbackBool && + Mock.vkGetPhysicalDeviceImageFormatProperties2_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPhysicalDeviceImageFormatProperties2_CallbackFunctionPointer(physicalDevice, pImageFormatInfo, pImageFormatProperties, Mock.vkGetPhysicalDeviceImageFormatProperties2_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceImageFormatProperties2,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pImageFormatInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceImageFormatProperties2,CMockString_pImageFormatInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pImageFormatInfo), (void*)(pImageFormatInfo), sizeof(const VkPhysicalDeviceImageFormatInfo2), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pImageFormatProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceImageFormatProperties2,CMockString_pImageFormatProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pImageFormatProperties), (void*)(pImageFormatProperties), sizeof(VkImageFormatProperties2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceImageFormatProperties2_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPhysicalDeviceImageFormatProperties2_CallbackFunctionPointer(physicalDevice, pImageFormatInfo, pImageFormatProperties, Mock.vkGetPhysicalDeviceImageFormatProperties2_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pImageFormatProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pImageFormatProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pImageFormatProperties, (const void*)cmock_call_instance->ReturnThruPtr_pImageFormatProperties_Val, + cmock_call_instance->ReturnThruPtr_pImageFormatProperties_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPhysicalDeviceImageFormatProperties2(CMOCK_vkGetPhysicalDeviceImageFormatProperties2_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); +void CMockExpectParameters_vkGetPhysicalDeviceImageFormatProperties2(CMOCK_vkGetPhysicalDeviceImageFormatProperties2_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pImageFormatInfo = pImageFormatInfo; + cmock_call_instance->IgnoreArg_pImageFormatInfo = 0; + cmock_call_instance->Expected_pImageFormatProperties = pImageFormatProperties; + cmock_call_instance->IgnoreArg_pImageFormatProperties = 0; + cmock_call_instance->ReturnThruPtr_pImageFormatProperties_Used = 0; +} + +void vkGetPhysicalDeviceImageFormatProperties2_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceImageFormatProperties2_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceImageFormatProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceImageFormatProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceImageFormatProperties2_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceImageFormatProperties2_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceImageFormatProperties2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPhysicalDeviceImageFormatProperties2_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceImageFormatProperties2_CMockStopIgnore(void) +{ + if(Mock.vkGetPhysicalDeviceImageFormatProperties2_IgnoreBool) + Mock.vkGetPhysicalDeviceImageFormatProperties2_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceImageFormatProperties2_CallInstance); + Mock.vkGetPhysicalDeviceImageFormatProperties2_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceImageFormatProperties2_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceImageFormatProperties2_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceImageFormatProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceImageFormatProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceImageFormatProperties2_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceImageFormatProperties2_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceImageFormatProperties2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceImageFormatProperties2_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceImageFormatProperties2_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceImageFormatProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceImageFormatProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceImageFormatProperties2_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceImageFormatProperties2_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceImageFormatProperties2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceImageFormatProperties2(cmock_call_instance, physicalDevice, pImageFormatInfo, pImageFormatProperties); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPhysicalDeviceImageFormatProperties2_AddCallback(CMOCK_vkGetPhysicalDeviceImageFormatProperties2_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceImageFormatProperties2_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceImageFormatProperties2_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceImageFormatProperties2_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceImageFormatProperties2_Stub(CMOCK_vkGetPhysicalDeviceImageFormatProperties2_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceImageFormatProperties2_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceImageFormatProperties2_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceImageFormatProperties2_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceImageFormatProperties2_CMockReturnMemThruPtr_pImageFormatProperties(UNITY_LINE_TYPE cmock_line, VkImageFormatProperties2 const* pImageFormatProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceImageFormatProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceImageFormatProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceImageFormatProperties2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pImageFormatProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pImageFormatProperties_Val = pImageFormatProperties; + cmock_call_instance->ReturnThruPtr_pImageFormatProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceImageFormatProperties2_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceImageFormatProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceImageFormatProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceImageFormatProperties2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceImageFormatProperties2_CMockIgnoreArg_pImageFormatInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceImageFormatProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceImageFormatProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceImageFormatProperties2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pImageFormatInfo = 1; +} + +void vkGetPhysicalDeviceImageFormatProperties2_CMockIgnoreArg_pImageFormatProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceImageFormatProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceImageFormatProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceImageFormatProperties2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pImageFormatProperties = 1; +} + +void vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceQueueFamilyProperties2); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceQueueFamilyProperties2_CallInstance); + Mock.vkGetPhysicalDeviceQueueFamilyProperties2_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceQueueFamilyProperties2_CallInstance); + if (Mock.vkGetPhysicalDeviceQueueFamilyProperties2_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetPhysicalDeviceQueueFamilyProperties2_CallbackBool && + Mock.vkGetPhysicalDeviceQueueFamilyProperties2_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceQueueFamilyProperties2_CallbackFunctionPointer(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, Mock.vkGetPhysicalDeviceQueueFamilyProperties2_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceQueueFamilyProperties2,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pQueueFamilyPropertyCount) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceQueueFamilyProperties2,CMockString_pQueueFamilyPropertyCount); + if (cmock_call_instance->Expected_pQueueFamilyPropertyCount == NULL) + { UNITY_TEST_ASSERT_NULL(pQueueFamilyPropertyCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pQueueFamilyPropertyCount, pQueueFamilyPropertyCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pQueueFamilyProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceQueueFamilyProperties2,CMockString_pQueueFamilyProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pQueueFamilyProperties), (void*)(pQueueFamilyProperties), sizeof(VkQueueFamilyProperties2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceQueueFamilyProperties2_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceQueueFamilyProperties2_CallbackFunctionPointer(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, Mock.vkGetPhysicalDeviceQueueFamilyProperties2_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pQueueFamilyPropertyCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pQueueFamilyPropertyCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pQueueFamilyPropertyCount, (const void*)cmock_call_instance->ReturnThruPtr_pQueueFamilyPropertyCount_Val, + cmock_call_instance->ReturnThruPtr_pQueueFamilyPropertyCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pQueueFamilyProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pQueueFamilyProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pQueueFamilyProperties, (const void*)cmock_call_instance->ReturnThruPtr_pQueueFamilyProperties_Val, + cmock_call_instance->ReturnThruPtr_pQueueFamilyProperties_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetPhysicalDeviceQueueFamilyProperties2(CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); +void CMockExpectParameters_vkGetPhysicalDeviceQueueFamilyProperties2(CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pQueueFamilyPropertyCount = pQueueFamilyPropertyCount; + cmock_call_instance->IgnoreArg_pQueueFamilyPropertyCount = 0; + cmock_call_instance->ReturnThruPtr_pQueueFamilyPropertyCount_Used = 0; + cmock_call_instance->Expected_pQueueFamilyProperties = pQueueFamilyProperties; + cmock_call_instance->IgnoreArg_pQueueFamilyProperties = 0; + cmock_call_instance->ReturnThruPtr_pQueueFamilyProperties_Used = 0; +} + +void vkGetPhysicalDeviceQueueFamilyProperties2_CMockIgnore(void) +{ + Mock.vkGetPhysicalDeviceQueueFamilyProperties2_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceQueueFamilyProperties2_CMockStopIgnore(void) +{ + Mock.vkGetPhysicalDeviceQueueFamilyProperties2_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceQueueFamilyProperties2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceQueueFamilyProperties2_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceQueueFamilyProperties2_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceQueueFamilyProperties2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceQueueFamilyProperties2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceQueueFamilyProperties2_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceQueueFamilyProperties2_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceQueueFamilyProperties2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceQueueFamilyProperties2(cmock_call_instance, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); +} + +void vkGetPhysicalDeviceQueueFamilyProperties2_AddCallback(CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceQueueFamilyProperties2_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceQueueFamilyProperties2_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceQueueFamilyProperties2_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceQueueFamilyProperties2_Stub(CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceQueueFamilyProperties2_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceQueueFamilyProperties2_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceQueueFamilyProperties2_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceQueueFamilyProperties2_CMockReturnMemThruPtr_pQueueFamilyPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pQueueFamilyPropertyCount, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceQueueFamilyProperties2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pQueueFamilyPropertyCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pQueueFamilyPropertyCount_Val = pQueueFamilyPropertyCount; + cmock_call_instance->ReturnThruPtr_pQueueFamilyPropertyCount_Size = cmock_size; +} + +void vkGetPhysicalDeviceQueueFamilyProperties2_CMockReturnMemThruPtr_pQueueFamilyProperties(UNITY_LINE_TYPE cmock_line, VkQueueFamilyProperties2 const* pQueueFamilyProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceQueueFamilyProperties2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pQueueFamilyProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pQueueFamilyProperties_Val = pQueueFamilyProperties; + cmock_call_instance->ReturnThruPtr_pQueueFamilyProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceQueueFamilyProperties2_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceQueueFamilyProperties2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceQueueFamilyProperties2_CMockIgnoreArg_pQueueFamilyPropertyCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceQueueFamilyProperties2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pQueueFamilyPropertyCount = 1; +} + +void vkGetPhysicalDeviceQueueFamilyProperties2_CMockIgnoreArg_pQueueFamilyProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceQueueFamilyProperties2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pQueueFamilyProperties = 1; +} + +void vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceMemoryProperties2_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceMemoryProperties2); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceMemoryProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceMemoryProperties2_CallInstance); + Mock.vkGetPhysicalDeviceMemoryProperties2_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceMemoryProperties2_CallInstance); + if (Mock.vkGetPhysicalDeviceMemoryProperties2_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetPhysicalDeviceMemoryProperties2_CallbackBool && + Mock.vkGetPhysicalDeviceMemoryProperties2_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceMemoryProperties2_CallbackFunctionPointer(physicalDevice, pMemoryProperties, Mock.vkGetPhysicalDeviceMemoryProperties2_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceMemoryProperties2,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMemoryProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceMemoryProperties2,CMockString_pMemoryProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMemoryProperties), (void*)(pMemoryProperties), sizeof(VkPhysicalDeviceMemoryProperties2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceMemoryProperties2_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceMemoryProperties2_CallbackFunctionPointer(physicalDevice, pMemoryProperties, Mock.vkGetPhysicalDeviceMemoryProperties2_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pMemoryProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pMemoryProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pMemoryProperties, (const void*)cmock_call_instance->ReturnThruPtr_pMemoryProperties_Val, + cmock_call_instance->ReturnThruPtr_pMemoryProperties_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetPhysicalDeviceMemoryProperties2(CMOCK_vkGetPhysicalDeviceMemoryProperties2_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); +void CMockExpectParameters_vkGetPhysicalDeviceMemoryProperties2(CMOCK_vkGetPhysicalDeviceMemoryProperties2_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pMemoryProperties = pMemoryProperties; + cmock_call_instance->IgnoreArg_pMemoryProperties = 0; + cmock_call_instance->ReturnThruPtr_pMemoryProperties_Used = 0; +} + +void vkGetPhysicalDeviceMemoryProperties2_CMockIgnore(void) +{ + Mock.vkGetPhysicalDeviceMemoryProperties2_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceMemoryProperties2_CMockStopIgnore(void) +{ + Mock.vkGetPhysicalDeviceMemoryProperties2_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceMemoryProperties2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceMemoryProperties2_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceMemoryProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceMemoryProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceMemoryProperties2_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceMemoryProperties2_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceMemoryProperties2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceMemoryProperties2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceMemoryProperties2_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceMemoryProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceMemoryProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceMemoryProperties2_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceMemoryProperties2_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceMemoryProperties2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceMemoryProperties2(cmock_call_instance, physicalDevice, pMemoryProperties); +} + +void vkGetPhysicalDeviceMemoryProperties2_AddCallback(CMOCK_vkGetPhysicalDeviceMemoryProperties2_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceMemoryProperties2_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceMemoryProperties2_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceMemoryProperties2_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceMemoryProperties2_Stub(CMOCK_vkGetPhysicalDeviceMemoryProperties2_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceMemoryProperties2_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceMemoryProperties2_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceMemoryProperties2_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceMemoryProperties2_CMockReturnMemThruPtr_pMemoryProperties(UNITY_LINE_TYPE cmock_line, VkPhysicalDeviceMemoryProperties2 const* pMemoryProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceMemoryProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceMemoryProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceMemoryProperties2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pMemoryProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pMemoryProperties_Val = pMemoryProperties; + cmock_call_instance->ReturnThruPtr_pMemoryProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceMemoryProperties2_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceMemoryProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceMemoryProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceMemoryProperties2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceMemoryProperties2_CMockIgnoreArg_pMemoryProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceMemoryProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceMemoryProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceMemoryProperties2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMemoryProperties = 1; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceSparseImageFormatProperties2); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_CallInstance); + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_CallInstance); + if (Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_CallbackBool && + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_CallbackFunctionPointer(physicalDevice, pFormatInfo, pPropertyCount, pProperties, Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSparseImageFormatProperties2,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pFormatInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSparseImageFormatProperties2,CMockString_pFormatInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pFormatInfo), (void*)(pFormatInfo), sizeof(const VkPhysicalDeviceSparseImageFormatInfo2), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPropertyCount) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSparseImageFormatProperties2,CMockString_pPropertyCount); + if (cmock_call_instance->Expected_pPropertyCount == NULL) + { UNITY_TEST_ASSERT_NULL(pPropertyCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pPropertyCount, pPropertyCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSparseImageFormatProperties2,CMockString_pProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pProperties), (void*)(pProperties), sizeof(VkSparseImageFormatProperties2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_CallbackFunctionPointer(physicalDevice, pFormatInfo, pPropertyCount, pProperties, Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPropertyCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPropertyCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPropertyCount, (const void*)cmock_call_instance->ReturnThruPtr_pPropertyCount_Val, + cmock_call_instance->ReturnThruPtr_pPropertyCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pProperties, (const void*)cmock_call_instance->ReturnThruPtr_pProperties_Val, + cmock_call_instance->ReturnThruPtr_pProperties_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetPhysicalDeviceSparseImageFormatProperties2(CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); +void CMockExpectParameters_vkGetPhysicalDeviceSparseImageFormatProperties2(CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pFormatInfo = pFormatInfo; + cmock_call_instance->IgnoreArg_pFormatInfo = 0; + cmock_call_instance->Expected_pPropertyCount = pPropertyCount; + cmock_call_instance->IgnoreArg_pPropertyCount = 0; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Used = 0; + cmock_call_instance->Expected_pProperties = pProperties; + cmock_call_instance->IgnoreArg_pProperties = 0; + cmock_call_instance->ReturnThruPtr_pProperties_Used = 0; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties2_CMockIgnore(void) +{ + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties2_CMockStopIgnore(void) +{ + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceSparseImageFormatProperties2(cmock_call_instance, physicalDevice, pFormatInfo, pPropertyCount, pProperties); +} + +void vkGetPhysicalDeviceSparseImageFormatProperties2_AddCallback(CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties2_Stub(CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties2_CMockReturnMemThruPtr_pPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPropertyCount, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPropertyCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Val = pPropertyCount; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Size = cmock_size; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties2_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkSparseImageFormatProperties2 const* pProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pProperties_Val = pProperties; + cmock_call_instance->ReturnThruPtr_pProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties2_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties2_CMockIgnoreArg_pFormatInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pFormatInfo = 1; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties2_CMockIgnoreArg_pPropertyCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPropertyCount = 1; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties2_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSparseImageFormatProperties2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pProperties = 1; +} + +void vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkTrimCommandPool_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkTrimCommandPool); + cmock_call_instance = (CMOCK_vkTrimCommandPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkTrimCommandPool_CallInstance); + Mock.vkTrimCommandPool_CallInstance = CMock_Guts_MemNext(Mock.vkTrimCommandPool_CallInstance); + if (Mock.vkTrimCommandPool_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkTrimCommandPool_CallbackBool && + Mock.vkTrimCommandPool_CallbackFunctionPointer != NULL) + { + Mock.vkTrimCommandPool_CallbackFunctionPointer(device, commandPool, flags, Mock.vkTrimCommandPool_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkTrimCommandPool,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_commandPool) + { + UNITY_SET_DETAILS(CMockString_vkTrimCommandPool,CMockString_commandPool); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandPool), (void*)(&commandPool), sizeof(VkCommandPool), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_flags) + { + UNITY_SET_DETAILS(CMockString_vkTrimCommandPool,CMockString_flags); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_flags), (void*)(&flags), sizeof(VkCommandPoolTrimFlags), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkTrimCommandPool_CallbackFunctionPointer != NULL) + { + Mock.vkTrimCommandPool_CallbackFunctionPointer(device, commandPool, flags, Mock.vkTrimCommandPool_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkTrimCommandPool(CMOCK_vkTrimCommandPool_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); +void CMockExpectParameters_vkTrimCommandPool(CMOCK_vkTrimCommandPool_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_commandPool), (void*)(&commandPool), + sizeof(VkCommandPool[sizeof(commandPool) == sizeof(VkCommandPool) ? 1 : -1])); /* add VkCommandPool to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandPool = 0; + memcpy((void*)(&cmock_call_instance->Expected_flags), (void*)(&flags), + sizeof(VkCommandPoolTrimFlags[sizeof(flags) == sizeof(VkCommandPoolTrimFlags) ? 1 : -1])); /* add VkCommandPoolTrimFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_flags = 0; +} + +void vkTrimCommandPool_CMockIgnore(void) +{ + Mock.vkTrimCommandPool_IgnoreBool = (char)1; +} + +void vkTrimCommandPool_CMockStopIgnore(void) +{ + Mock.vkTrimCommandPool_IgnoreBool = (char)0; +} + +void vkTrimCommandPool_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkTrimCommandPool_CALL_INSTANCE)); + CMOCK_vkTrimCommandPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkTrimCommandPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkTrimCommandPool_CallInstance = CMock_Guts_MemChain(Mock.vkTrimCommandPool_CallInstance, cmock_guts_index); + Mock.vkTrimCommandPool_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkTrimCommandPool_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkTrimCommandPool_CALL_INSTANCE)); + CMOCK_vkTrimCommandPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkTrimCommandPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkTrimCommandPool_CallInstance = CMock_Guts_MemChain(Mock.vkTrimCommandPool_CallInstance, cmock_guts_index); + Mock.vkTrimCommandPool_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkTrimCommandPool(cmock_call_instance, device, commandPool, flags); +} + +void vkTrimCommandPool_AddCallback(CMOCK_vkTrimCommandPool_CALLBACK Callback) +{ + Mock.vkTrimCommandPool_IgnoreBool = (char)0; + Mock.vkTrimCommandPool_CallbackBool = (char)1; + Mock.vkTrimCommandPool_CallbackFunctionPointer = Callback; +} + +void vkTrimCommandPool_Stub(CMOCK_vkTrimCommandPool_CALLBACK Callback) +{ + Mock.vkTrimCommandPool_IgnoreBool = (char)0; + Mock.vkTrimCommandPool_CallbackBool = (char)0; + Mock.vkTrimCommandPool_CallbackFunctionPointer = Callback; +} + +void vkTrimCommandPool_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkTrimCommandPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkTrimCommandPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkTrimCommandPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkTrimCommandPool_CMockIgnoreArg_commandPool(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkTrimCommandPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkTrimCommandPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkTrimCommandPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandPool = 1; +} + +void vkTrimCommandPool_CMockIgnoreArg_flags(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkTrimCommandPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkTrimCommandPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkTrimCommandPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_flags = 1; +} + +void vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDeviceQueue2_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDeviceQueue2); + cmock_call_instance = (CMOCK_vkGetDeviceQueue2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDeviceQueue2_CallInstance); + Mock.vkGetDeviceQueue2_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeviceQueue2_CallInstance); + if (Mock.vkGetDeviceQueue2_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetDeviceQueue2_CallbackBool && + Mock.vkGetDeviceQueue2_CallbackFunctionPointer != NULL) + { + Mock.vkGetDeviceQueue2_CallbackFunctionPointer(device, pQueueInfo, pQueue, Mock.vkGetDeviceQueue2_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceQueue2,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pQueueInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceQueue2,CMockString_pQueueInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pQueueInfo), (void*)(pQueueInfo), sizeof(const VkDeviceQueueInfo2), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pQueue) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceQueue2,CMockString_pQueue); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pQueue), (void*)(pQueue), sizeof(VkQueue), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDeviceQueue2_CallbackFunctionPointer != NULL) + { + Mock.vkGetDeviceQueue2_CallbackFunctionPointer(device, pQueueInfo, pQueue, Mock.vkGetDeviceQueue2_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pQueue_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pQueue, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pQueue, (const void*)cmock_call_instance->ReturnThruPtr_pQueue_Val, + cmock_call_instance->ReturnThruPtr_pQueue_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetDeviceQueue2(CMOCK_vkGetDeviceQueue2_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue); +void CMockExpectParameters_vkGetDeviceQueue2(CMOCK_vkGetDeviceQueue2_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pQueueInfo = pQueueInfo; + cmock_call_instance->IgnoreArg_pQueueInfo = 0; + cmock_call_instance->Expected_pQueue = pQueue; + cmock_call_instance->IgnoreArg_pQueue = 0; + cmock_call_instance->ReturnThruPtr_pQueue_Used = 0; +} + +void vkGetDeviceQueue2_CMockIgnore(void) +{ + Mock.vkGetDeviceQueue2_IgnoreBool = (char)1; +} + +void vkGetDeviceQueue2_CMockStopIgnore(void) +{ + Mock.vkGetDeviceQueue2_IgnoreBool = (char)0; +} + +void vkGetDeviceQueue2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceQueue2_CALL_INSTANCE)); + CMOCK_vkGetDeviceQueue2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceQueue2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceQueue2_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceQueue2_CallInstance, cmock_guts_index); + Mock.vkGetDeviceQueue2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDeviceQueue2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceQueue2_CALL_INSTANCE)); + CMOCK_vkGetDeviceQueue2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceQueue2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceQueue2_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceQueue2_CallInstance, cmock_guts_index); + Mock.vkGetDeviceQueue2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDeviceQueue2(cmock_call_instance, device, pQueueInfo, pQueue); +} + +void vkGetDeviceQueue2_AddCallback(CMOCK_vkGetDeviceQueue2_CALLBACK Callback) +{ + Mock.vkGetDeviceQueue2_IgnoreBool = (char)0; + Mock.vkGetDeviceQueue2_CallbackBool = (char)1; + Mock.vkGetDeviceQueue2_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceQueue2_Stub(CMOCK_vkGetDeviceQueue2_CALLBACK Callback) +{ + Mock.vkGetDeviceQueue2_IgnoreBool = (char)0; + Mock.vkGetDeviceQueue2_CallbackBool = (char)0; + Mock.vkGetDeviceQueue2_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceQueue2_CMockReturnMemThruPtr_pQueue(UNITY_LINE_TYPE cmock_line, VkQueue const* pQueue, size_t cmock_size) +{ + CMOCK_vkGetDeviceQueue2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceQueue2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceQueue2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pQueue_Used = 1; + cmock_call_instance->ReturnThruPtr_pQueue_Val = pQueue; + cmock_call_instance->ReturnThruPtr_pQueue_Size = cmock_size; +} + +void vkGetDeviceQueue2_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceQueue2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceQueue2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceQueue2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetDeviceQueue2_CMockIgnoreArg_pQueueInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceQueue2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceQueue2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceQueue2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pQueueInfo = 1; +} + +void vkGetDeviceQueue2_CMockIgnoreArg_pQueue(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceQueue2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceQueue2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceQueue2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pQueue = 1; +} + +VkResult vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateSamplerYcbcrConversion_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateSamplerYcbcrConversion); + cmock_call_instance = (CMOCK_vkCreateSamplerYcbcrConversion_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateSamplerYcbcrConversion_CallInstance); + Mock.vkCreateSamplerYcbcrConversion_CallInstance = CMock_Guts_MemNext(Mock.vkCreateSamplerYcbcrConversion_CallInstance); + if (Mock.vkCreateSamplerYcbcrConversion_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateSamplerYcbcrConversion_FinalReturn; + memcpy((void*)(&Mock.vkCreateSamplerYcbcrConversion_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateSamplerYcbcrConversion_CallbackBool && + Mock.vkCreateSamplerYcbcrConversion_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateSamplerYcbcrConversion_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pYcbcrConversion, Mock.vkCreateSamplerYcbcrConversion_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateSamplerYcbcrConversion,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateSamplerYcbcrConversion,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkSamplerYcbcrConversionCreateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateSamplerYcbcrConversion,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pYcbcrConversion) + { + UNITY_SET_DETAILS(CMockString_vkCreateSamplerYcbcrConversion,CMockString_pYcbcrConversion); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pYcbcrConversion), (void*)(pYcbcrConversion), sizeof(VkSamplerYcbcrConversion), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateSamplerYcbcrConversion_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateSamplerYcbcrConversion_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pYcbcrConversion, Mock.vkCreateSamplerYcbcrConversion_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pYcbcrConversion_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pYcbcrConversion, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pYcbcrConversion, (const void*)cmock_call_instance->ReturnThruPtr_pYcbcrConversion_Val, + cmock_call_instance->ReturnThruPtr_pYcbcrConversion_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateSamplerYcbcrConversion(CMOCK_vkCreateSamplerYcbcrConversion_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); +void CMockExpectParameters_vkCreateSamplerYcbcrConversion(CMOCK_vkCreateSamplerYcbcrConversion_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pYcbcrConversion = pYcbcrConversion; + cmock_call_instance->IgnoreArg_pYcbcrConversion = 0; + cmock_call_instance->ReturnThruPtr_pYcbcrConversion_Used = 0; +} + +void vkCreateSamplerYcbcrConversion_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateSamplerYcbcrConversion_CALL_INSTANCE)); + CMOCK_vkCreateSamplerYcbcrConversion_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSamplerYcbcrConversion_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateSamplerYcbcrConversion_CallInstance = CMock_Guts_MemChain(Mock.vkCreateSamplerYcbcrConversion_CallInstance, cmock_guts_index); + Mock.vkCreateSamplerYcbcrConversion_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateSamplerYcbcrConversion_IgnoreBool = (char)1; +} + +void vkCreateSamplerYcbcrConversion_CMockStopIgnore(void) +{ + if(Mock.vkCreateSamplerYcbcrConversion_IgnoreBool) + Mock.vkCreateSamplerYcbcrConversion_CallInstance = CMock_Guts_MemNext(Mock.vkCreateSamplerYcbcrConversion_CallInstance); + Mock.vkCreateSamplerYcbcrConversion_IgnoreBool = (char)0; +} + +void vkCreateSamplerYcbcrConversion_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateSamplerYcbcrConversion_CALL_INSTANCE)); + CMOCK_vkCreateSamplerYcbcrConversion_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSamplerYcbcrConversion_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateSamplerYcbcrConversion_CallInstance = CMock_Guts_MemChain(Mock.vkCreateSamplerYcbcrConversion_CallInstance, cmock_guts_index); + Mock.vkCreateSamplerYcbcrConversion_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateSamplerYcbcrConversion_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateSamplerYcbcrConversion_CALL_INSTANCE)); + CMOCK_vkCreateSamplerYcbcrConversion_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSamplerYcbcrConversion_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateSamplerYcbcrConversion_CallInstance = CMock_Guts_MemChain(Mock.vkCreateSamplerYcbcrConversion_CallInstance, cmock_guts_index); + Mock.vkCreateSamplerYcbcrConversion_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateSamplerYcbcrConversion(cmock_call_instance, device, pCreateInfo, pAllocator, pYcbcrConversion); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateSamplerYcbcrConversion_AddCallback(CMOCK_vkCreateSamplerYcbcrConversion_CALLBACK Callback) +{ + Mock.vkCreateSamplerYcbcrConversion_IgnoreBool = (char)0; + Mock.vkCreateSamplerYcbcrConversion_CallbackBool = (char)1; + Mock.vkCreateSamplerYcbcrConversion_CallbackFunctionPointer = Callback; +} + +void vkCreateSamplerYcbcrConversion_Stub(CMOCK_vkCreateSamplerYcbcrConversion_CALLBACK Callback) +{ + Mock.vkCreateSamplerYcbcrConversion_IgnoreBool = (char)0; + Mock.vkCreateSamplerYcbcrConversion_CallbackBool = (char)0; + Mock.vkCreateSamplerYcbcrConversion_CallbackFunctionPointer = Callback; +} + +void vkCreateSamplerYcbcrConversion_CMockReturnMemThruPtr_pYcbcrConversion(UNITY_LINE_TYPE cmock_line, VkSamplerYcbcrConversion const* pYcbcrConversion, size_t cmock_size) +{ + CMOCK_vkCreateSamplerYcbcrConversion_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSamplerYcbcrConversion_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSamplerYcbcrConversion_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pYcbcrConversion_Used = 1; + cmock_call_instance->ReturnThruPtr_pYcbcrConversion_Val = pYcbcrConversion; + cmock_call_instance->ReturnThruPtr_pYcbcrConversion_Size = cmock_size; +} + +void vkCreateSamplerYcbcrConversion_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateSamplerYcbcrConversion_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSamplerYcbcrConversion_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSamplerYcbcrConversion_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateSamplerYcbcrConversion_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateSamplerYcbcrConversion_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSamplerYcbcrConversion_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSamplerYcbcrConversion_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateSamplerYcbcrConversion_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateSamplerYcbcrConversion_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSamplerYcbcrConversion_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSamplerYcbcrConversion_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateSamplerYcbcrConversion_CMockIgnoreArg_pYcbcrConversion(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateSamplerYcbcrConversion_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSamplerYcbcrConversion_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSamplerYcbcrConversion_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pYcbcrConversion = 1; +} + +void vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroySamplerYcbcrConversion_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroySamplerYcbcrConversion); + cmock_call_instance = (CMOCK_vkDestroySamplerYcbcrConversion_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroySamplerYcbcrConversion_CallInstance); + Mock.vkDestroySamplerYcbcrConversion_CallInstance = CMock_Guts_MemNext(Mock.vkDestroySamplerYcbcrConversion_CallInstance); + if (Mock.vkDestroySamplerYcbcrConversion_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroySamplerYcbcrConversion_CallbackBool && + Mock.vkDestroySamplerYcbcrConversion_CallbackFunctionPointer != NULL) + { + Mock.vkDestroySamplerYcbcrConversion_CallbackFunctionPointer(device, ycbcrConversion, pAllocator, Mock.vkDestroySamplerYcbcrConversion_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroySamplerYcbcrConversion,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_ycbcrConversion) + { + UNITY_SET_DETAILS(CMockString_vkDestroySamplerYcbcrConversion,CMockString_ycbcrConversion); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_ycbcrConversion), (void*)(&ycbcrConversion), sizeof(VkSamplerYcbcrConversion), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroySamplerYcbcrConversion,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroySamplerYcbcrConversion_CallbackFunctionPointer != NULL) + { + Mock.vkDestroySamplerYcbcrConversion_CallbackFunctionPointer(device, ycbcrConversion, pAllocator, Mock.vkDestroySamplerYcbcrConversion_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroySamplerYcbcrConversion(CMOCK_vkDestroySamplerYcbcrConversion_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroySamplerYcbcrConversion(CMOCK_vkDestroySamplerYcbcrConversion_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_ycbcrConversion), (void*)(&ycbcrConversion), + sizeof(VkSamplerYcbcrConversion[sizeof(ycbcrConversion) == sizeof(VkSamplerYcbcrConversion) ? 1 : -1])); /* add VkSamplerYcbcrConversion to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_ycbcrConversion = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroySamplerYcbcrConversion_CMockIgnore(void) +{ + Mock.vkDestroySamplerYcbcrConversion_IgnoreBool = (char)1; +} + +void vkDestroySamplerYcbcrConversion_CMockStopIgnore(void) +{ + Mock.vkDestroySamplerYcbcrConversion_IgnoreBool = (char)0; +} + +void vkDestroySamplerYcbcrConversion_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroySamplerYcbcrConversion_CALL_INSTANCE)); + CMOCK_vkDestroySamplerYcbcrConversion_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroySamplerYcbcrConversion_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroySamplerYcbcrConversion_CallInstance = CMock_Guts_MemChain(Mock.vkDestroySamplerYcbcrConversion_CallInstance, cmock_guts_index); + Mock.vkDestroySamplerYcbcrConversion_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroySamplerYcbcrConversion_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroySamplerYcbcrConversion_CALL_INSTANCE)); + CMOCK_vkDestroySamplerYcbcrConversion_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroySamplerYcbcrConversion_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroySamplerYcbcrConversion_CallInstance = CMock_Guts_MemChain(Mock.vkDestroySamplerYcbcrConversion_CallInstance, cmock_guts_index); + Mock.vkDestroySamplerYcbcrConversion_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroySamplerYcbcrConversion(cmock_call_instance, device, ycbcrConversion, pAllocator); +} + +void vkDestroySamplerYcbcrConversion_AddCallback(CMOCK_vkDestroySamplerYcbcrConversion_CALLBACK Callback) +{ + Mock.vkDestroySamplerYcbcrConversion_IgnoreBool = (char)0; + Mock.vkDestroySamplerYcbcrConversion_CallbackBool = (char)1; + Mock.vkDestroySamplerYcbcrConversion_CallbackFunctionPointer = Callback; +} + +void vkDestroySamplerYcbcrConversion_Stub(CMOCK_vkDestroySamplerYcbcrConversion_CALLBACK Callback) +{ + Mock.vkDestroySamplerYcbcrConversion_IgnoreBool = (char)0; + Mock.vkDestroySamplerYcbcrConversion_CallbackBool = (char)0; + Mock.vkDestroySamplerYcbcrConversion_CallbackFunctionPointer = Callback; +} + +void vkDestroySamplerYcbcrConversion_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroySamplerYcbcrConversion_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroySamplerYcbcrConversion_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroySamplerYcbcrConversion_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroySamplerYcbcrConversion_CMockIgnoreArg_ycbcrConversion(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroySamplerYcbcrConversion_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroySamplerYcbcrConversion_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroySamplerYcbcrConversion_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_ycbcrConversion = 1; +} + +void vkDestroySamplerYcbcrConversion_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroySamplerYcbcrConversion_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroySamplerYcbcrConversion_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroySamplerYcbcrConversion_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +VkResult vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateDescriptorUpdateTemplate_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateDescriptorUpdateTemplate); + cmock_call_instance = (CMOCK_vkCreateDescriptorUpdateTemplate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateDescriptorUpdateTemplate_CallInstance); + Mock.vkCreateDescriptorUpdateTemplate_CallInstance = CMock_Guts_MemNext(Mock.vkCreateDescriptorUpdateTemplate_CallInstance); + if (Mock.vkCreateDescriptorUpdateTemplate_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateDescriptorUpdateTemplate_FinalReturn; + memcpy((void*)(&Mock.vkCreateDescriptorUpdateTemplate_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateDescriptorUpdateTemplate_CallbackBool && + Mock.vkCreateDescriptorUpdateTemplate_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateDescriptorUpdateTemplate_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, Mock.vkCreateDescriptorUpdateTemplate_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateDescriptorUpdateTemplate,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateDescriptorUpdateTemplate,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkDescriptorUpdateTemplateCreateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateDescriptorUpdateTemplate,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDescriptorUpdateTemplate) + { + UNITY_SET_DETAILS(CMockString_vkCreateDescriptorUpdateTemplate,CMockString_pDescriptorUpdateTemplate); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDescriptorUpdateTemplate), (void*)(pDescriptorUpdateTemplate), sizeof(VkDescriptorUpdateTemplate), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateDescriptorUpdateTemplate_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateDescriptorUpdateTemplate_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, Mock.vkCreateDescriptorUpdateTemplate_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pDescriptorUpdateTemplate_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pDescriptorUpdateTemplate, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pDescriptorUpdateTemplate, (const void*)cmock_call_instance->ReturnThruPtr_pDescriptorUpdateTemplate_Val, + cmock_call_instance->ReturnThruPtr_pDescriptorUpdateTemplate_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateDescriptorUpdateTemplate(CMOCK_vkCreateDescriptorUpdateTemplate_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); +void CMockExpectParameters_vkCreateDescriptorUpdateTemplate(CMOCK_vkCreateDescriptorUpdateTemplate_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pDescriptorUpdateTemplate = pDescriptorUpdateTemplate; + cmock_call_instance->IgnoreArg_pDescriptorUpdateTemplate = 0; + cmock_call_instance->ReturnThruPtr_pDescriptorUpdateTemplate_Used = 0; +} + +void vkCreateDescriptorUpdateTemplate_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateDescriptorUpdateTemplate_CALL_INSTANCE)); + CMOCK_vkCreateDescriptorUpdateTemplate_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorUpdateTemplate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateDescriptorUpdateTemplate_CallInstance = CMock_Guts_MemChain(Mock.vkCreateDescriptorUpdateTemplate_CallInstance, cmock_guts_index); + Mock.vkCreateDescriptorUpdateTemplate_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateDescriptorUpdateTemplate_IgnoreBool = (char)1; +} + +void vkCreateDescriptorUpdateTemplate_CMockStopIgnore(void) +{ + if(Mock.vkCreateDescriptorUpdateTemplate_IgnoreBool) + Mock.vkCreateDescriptorUpdateTemplate_CallInstance = CMock_Guts_MemNext(Mock.vkCreateDescriptorUpdateTemplate_CallInstance); + Mock.vkCreateDescriptorUpdateTemplate_IgnoreBool = (char)0; +} + +void vkCreateDescriptorUpdateTemplate_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateDescriptorUpdateTemplate_CALL_INSTANCE)); + CMOCK_vkCreateDescriptorUpdateTemplate_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorUpdateTemplate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateDescriptorUpdateTemplate_CallInstance = CMock_Guts_MemChain(Mock.vkCreateDescriptorUpdateTemplate_CallInstance, cmock_guts_index); + Mock.vkCreateDescriptorUpdateTemplate_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateDescriptorUpdateTemplate_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateDescriptorUpdateTemplate_CALL_INSTANCE)); + CMOCK_vkCreateDescriptorUpdateTemplate_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorUpdateTemplate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateDescriptorUpdateTemplate_CallInstance = CMock_Guts_MemChain(Mock.vkCreateDescriptorUpdateTemplate_CallInstance, cmock_guts_index); + Mock.vkCreateDescriptorUpdateTemplate_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateDescriptorUpdateTemplate(cmock_call_instance, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateDescriptorUpdateTemplate_AddCallback(CMOCK_vkCreateDescriptorUpdateTemplate_CALLBACK Callback) +{ + Mock.vkCreateDescriptorUpdateTemplate_IgnoreBool = (char)0; + Mock.vkCreateDescriptorUpdateTemplate_CallbackBool = (char)1; + Mock.vkCreateDescriptorUpdateTemplate_CallbackFunctionPointer = Callback; +} + +void vkCreateDescriptorUpdateTemplate_Stub(CMOCK_vkCreateDescriptorUpdateTemplate_CALLBACK Callback) +{ + Mock.vkCreateDescriptorUpdateTemplate_IgnoreBool = (char)0; + Mock.vkCreateDescriptorUpdateTemplate_CallbackBool = (char)0; + Mock.vkCreateDescriptorUpdateTemplate_CallbackFunctionPointer = Callback; +} + +void vkCreateDescriptorUpdateTemplate_CMockReturnMemThruPtr_pDescriptorUpdateTemplate(UNITY_LINE_TYPE cmock_line, VkDescriptorUpdateTemplate const* pDescriptorUpdateTemplate, size_t cmock_size) +{ + CMOCK_vkCreateDescriptorUpdateTemplate_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorUpdateTemplate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDescriptorUpdateTemplate_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pDescriptorUpdateTemplate_Used = 1; + cmock_call_instance->ReturnThruPtr_pDescriptorUpdateTemplate_Val = pDescriptorUpdateTemplate; + cmock_call_instance->ReturnThruPtr_pDescriptorUpdateTemplate_Size = cmock_size; +} + +void vkCreateDescriptorUpdateTemplate_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDescriptorUpdateTemplate_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorUpdateTemplate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDescriptorUpdateTemplate_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateDescriptorUpdateTemplate_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDescriptorUpdateTemplate_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorUpdateTemplate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDescriptorUpdateTemplate_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateDescriptorUpdateTemplate_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDescriptorUpdateTemplate_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorUpdateTemplate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDescriptorUpdateTemplate_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateDescriptorUpdateTemplate_CMockIgnoreArg_pDescriptorUpdateTemplate(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDescriptorUpdateTemplate_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorUpdateTemplate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDescriptorUpdateTemplate_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDescriptorUpdateTemplate = 1; +} + +void vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyDescriptorUpdateTemplate_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyDescriptorUpdateTemplate); + cmock_call_instance = (CMOCK_vkDestroyDescriptorUpdateTemplate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyDescriptorUpdateTemplate_CallInstance); + Mock.vkDestroyDescriptorUpdateTemplate_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyDescriptorUpdateTemplate_CallInstance); + if (Mock.vkDestroyDescriptorUpdateTemplate_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyDescriptorUpdateTemplate_CallbackBool && + Mock.vkDestroyDescriptorUpdateTemplate_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyDescriptorUpdateTemplate_CallbackFunctionPointer(device, descriptorUpdateTemplate, pAllocator, Mock.vkDestroyDescriptorUpdateTemplate_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyDescriptorUpdateTemplate,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_descriptorUpdateTemplate) + { + UNITY_SET_DETAILS(CMockString_vkDestroyDescriptorUpdateTemplate,CMockString_descriptorUpdateTemplate); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_descriptorUpdateTemplate), (void*)(&descriptorUpdateTemplate), sizeof(VkDescriptorUpdateTemplate), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyDescriptorUpdateTemplate,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyDescriptorUpdateTemplate_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyDescriptorUpdateTemplate_CallbackFunctionPointer(device, descriptorUpdateTemplate, pAllocator, Mock.vkDestroyDescriptorUpdateTemplate_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyDescriptorUpdateTemplate(CMOCK_vkDestroyDescriptorUpdateTemplate_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyDescriptorUpdateTemplate(CMOCK_vkDestroyDescriptorUpdateTemplate_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_descriptorUpdateTemplate), (void*)(&descriptorUpdateTemplate), + sizeof(VkDescriptorUpdateTemplate[sizeof(descriptorUpdateTemplate) == sizeof(VkDescriptorUpdateTemplate) ? 1 : -1])); /* add VkDescriptorUpdateTemplate to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_descriptorUpdateTemplate = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyDescriptorUpdateTemplate_CMockIgnore(void) +{ + Mock.vkDestroyDescriptorUpdateTemplate_IgnoreBool = (char)1; +} + +void vkDestroyDescriptorUpdateTemplate_CMockStopIgnore(void) +{ + Mock.vkDestroyDescriptorUpdateTemplate_IgnoreBool = (char)0; +} + +void vkDestroyDescriptorUpdateTemplate_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyDescriptorUpdateTemplate_CALL_INSTANCE)); + CMOCK_vkDestroyDescriptorUpdateTemplate_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDescriptorUpdateTemplate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyDescriptorUpdateTemplate_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyDescriptorUpdateTemplate_CallInstance, cmock_guts_index); + Mock.vkDestroyDescriptorUpdateTemplate_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyDescriptorUpdateTemplate_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyDescriptorUpdateTemplate_CALL_INSTANCE)); + CMOCK_vkDestroyDescriptorUpdateTemplate_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDescriptorUpdateTemplate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyDescriptorUpdateTemplate_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyDescriptorUpdateTemplate_CallInstance, cmock_guts_index); + Mock.vkDestroyDescriptorUpdateTemplate_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyDescriptorUpdateTemplate(cmock_call_instance, device, descriptorUpdateTemplate, pAllocator); +} + +void vkDestroyDescriptorUpdateTemplate_AddCallback(CMOCK_vkDestroyDescriptorUpdateTemplate_CALLBACK Callback) +{ + Mock.vkDestroyDescriptorUpdateTemplate_IgnoreBool = (char)0; + Mock.vkDestroyDescriptorUpdateTemplate_CallbackBool = (char)1; + Mock.vkDestroyDescriptorUpdateTemplate_CallbackFunctionPointer = Callback; +} + +void vkDestroyDescriptorUpdateTemplate_Stub(CMOCK_vkDestroyDescriptorUpdateTemplate_CALLBACK Callback) +{ + Mock.vkDestroyDescriptorUpdateTemplate_IgnoreBool = (char)0; + Mock.vkDestroyDescriptorUpdateTemplate_CallbackBool = (char)0; + Mock.vkDestroyDescriptorUpdateTemplate_CallbackFunctionPointer = Callback; +} + +void vkDestroyDescriptorUpdateTemplate_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyDescriptorUpdateTemplate_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDescriptorUpdateTemplate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyDescriptorUpdateTemplate_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyDescriptorUpdateTemplate_CMockIgnoreArg_descriptorUpdateTemplate(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyDescriptorUpdateTemplate_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDescriptorUpdateTemplate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyDescriptorUpdateTemplate_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_descriptorUpdateTemplate = 1; +} + +void vkDestroyDescriptorUpdateTemplate_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyDescriptorUpdateTemplate_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDescriptorUpdateTemplate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyDescriptorUpdateTemplate_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkUpdateDescriptorSetWithTemplate_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkUpdateDescriptorSetWithTemplate); + cmock_call_instance = (CMOCK_vkUpdateDescriptorSetWithTemplate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkUpdateDescriptorSetWithTemplate_CallInstance); + Mock.vkUpdateDescriptorSetWithTemplate_CallInstance = CMock_Guts_MemNext(Mock.vkUpdateDescriptorSetWithTemplate_CallInstance); + if (Mock.vkUpdateDescriptorSetWithTemplate_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkUpdateDescriptorSetWithTemplate_CallbackBool && + Mock.vkUpdateDescriptorSetWithTemplate_CallbackFunctionPointer != NULL) + { + Mock.vkUpdateDescriptorSetWithTemplate_CallbackFunctionPointer(device, descriptorSet, descriptorUpdateTemplate, pData, Mock.vkUpdateDescriptorSetWithTemplate_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkUpdateDescriptorSetWithTemplate,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_descriptorSet) + { + UNITY_SET_DETAILS(CMockString_vkUpdateDescriptorSetWithTemplate,CMockString_descriptorSet); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_descriptorSet), (void*)(&descriptorSet), sizeof(VkDescriptorSet), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_descriptorUpdateTemplate) + { + UNITY_SET_DETAILS(CMockString_vkUpdateDescriptorSetWithTemplate,CMockString_descriptorUpdateTemplate); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_descriptorUpdateTemplate), (void*)(&descriptorUpdateTemplate), sizeof(VkDescriptorUpdateTemplate), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pData) + { + UNITY_SET_DETAILS(CMockString_vkUpdateDescriptorSetWithTemplate,CMockString_pData); + if (cmock_call_instance->Expected_pData == NULL) + { UNITY_TEST_ASSERT_NULL(pData, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(cmock_call_instance->Expected_pData, pData, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkUpdateDescriptorSetWithTemplate_CallbackFunctionPointer != NULL) + { + Mock.vkUpdateDescriptorSetWithTemplate_CallbackFunctionPointer(device, descriptorSet, descriptorUpdateTemplate, pData, Mock.vkUpdateDescriptorSetWithTemplate_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkUpdateDescriptorSetWithTemplate(CMOCK_vkUpdateDescriptorSetWithTemplate_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); +void CMockExpectParameters_vkUpdateDescriptorSetWithTemplate(CMOCK_vkUpdateDescriptorSetWithTemplate_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_descriptorSet), (void*)(&descriptorSet), + sizeof(VkDescriptorSet[sizeof(descriptorSet) == sizeof(VkDescriptorSet) ? 1 : -1])); /* add VkDescriptorSet to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_descriptorSet = 0; + memcpy((void*)(&cmock_call_instance->Expected_descriptorUpdateTemplate), (void*)(&descriptorUpdateTemplate), + sizeof(VkDescriptorUpdateTemplate[sizeof(descriptorUpdateTemplate) == sizeof(VkDescriptorUpdateTemplate) ? 1 : -1])); /* add VkDescriptorUpdateTemplate to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_descriptorUpdateTemplate = 0; + cmock_call_instance->Expected_pData = pData; + cmock_call_instance->IgnoreArg_pData = 0; +} + +void vkUpdateDescriptorSetWithTemplate_CMockIgnore(void) +{ + Mock.vkUpdateDescriptorSetWithTemplate_IgnoreBool = (char)1; +} + +void vkUpdateDescriptorSetWithTemplate_CMockStopIgnore(void) +{ + Mock.vkUpdateDescriptorSetWithTemplate_IgnoreBool = (char)0; +} + +void vkUpdateDescriptorSetWithTemplate_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkUpdateDescriptorSetWithTemplate_CALL_INSTANCE)); + CMOCK_vkUpdateDescriptorSetWithTemplate_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUpdateDescriptorSetWithTemplate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkUpdateDescriptorSetWithTemplate_CallInstance = CMock_Guts_MemChain(Mock.vkUpdateDescriptorSetWithTemplate_CallInstance, cmock_guts_index); + Mock.vkUpdateDescriptorSetWithTemplate_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkUpdateDescriptorSetWithTemplate_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkUpdateDescriptorSetWithTemplate_CALL_INSTANCE)); + CMOCK_vkUpdateDescriptorSetWithTemplate_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUpdateDescriptorSetWithTemplate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkUpdateDescriptorSetWithTemplate_CallInstance = CMock_Guts_MemChain(Mock.vkUpdateDescriptorSetWithTemplate_CallInstance, cmock_guts_index); + Mock.vkUpdateDescriptorSetWithTemplate_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkUpdateDescriptorSetWithTemplate(cmock_call_instance, device, descriptorSet, descriptorUpdateTemplate, pData); +} + +void vkUpdateDescriptorSetWithTemplate_AddCallback(CMOCK_vkUpdateDescriptorSetWithTemplate_CALLBACK Callback) +{ + Mock.vkUpdateDescriptorSetWithTemplate_IgnoreBool = (char)0; + Mock.vkUpdateDescriptorSetWithTemplate_CallbackBool = (char)1; + Mock.vkUpdateDescriptorSetWithTemplate_CallbackFunctionPointer = Callback; +} + +void vkUpdateDescriptorSetWithTemplate_Stub(CMOCK_vkUpdateDescriptorSetWithTemplate_CALLBACK Callback) +{ + Mock.vkUpdateDescriptorSetWithTemplate_IgnoreBool = (char)0; + Mock.vkUpdateDescriptorSetWithTemplate_CallbackBool = (char)0; + Mock.vkUpdateDescriptorSetWithTemplate_CallbackFunctionPointer = Callback; +} + +void vkUpdateDescriptorSetWithTemplate_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkUpdateDescriptorSetWithTemplate_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUpdateDescriptorSetWithTemplate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkUpdateDescriptorSetWithTemplate_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkUpdateDescriptorSetWithTemplate_CMockIgnoreArg_descriptorSet(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkUpdateDescriptorSetWithTemplate_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUpdateDescriptorSetWithTemplate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkUpdateDescriptorSetWithTemplate_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_descriptorSet = 1; +} + +void vkUpdateDescriptorSetWithTemplate_CMockIgnoreArg_descriptorUpdateTemplate(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkUpdateDescriptorSetWithTemplate_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUpdateDescriptorSetWithTemplate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkUpdateDescriptorSetWithTemplate_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_descriptorUpdateTemplate = 1; +} + +void vkUpdateDescriptorSetWithTemplate_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkUpdateDescriptorSetWithTemplate_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUpdateDescriptorSetWithTemplate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkUpdateDescriptorSetWithTemplate_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pData = 1; +} + +void vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceExternalBufferProperties_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceExternalBufferProperties); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalBufferProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceExternalBufferProperties_CallInstance); + Mock.vkGetPhysicalDeviceExternalBufferProperties_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceExternalBufferProperties_CallInstance); + if (Mock.vkGetPhysicalDeviceExternalBufferProperties_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetPhysicalDeviceExternalBufferProperties_CallbackBool && + Mock.vkGetPhysicalDeviceExternalBufferProperties_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceExternalBufferProperties_CallbackFunctionPointer(physicalDevice, pExternalBufferInfo, pExternalBufferProperties, Mock.vkGetPhysicalDeviceExternalBufferProperties_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceExternalBufferProperties,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pExternalBufferInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceExternalBufferProperties,CMockString_pExternalBufferInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pExternalBufferInfo), (void*)(pExternalBufferInfo), sizeof(const VkPhysicalDeviceExternalBufferInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pExternalBufferProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceExternalBufferProperties,CMockString_pExternalBufferProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pExternalBufferProperties), (void*)(pExternalBufferProperties), sizeof(VkExternalBufferProperties), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceExternalBufferProperties_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceExternalBufferProperties_CallbackFunctionPointer(physicalDevice, pExternalBufferInfo, pExternalBufferProperties, Mock.vkGetPhysicalDeviceExternalBufferProperties_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pExternalBufferProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pExternalBufferProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pExternalBufferProperties, (const void*)cmock_call_instance->ReturnThruPtr_pExternalBufferProperties_Val, + cmock_call_instance->ReturnThruPtr_pExternalBufferProperties_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetPhysicalDeviceExternalBufferProperties(CMOCK_vkGetPhysicalDeviceExternalBufferProperties_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); +void CMockExpectParameters_vkGetPhysicalDeviceExternalBufferProperties(CMOCK_vkGetPhysicalDeviceExternalBufferProperties_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pExternalBufferInfo = pExternalBufferInfo; + cmock_call_instance->IgnoreArg_pExternalBufferInfo = 0; + cmock_call_instance->Expected_pExternalBufferProperties = pExternalBufferProperties; + cmock_call_instance->IgnoreArg_pExternalBufferProperties = 0; + cmock_call_instance->ReturnThruPtr_pExternalBufferProperties_Used = 0; +} + +void vkGetPhysicalDeviceExternalBufferProperties_CMockIgnore(void) +{ + Mock.vkGetPhysicalDeviceExternalBufferProperties_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceExternalBufferProperties_CMockStopIgnore(void) +{ + Mock.vkGetPhysicalDeviceExternalBufferProperties_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceExternalBufferProperties_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceExternalBufferProperties_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceExternalBufferProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalBufferProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceExternalBufferProperties_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceExternalBufferProperties_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceExternalBufferProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceExternalBufferProperties_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceExternalBufferProperties_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceExternalBufferProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalBufferProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceExternalBufferProperties_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceExternalBufferProperties_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceExternalBufferProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceExternalBufferProperties(cmock_call_instance, physicalDevice, pExternalBufferInfo, pExternalBufferProperties); +} + +void vkGetPhysicalDeviceExternalBufferProperties_AddCallback(CMOCK_vkGetPhysicalDeviceExternalBufferProperties_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceExternalBufferProperties_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceExternalBufferProperties_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceExternalBufferProperties_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceExternalBufferProperties_Stub(CMOCK_vkGetPhysicalDeviceExternalBufferProperties_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceExternalBufferProperties_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceExternalBufferProperties_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceExternalBufferProperties_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceExternalBufferProperties_CMockReturnMemThruPtr_pExternalBufferProperties(UNITY_LINE_TYPE cmock_line, VkExternalBufferProperties const* pExternalBufferProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceExternalBufferProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalBufferProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalBufferProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pExternalBufferProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pExternalBufferProperties_Val = pExternalBufferProperties; + cmock_call_instance->ReturnThruPtr_pExternalBufferProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceExternalBufferProperties_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceExternalBufferProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalBufferProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalBufferProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceExternalBufferProperties_CMockIgnoreArg_pExternalBufferInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceExternalBufferProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalBufferProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalBufferProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pExternalBufferInfo = 1; +} + +void vkGetPhysicalDeviceExternalBufferProperties_CMockIgnoreArg_pExternalBufferProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceExternalBufferProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalBufferProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalBufferProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pExternalBufferProperties = 1; +} + +void vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceExternalFenceProperties_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceExternalFenceProperties); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalFenceProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceExternalFenceProperties_CallInstance); + Mock.vkGetPhysicalDeviceExternalFenceProperties_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceExternalFenceProperties_CallInstance); + if (Mock.vkGetPhysicalDeviceExternalFenceProperties_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetPhysicalDeviceExternalFenceProperties_CallbackBool && + Mock.vkGetPhysicalDeviceExternalFenceProperties_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceExternalFenceProperties_CallbackFunctionPointer(physicalDevice, pExternalFenceInfo, pExternalFenceProperties, Mock.vkGetPhysicalDeviceExternalFenceProperties_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceExternalFenceProperties,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pExternalFenceInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceExternalFenceProperties,CMockString_pExternalFenceInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pExternalFenceInfo), (void*)(pExternalFenceInfo), sizeof(const VkPhysicalDeviceExternalFenceInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pExternalFenceProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceExternalFenceProperties,CMockString_pExternalFenceProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pExternalFenceProperties), (void*)(pExternalFenceProperties), sizeof(VkExternalFenceProperties), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceExternalFenceProperties_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceExternalFenceProperties_CallbackFunctionPointer(physicalDevice, pExternalFenceInfo, pExternalFenceProperties, Mock.vkGetPhysicalDeviceExternalFenceProperties_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pExternalFenceProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pExternalFenceProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pExternalFenceProperties, (const void*)cmock_call_instance->ReturnThruPtr_pExternalFenceProperties_Val, + cmock_call_instance->ReturnThruPtr_pExternalFenceProperties_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetPhysicalDeviceExternalFenceProperties(CMOCK_vkGetPhysicalDeviceExternalFenceProperties_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); +void CMockExpectParameters_vkGetPhysicalDeviceExternalFenceProperties(CMOCK_vkGetPhysicalDeviceExternalFenceProperties_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pExternalFenceInfo = pExternalFenceInfo; + cmock_call_instance->IgnoreArg_pExternalFenceInfo = 0; + cmock_call_instance->Expected_pExternalFenceProperties = pExternalFenceProperties; + cmock_call_instance->IgnoreArg_pExternalFenceProperties = 0; + cmock_call_instance->ReturnThruPtr_pExternalFenceProperties_Used = 0; +} + +void vkGetPhysicalDeviceExternalFenceProperties_CMockIgnore(void) +{ + Mock.vkGetPhysicalDeviceExternalFenceProperties_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceExternalFenceProperties_CMockStopIgnore(void) +{ + Mock.vkGetPhysicalDeviceExternalFenceProperties_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceExternalFenceProperties_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceExternalFenceProperties_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceExternalFenceProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalFenceProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceExternalFenceProperties_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceExternalFenceProperties_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceExternalFenceProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceExternalFenceProperties_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceExternalFenceProperties_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceExternalFenceProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalFenceProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceExternalFenceProperties_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceExternalFenceProperties_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceExternalFenceProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceExternalFenceProperties(cmock_call_instance, physicalDevice, pExternalFenceInfo, pExternalFenceProperties); +} + +void vkGetPhysicalDeviceExternalFenceProperties_AddCallback(CMOCK_vkGetPhysicalDeviceExternalFenceProperties_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceExternalFenceProperties_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceExternalFenceProperties_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceExternalFenceProperties_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceExternalFenceProperties_Stub(CMOCK_vkGetPhysicalDeviceExternalFenceProperties_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceExternalFenceProperties_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceExternalFenceProperties_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceExternalFenceProperties_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceExternalFenceProperties_CMockReturnMemThruPtr_pExternalFenceProperties(UNITY_LINE_TYPE cmock_line, VkExternalFenceProperties const* pExternalFenceProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceExternalFenceProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalFenceProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalFenceProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pExternalFenceProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pExternalFenceProperties_Val = pExternalFenceProperties; + cmock_call_instance->ReturnThruPtr_pExternalFenceProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceExternalFenceProperties_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceExternalFenceProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalFenceProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalFenceProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceExternalFenceProperties_CMockIgnoreArg_pExternalFenceInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceExternalFenceProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalFenceProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalFenceProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pExternalFenceInfo = 1; +} + +void vkGetPhysicalDeviceExternalFenceProperties_CMockIgnoreArg_pExternalFenceProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceExternalFenceProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalFenceProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalFenceProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pExternalFenceProperties = 1; +} + +void vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceExternalSemaphoreProperties_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceExternalSemaphoreProperties); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalSemaphoreProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_CallInstance); + Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_CallInstance); + if (Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_CallbackBool && + Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_CallbackFunctionPointer(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceExternalSemaphoreProperties,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pExternalSemaphoreInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceExternalSemaphoreProperties,CMockString_pExternalSemaphoreInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pExternalSemaphoreInfo), (void*)(pExternalSemaphoreInfo), sizeof(const VkPhysicalDeviceExternalSemaphoreInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pExternalSemaphoreProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceExternalSemaphoreProperties,CMockString_pExternalSemaphoreProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pExternalSemaphoreProperties), (void*)(pExternalSemaphoreProperties), sizeof(VkExternalSemaphoreProperties), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_CallbackFunctionPointer(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pExternalSemaphoreProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pExternalSemaphoreProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pExternalSemaphoreProperties, (const void*)cmock_call_instance->ReturnThruPtr_pExternalSemaphoreProperties_Val, + cmock_call_instance->ReturnThruPtr_pExternalSemaphoreProperties_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetPhysicalDeviceExternalSemaphoreProperties(CMOCK_vkGetPhysicalDeviceExternalSemaphoreProperties_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); +void CMockExpectParameters_vkGetPhysicalDeviceExternalSemaphoreProperties(CMOCK_vkGetPhysicalDeviceExternalSemaphoreProperties_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pExternalSemaphoreInfo = pExternalSemaphoreInfo; + cmock_call_instance->IgnoreArg_pExternalSemaphoreInfo = 0; + cmock_call_instance->Expected_pExternalSemaphoreProperties = pExternalSemaphoreProperties; + cmock_call_instance->IgnoreArg_pExternalSemaphoreProperties = 0; + cmock_call_instance->ReturnThruPtr_pExternalSemaphoreProperties_Used = 0; +} + +void vkGetPhysicalDeviceExternalSemaphoreProperties_CMockIgnore(void) +{ + Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceExternalSemaphoreProperties_CMockStopIgnore(void) +{ + Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceExternalSemaphoreProperties_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceExternalSemaphoreProperties_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceExternalSemaphoreProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalSemaphoreProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceExternalSemaphoreProperties_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceExternalSemaphoreProperties_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceExternalSemaphoreProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalSemaphoreProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceExternalSemaphoreProperties(cmock_call_instance, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); +} + +void vkGetPhysicalDeviceExternalSemaphoreProperties_AddCallback(CMOCK_vkGetPhysicalDeviceExternalSemaphoreProperties_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceExternalSemaphoreProperties_Stub(CMOCK_vkGetPhysicalDeviceExternalSemaphoreProperties_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceExternalSemaphoreProperties_CMockReturnMemThruPtr_pExternalSemaphoreProperties(UNITY_LINE_TYPE cmock_line, VkExternalSemaphoreProperties const* pExternalSemaphoreProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceExternalSemaphoreProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalSemaphoreProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pExternalSemaphoreProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pExternalSemaphoreProperties_Val = pExternalSemaphoreProperties; + cmock_call_instance->ReturnThruPtr_pExternalSemaphoreProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceExternalSemaphoreProperties_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceExternalSemaphoreProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalSemaphoreProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceExternalSemaphoreProperties_CMockIgnoreArg_pExternalSemaphoreInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceExternalSemaphoreProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalSemaphoreProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pExternalSemaphoreInfo = 1; +} + +void vkGetPhysicalDeviceExternalSemaphoreProperties_CMockIgnoreArg_pExternalSemaphoreProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceExternalSemaphoreProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalSemaphoreProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalSemaphoreProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pExternalSemaphoreProperties = 1; +} + +void vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDescriptorSetLayoutSupport_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDescriptorSetLayoutSupport); + cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutSupport_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDescriptorSetLayoutSupport_CallInstance); + Mock.vkGetDescriptorSetLayoutSupport_CallInstance = CMock_Guts_MemNext(Mock.vkGetDescriptorSetLayoutSupport_CallInstance); + if (Mock.vkGetDescriptorSetLayoutSupport_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetDescriptorSetLayoutSupport_CallbackBool && + Mock.vkGetDescriptorSetLayoutSupport_CallbackFunctionPointer != NULL) + { + Mock.vkGetDescriptorSetLayoutSupport_CallbackFunctionPointer(device, pCreateInfo, pSupport, Mock.vkGetDescriptorSetLayoutSupport_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetDescriptorSetLayoutSupport,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetDescriptorSetLayoutSupport,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkDescriptorSetLayoutCreateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSupport) + { + UNITY_SET_DETAILS(CMockString_vkGetDescriptorSetLayoutSupport,CMockString_pSupport); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSupport), (void*)(pSupport), sizeof(VkDescriptorSetLayoutSupport), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDescriptorSetLayoutSupport_CallbackFunctionPointer != NULL) + { + Mock.vkGetDescriptorSetLayoutSupport_CallbackFunctionPointer(device, pCreateInfo, pSupport, Mock.vkGetDescriptorSetLayoutSupport_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pSupport_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSupport, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSupport, (const void*)cmock_call_instance->ReturnThruPtr_pSupport_Val, + cmock_call_instance->ReturnThruPtr_pSupport_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetDescriptorSetLayoutSupport(CMOCK_vkGetDescriptorSetLayoutSupport_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); +void CMockExpectParameters_vkGetDescriptorSetLayoutSupport(CMOCK_vkGetDescriptorSetLayoutSupport_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pSupport = pSupport; + cmock_call_instance->IgnoreArg_pSupport = 0; + cmock_call_instance->ReturnThruPtr_pSupport_Used = 0; +} + +void vkGetDescriptorSetLayoutSupport_CMockIgnore(void) +{ + Mock.vkGetDescriptorSetLayoutSupport_IgnoreBool = (char)1; +} + +void vkGetDescriptorSetLayoutSupport_CMockStopIgnore(void) +{ + Mock.vkGetDescriptorSetLayoutSupport_IgnoreBool = (char)0; +} + +void vkGetDescriptorSetLayoutSupport_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDescriptorSetLayoutSupport_CALL_INSTANCE)); + CMOCK_vkGetDescriptorSetLayoutSupport_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutSupport_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDescriptorSetLayoutSupport_CallInstance = CMock_Guts_MemChain(Mock.vkGetDescriptorSetLayoutSupport_CallInstance, cmock_guts_index); + Mock.vkGetDescriptorSetLayoutSupport_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDescriptorSetLayoutSupport_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDescriptorSetLayoutSupport_CALL_INSTANCE)); + CMOCK_vkGetDescriptorSetLayoutSupport_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutSupport_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDescriptorSetLayoutSupport_CallInstance = CMock_Guts_MemChain(Mock.vkGetDescriptorSetLayoutSupport_CallInstance, cmock_guts_index); + Mock.vkGetDescriptorSetLayoutSupport_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDescriptorSetLayoutSupport(cmock_call_instance, device, pCreateInfo, pSupport); +} + +void vkGetDescriptorSetLayoutSupport_AddCallback(CMOCK_vkGetDescriptorSetLayoutSupport_CALLBACK Callback) +{ + Mock.vkGetDescriptorSetLayoutSupport_IgnoreBool = (char)0; + Mock.vkGetDescriptorSetLayoutSupport_CallbackBool = (char)1; + Mock.vkGetDescriptorSetLayoutSupport_CallbackFunctionPointer = Callback; +} + +void vkGetDescriptorSetLayoutSupport_Stub(CMOCK_vkGetDescriptorSetLayoutSupport_CALLBACK Callback) +{ + Mock.vkGetDescriptorSetLayoutSupport_IgnoreBool = (char)0; + Mock.vkGetDescriptorSetLayoutSupport_CallbackBool = (char)0; + Mock.vkGetDescriptorSetLayoutSupport_CallbackFunctionPointer = Callback; +} + +void vkGetDescriptorSetLayoutSupport_CMockReturnMemThruPtr_pSupport(UNITY_LINE_TYPE cmock_line, VkDescriptorSetLayoutSupport const* pSupport, size_t cmock_size) +{ + CMOCK_vkGetDescriptorSetLayoutSupport_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutSupport_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDescriptorSetLayoutSupport_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSupport_Used = 1; + cmock_call_instance->ReturnThruPtr_pSupport_Val = pSupport; + cmock_call_instance->ReturnThruPtr_pSupport_Size = cmock_size; +} + +void vkGetDescriptorSetLayoutSupport_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDescriptorSetLayoutSupport_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutSupport_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDescriptorSetLayoutSupport_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetDescriptorSetLayoutSupport_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDescriptorSetLayoutSupport_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutSupport_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDescriptorSetLayoutSupport_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkGetDescriptorSetLayoutSupport_CMockIgnoreArg_pSupport(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDescriptorSetLayoutSupport_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutSupport_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDescriptorSetLayoutSupport_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSupport = 1; +} + +void vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDrawIndirectCount_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDrawIndirectCount); + cmock_call_instance = (CMOCK_vkCmdDrawIndirectCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDrawIndirectCount_CallInstance); + Mock.vkCmdDrawIndirectCount_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDrawIndirectCount_CallInstance); + if (Mock.vkCmdDrawIndirectCount_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDrawIndirectCount_CallbackBool && + Mock.vkCmdDrawIndirectCount_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawIndirectCount_CallbackFunctionPointer(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, Mock.vkCmdDrawIndirectCount_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirectCount,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_buffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirectCount,CMockString_buffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_offset) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirectCount,CMockString_offset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_countBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirectCount,CMockString_countBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_countBuffer), (void*)(&countBuffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_countBufferOffset) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirectCount,CMockString_countBufferOffset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_countBufferOffset), (void*)(&countBufferOffset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_maxDrawCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirectCount,CMockString_maxDrawCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_maxDrawCount, maxDrawCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_stride) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirectCount,CMockString_stride); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_stride, stride, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdDrawIndirectCount_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawIndirectCount_CallbackFunctionPointer(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, Mock.vkCmdDrawIndirectCount_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDrawIndirectCount(CMOCK_vkCmdDrawIndirectCount_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +void CMockExpectParameters_vkCmdDrawIndirectCount(CMOCK_vkCmdDrawIndirectCount_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), + sizeof(VkBuffer[sizeof(buffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_buffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), + sizeof(VkDeviceSize[sizeof(offset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_offset = 0; + memcpy((void*)(&cmock_call_instance->Expected_countBuffer), (void*)(&countBuffer), + sizeof(VkBuffer[sizeof(countBuffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_countBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_countBufferOffset), (void*)(&countBufferOffset), + sizeof(VkDeviceSize[sizeof(countBufferOffset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_countBufferOffset = 0; + cmock_call_instance->Expected_maxDrawCount = maxDrawCount; + cmock_call_instance->IgnoreArg_maxDrawCount = 0; + cmock_call_instance->Expected_stride = stride; + cmock_call_instance->IgnoreArg_stride = 0; +} + +void vkCmdDrawIndirectCount_CMockIgnore(void) +{ + Mock.vkCmdDrawIndirectCount_IgnoreBool = (char)1; +} + +void vkCmdDrawIndirectCount_CMockStopIgnore(void) +{ + Mock.vkCmdDrawIndirectCount_IgnoreBool = (char)0; +} + +void vkCmdDrawIndirectCount_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawIndirectCount_CALL_INSTANCE)); + CMOCK_vkCmdDrawIndirectCount_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawIndirectCount_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawIndirectCount_CallInstance, cmock_guts_index); + Mock.vkCmdDrawIndirectCount_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDrawIndirectCount_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawIndirectCount_CALL_INSTANCE)); + CMOCK_vkCmdDrawIndirectCount_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawIndirectCount_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawIndirectCount_CallInstance, cmock_guts_index); + Mock.vkCmdDrawIndirectCount_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDrawIndirectCount(cmock_call_instance, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); +} + +void vkCmdDrawIndirectCount_AddCallback(CMOCK_vkCmdDrawIndirectCount_CALLBACK Callback) +{ + Mock.vkCmdDrawIndirectCount_IgnoreBool = (char)0; + Mock.vkCmdDrawIndirectCount_CallbackBool = (char)1; + Mock.vkCmdDrawIndirectCount_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawIndirectCount_Stub(CMOCK_vkCmdDrawIndirectCount_CALLBACK Callback) +{ + Mock.vkCmdDrawIndirectCount_IgnoreBool = (char)0; + Mock.vkCmdDrawIndirectCount_CallbackBool = (char)0; + Mock.vkCmdDrawIndirectCount_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawIndirectCount_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirectCount_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirectCount_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDrawIndirectCount_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirectCount_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirectCount_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_buffer = 1; +} + +void vkCmdDrawIndirectCount_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirectCount_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirectCount_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_offset = 1; +} + +void vkCmdDrawIndirectCount_CMockIgnoreArg_countBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirectCount_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirectCount_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_countBuffer = 1; +} + +void vkCmdDrawIndirectCount_CMockIgnoreArg_countBufferOffset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirectCount_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirectCount_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_countBufferOffset = 1; +} + +void vkCmdDrawIndirectCount_CMockIgnoreArg_maxDrawCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirectCount_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirectCount_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_maxDrawCount = 1; +} + +void vkCmdDrawIndirectCount_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirectCount_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirectCount_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stride = 1; +} + +void vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDrawIndexedIndirectCount_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDrawIndexedIndirectCount); + cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirectCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDrawIndexedIndirectCount_CallInstance); + Mock.vkCmdDrawIndexedIndirectCount_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDrawIndexedIndirectCount_CallInstance); + if (Mock.vkCmdDrawIndexedIndirectCount_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDrawIndexedIndirectCount_CallbackBool && + Mock.vkCmdDrawIndexedIndirectCount_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawIndexedIndirectCount_CallbackFunctionPointer(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, Mock.vkCmdDrawIndexedIndirectCount_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexedIndirectCount,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_buffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexedIndirectCount,CMockString_buffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_offset) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexedIndirectCount,CMockString_offset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_countBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexedIndirectCount,CMockString_countBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_countBuffer), (void*)(&countBuffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_countBufferOffset) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexedIndirectCount,CMockString_countBufferOffset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_countBufferOffset), (void*)(&countBufferOffset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_maxDrawCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexedIndirectCount,CMockString_maxDrawCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_maxDrawCount, maxDrawCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_stride) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexedIndirectCount,CMockString_stride); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_stride, stride, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdDrawIndexedIndirectCount_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawIndexedIndirectCount_CallbackFunctionPointer(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, Mock.vkCmdDrawIndexedIndirectCount_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDrawIndexedIndirectCount(CMOCK_vkCmdDrawIndexedIndirectCount_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +void CMockExpectParameters_vkCmdDrawIndexedIndirectCount(CMOCK_vkCmdDrawIndexedIndirectCount_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), + sizeof(VkBuffer[sizeof(buffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_buffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), + sizeof(VkDeviceSize[sizeof(offset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_offset = 0; + memcpy((void*)(&cmock_call_instance->Expected_countBuffer), (void*)(&countBuffer), + sizeof(VkBuffer[sizeof(countBuffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_countBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_countBufferOffset), (void*)(&countBufferOffset), + sizeof(VkDeviceSize[sizeof(countBufferOffset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_countBufferOffset = 0; + cmock_call_instance->Expected_maxDrawCount = maxDrawCount; + cmock_call_instance->IgnoreArg_maxDrawCount = 0; + cmock_call_instance->Expected_stride = stride; + cmock_call_instance->IgnoreArg_stride = 0; +} + +void vkCmdDrawIndexedIndirectCount_CMockIgnore(void) +{ + Mock.vkCmdDrawIndexedIndirectCount_IgnoreBool = (char)1; +} + +void vkCmdDrawIndexedIndirectCount_CMockStopIgnore(void) +{ + Mock.vkCmdDrawIndexedIndirectCount_IgnoreBool = (char)0; +} + +void vkCmdDrawIndexedIndirectCount_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawIndexedIndirectCount_CALL_INSTANCE)); + CMOCK_vkCmdDrawIndexedIndirectCount_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirectCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawIndexedIndirectCount_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawIndexedIndirectCount_CallInstance, cmock_guts_index); + Mock.vkCmdDrawIndexedIndirectCount_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDrawIndexedIndirectCount_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawIndexedIndirectCount_CALL_INSTANCE)); + CMOCK_vkCmdDrawIndexedIndirectCount_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirectCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawIndexedIndirectCount_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawIndexedIndirectCount_CallInstance, cmock_guts_index); + Mock.vkCmdDrawIndexedIndirectCount_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDrawIndexedIndirectCount(cmock_call_instance, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); +} + +void vkCmdDrawIndexedIndirectCount_AddCallback(CMOCK_vkCmdDrawIndexedIndirectCount_CALLBACK Callback) +{ + Mock.vkCmdDrawIndexedIndirectCount_IgnoreBool = (char)0; + Mock.vkCmdDrawIndexedIndirectCount_CallbackBool = (char)1; + Mock.vkCmdDrawIndexedIndirectCount_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawIndexedIndirectCount_Stub(CMOCK_vkCmdDrawIndexedIndirectCount_CALLBACK Callback) +{ + Mock.vkCmdDrawIndexedIndirectCount_IgnoreBool = (char)0; + Mock.vkCmdDrawIndexedIndirectCount_CallbackBool = (char)0; + Mock.vkCmdDrawIndexedIndirectCount_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawIndexedIndirectCount_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexedIndirectCount_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirectCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexedIndirectCount_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDrawIndexedIndirectCount_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexedIndirectCount_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirectCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexedIndirectCount_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_buffer = 1; +} + +void vkCmdDrawIndexedIndirectCount_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexedIndirectCount_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirectCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexedIndirectCount_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_offset = 1; +} + +void vkCmdDrawIndexedIndirectCount_CMockIgnoreArg_countBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexedIndirectCount_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirectCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexedIndirectCount_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_countBuffer = 1; +} + +void vkCmdDrawIndexedIndirectCount_CMockIgnoreArg_countBufferOffset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexedIndirectCount_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirectCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexedIndirectCount_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_countBufferOffset = 1; +} + +void vkCmdDrawIndexedIndirectCount_CMockIgnoreArg_maxDrawCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexedIndirectCount_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirectCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexedIndirectCount_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_maxDrawCount = 1; +} + +void vkCmdDrawIndexedIndirectCount_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexedIndirectCount_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirectCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexedIndirectCount_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stride = 1; +} + +VkResult vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateRenderPass2_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateRenderPass2); + cmock_call_instance = (CMOCK_vkCreateRenderPass2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateRenderPass2_CallInstance); + Mock.vkCreateRenderPass2_CallInstance = CMock_Guts_MemNext(Mock.vkCreateRenderPass2_CallInstance); + if (Mock.vkCreateRenderPass2_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateRenderPass2_FinalReturn; + memcpy((void*)(&Mock.vkCreateRenderPass2_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateRenderPass2_CallbackBool && + Mock.vkCreateRenderPass2_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateRenderPass2_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pRenderPass, Mock.vkCreateRenderPass2_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateRenderPass2,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateRenderPass2,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkRenderPassCreateInfo2), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateRenderPass2,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pRenderPass) + { + UNITY_SET_DETAILS(CMockString_vkCreateRenderPass2,CMockString_pRenderPass); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pRenderPass), (void*)(pRenderPass), sizeof(VkRenderPass), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateRenderPass2_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateRenderPass2_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pRenderPass, Mock.vkCreateRenderPass2_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pRenderPass_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pRenderPass, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pRenderPass, (const void*)cmock_call_instance->ReturnThruPtr_pRenderPass_Val, + cmock_call_instance->ReturnThruPtr_pRenderPass_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateRenderPass2(CMOCK_vkCreateRenderPass2_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); +void CMockExpectParameters_vkCreateRenderPass2(CMOCK_vkCreateRenderPass2_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pRenderPass = pRenderPass; + cmock_call_instance->IgnoreArg_pRenderPass = 0; + cmock_call_instance->ReturnThruPtr_pRenderPass_Used = 0; +} + +void vkCreateRenderPass2_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateRenderPass2_CALL_INSTANCE)); + CMOCK_vkCreateRenderPass2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRenderPass2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateRenderPass2_CallInstance = CMock_Guts_MemChain(Mock.vkCreateRenderPass2_CallInstance, cmock_guts_index); + Mock.vkCreateRenderPass2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateRenderPass2_IgnoreBool = (char)1; +} + +void vkCreateRenderPass2_CMockStopIgnore(void) +{ + if(Mock.vkCreateRenderPass2_IgnoreBool) + Mock.vkCreateRenderPass2_CallInstance = CMock_Guts_MemNext(Mock.vkCreateRenderPass2_CallInstance); + Mock.vkCreateRenderPass2_IgnoreBool = (char)0; +} + +void vkCreateRenderPass2_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateRenderPass2_CALL_INSTANCE)); + CMOCK_vkCreateRenderPass2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRenderPass2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateRenderPass2_CallInstance = CMock_Guts_MemChain(Mock.vkCreateRenderPass2_CallInstance, cmock_guts_index); + Mock.vkCreateRenderPass2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateRenderPass2_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateRenderPass2_CALL_INSTANCE)); + CMOCK_vkCreateRenderPass2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRenderPass2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateRenderPass2_CallInstance = CMock_Guts_MemChain(Mock.vkCreateRenderPass2_CallInstance, cmock_guts_index); + Mock.vkCreateRenderPass2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateRenderPass2(cmock_call_instance, device, pCreateInfo, pAllocator, pRenderPass); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateRenderPass2_AddCallback(CMOCK_vkCreateRenderPass2_CALLBACK Callback) +{ + Mock.vkCreateRenderPass2_IgnoreBool = (char)0; + Mock.vkCreateRenderPass2_CallbackBool = (char)1; + Mock.vkCreateRenderPass2_CallbackFunctionPointer = Callback; +} + +void vkCreateRenderPass2_Stub(CMOCK_vkCreateRenderPass2_CALLBACK Callback) +{ + Mock.vkCreateRenderPass2_IgnoreBool = (char)0; + Mock.vkCreateRenderPass2_CallbackBool = (char)0; + Mock.vkCreateRenderPass2_CallbackFunctionPointer = Callback; +} + +void vkCreateRenderPass2_CMockReturnMemThruPtr_pRenderPass(UNITY_LINE_TYPE cmock_line, VkRenderPass const* pRenderPass, size_t cmock_size) +{ + CMOCK_vkCreateRenderPass2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRenderPass2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateRenderPass2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pRenderPass_Used = 1; + cmock_call_instance->ReturnThruPtr_pRenderPass_Val = pRenderPass; + cmock_call_instance->ReturnThruPtr_pRenderPass_Size = cmock_size; +} + +void vkCreateRenderPass2_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateRenderPass2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRenderPass2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateRenderPass2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateRenderPass2_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateRenderPass2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRenderPass2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateRenderPass2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateRenderPass2_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateRenderPass2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRenderPass2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateRenderPass2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateRenderPass2_CMockIgnoreArg_pRenderPass(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateRenderPass2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRenderPass2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateRenderPass2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pRenderPass = 1; +} + +void vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBeginRenderPass2_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBeginRenderPass2); + cmock_call_instance = (CMOCK_vkCmdBeginRenderPass2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBeginRenderPass2_CallInstance); + Mock.vkCmdBeginRenderPass2_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBeginRenderPass2_CallInstance); + if (Mock.vkCmdBeginRenderPass2_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBeginRenderPass2_CallbackBool && + Mock.vkCmdBeginRenderPass2_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBeginRenderPass2_CallbackFunctionPointer(commandBuffer, pRenderPassBegin, pSubpassBeginInfo, Mock.vkCmdBeginRenderPass2_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginRenderPass2,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pRenderPassBegin) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginRenderPass2,CMockString_pRenderPassBegin); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pRenderPassBegin), (void*)(pRenderPassBegin), sizeof(const VkRenderPassBeginInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSubpassBeginInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginRenderPass2,CMockString_pSubpassBeginInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSubpassBeginInfo), (void*)(pSubpassBeginInfo), sizeof(const VkSubpassBeginInfo), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdBeginRenderPass2_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBeginRenderPass2_CallbackFunctionPointer(commandBuffer, pRenderPassBegin, pSubpassBeginInfo, Mock.vkCmdBeginRenderPass2_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBeginRenderPass2(CMOCK_vkCmdBeginRenderPass2_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo); +void CMockExpectParameters_vkCmdBeginRenderPass2(CMOCK_vkCmdBeginRenderPass2_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pRenderPassBegin = pRenderPassBegin; + cmock_call_instance->IgnoreArg_pRenderPassBegin = 0; + cmock_call_instance->Expected_pSubpassBeginInfo = pSubpassBeginInfo; + cmock_call_instance->IgnoreArg_pSubpassBeginInfo = 0; +} + +void vkCmdBeginRenderPass2_CMockIgnore(void) +{ + Mock.vkCmdBeginRenderPass2_IgnoreBool = (char)1; +} + +void vkCmdBeginRenderPass2_CMockStopIgnore(void) +{ + Mock.vkCmdBeginRenderPass2_IgnoreBool = (char)0; +} + +void vkCmdBeginRenderPass2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBeginRenderPass2_CALL_INSTANCE)); + CMOCK_vkCmdBeginRenderPass2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginRenderPass2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBeginRenderPass2_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBeginRenderPass2_CallInstance, cmock_guts_index); + Mock.vkCmdBeginRenderPass2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBeginRenderPass2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBeginRenderPass2_CALL_INSTANCE)); + CMOCK_vkCmdBeginRenderPass2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginRenderPass2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBeginRenderPass2_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBeginRenderPass2_CallInstance, cmock_guts_index); + Mock.vkCmdBeginRenderPass2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBeginRenderPass2(cmock_call_instance, commandBuffer, pRenderPassBegin, pSubpassBeginInfo); +} + +void vkCmdBeginRenderPass2_AddCallback(CMOCK_vkCmdBeginRenderPass2_CALLBACK Callback) +{ + Mock.vkCmdBeginRenderPass2_IgnoreBool = (char)0; + Mock.vkCmdBeginRenderPass2_CallbackBool = (char)1; + Mock.vkCmdBeginRenderPass2_CallbackFunctionPointer = Callback; +} + +void vkCmdBeginRenderPass2_Stub(CMOCK_vkCmdBeginRenderPass2_CALLBACK Callback) +{ + Mock.vkCmdBeginRenderPass2_IgnoreBool = (char)0; + Mock.vkCmdBeginRenderPass2_CallbackBool = (char)0; + Mock.vkCmdBeginRenderPass2_CallbackFunctionPointer = Callback; +} + +void vkCmdBeginRenderPass2_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginRenderPass2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginRenderPass2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginRenderPass2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBeginRenderPass2_CMockIgnoreArg_pRenderPassBegin(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginRenderPass2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginRenderPass2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginRenderPass2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pRenderPassBegin = 1; +} + +void vkCmdBeginRenderPass2_CMockIgnoreArg_pSubpassBeginInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginRenderPass2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginRenderPass2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginRenderPass2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSubpassBeginInfo = 1; +} + +void vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdNextSubpass2_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdNextSubpass2); + cmock_call_instance = (CMOCK_vkCmdNextSubpass2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdNextSubpass2_CallInstance); + Mock.vkCmdNextSubpass2_CallInstance = CMock_Guts_MemNext(Mock.vkCmdNextSubpass2_CallInstance); + if (Mock.vkCmdNextSubpass2_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdNextSubpass2_CallbackBool && + Mock.vkCmdNextSubpass2_CallbackFunctionPointer != NULL) + { + Mock.vkCmdNextSubpass2_CallbackFunctionPointer(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo, Mock.vkCmdNextSubpass2_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdNextSubpass2,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSubpassBeginInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdNextSubpass2,CMockString_pSubpassBeginInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSubpassBeginInfo), (void*)(pSubpassBeginInfo), sizeof(const VkSubpassBeginInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSubpassEndInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdNextSubpass2,CMockString_pSubpassEndInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSubpassEndInfo), (void*)(pSubpassEndInfo), sizeof(const VkSubpassEndInfo), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdNextSubpass2_CallbackFunctionPointer != NULL) + { + Mock.vkCmdNextSubpass2_CallbackFunctionPointer(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo, Mock.vkCmdNextSubpass2_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdNextSubpass2(CMOCK_vkCmdNextSubpass2_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo); +void CMockExpectParameters_vkCmdNextSubpass2(CMOCK_vkCmdNextSubpass2_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pSubpassBeginInfo = pSubpassBeginInfo; + cmock_call_instance->IgnoreArg_pSubpassBeginInfo = 0; + cmock_call_instance->Expected_pSubpassEndInfo = pSubpassEndInfo; + cmock_call_instance->IgnoreArg_pSubpassEndInfo = 0; +} + +void vkCmdNextSubpass2_CMockIgnore(void) +{ + Mock.vkCmdNextSubpass2_IgnoreBool = (char)1; +} + +void vkCmdNextSubpass2_CMockStopIgnore(void) +{ + Mock.vkCmdNextSubpass2_IgnoreBool = (char)0; +} + +void vkCmdNextSubpass2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdNextSubpass2_CALL_INSTANCE)); + CMOCK_vkCmdNextSubpass2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdNextSubpass2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdNextSubpass2_CallInstance = CMock_Guts_MemChain(Mock.vkCmdNextSubpass2_CallInstance, cmock_guts_index); + Mock.vkCmdNextSubpass2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdNextSubpass2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdNextSubpass2_CALL_INSTANCE)); + CMOCK_vkCmdNextSubpass2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdNextSubpass2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdNextSubpass2_CallInstance = CMock_Guts_MemChain(Mock.vkCmdNextSubpass2_CallInstance, cmock_guts_index); + Mock.vkCmdNextSubpass2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdNextSubpass2(cmock_call_instance, commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); +} + +void vkCmdNextSubpass2_AddCallback(CMOCK_vkCmdNextSubpass2_CALLBACK Callback) +{ + Mock.vkCmdNextSubpass2_IgnoreBool = (char)0; + Mock.vkCmdNextSubpass2_CallbackBool = (char)1; + Mock.vkCmdNextSubpass2_CallbackFunctionPointer = Callback; +} + +void vkCmdNextSubpass2_Stub(CMOCK_vkCmdNextSubpass2_CALLBACK Callback) +{ + Mock.vkCmdNextSubpass2_IgnoreBool = (char)0; + Mock.vkCmdNextSubpass2_CallbackBool = (char)0; + Mock.vkCmdNextSubpass2_CallbackFunctionPointer = Callback; +} + +void vkCmdNextSubpass2_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdNextSubpass2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdNextSubpass2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdNextSubpass2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdNextSubpass2_CMockIgnoreArg_pSubpassBeginInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdNextSubpass2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdNextSubpass2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdNextSubpass2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSubpassBeginInfo = 1; +} + +void vkCmdNextSubpass2_CMockIgnoreArg_pSubpassEndInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdNextSubpass2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdNextSubpass2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdNextSubpass2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSubpassEndInfo = 1; +} + +void vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdEndRenderPass2_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdEndRenderPass2); + cmock_call_instance = (CMOCK_vkCmdEndRenderPass2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdEndRenderPass2_CallInstance); + Mock.vkCmdEndRenderPass2_CallInstance = CMock_Guts_MemNext(Mock.vkCmdEndRenderPass2_CallInstance); + if (Mock.vkCmdEndRenderPass2_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdEndRenderPass2_CallbackBool && + Mock.vkCmdEndRenderPass2_CallbackFunctionPointer != NULL) + { + Mock.vkCmdEndRenderPass2_CallbackFunctionPointer(commandBuffer, pSubpassEndInfo, Mock.vkCmdEndRenderPass2_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdEndRenderPass2,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSubpassEndInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdEndRenderPass2,CMockString_pSubpassEndInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSubpassEndInfo), (void*)(pSubpassEndInfo), sizeof(const VkSubpassEndInfo), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdEndRenderPass2_CallbackFunctionPointer != NULL) + { + Mock.vkCmdEndRenderPass2_CallbackFunctionPointer(commandBuffer, pSubpassEndInfo, Mock.vkCmdEndRenderPass2_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdEndRenderPass2(CMOCK_vkCmdEndRenderPass2_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo); +void CMockExpectParameters_vkCmdEndRenderPass2(CMOCK_vkCmdEndRenderPass2_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pSubpassEndInfo = pSubpassEndInfo; + cmock_call_instance->IgnoreArg_pSubpassEndInfo = 0; +} + +void vkCmdEndRenderPass2_CMockIgnore(void) +{ + Mock.vkCmdEndRenderPass2_IgnoreBool = (char)1; +} + +void vkCmdEndRenderPass2_CMockStopIgnore(void) +{ + Mock.vkCmdEndRenderPass2_IgnoreBool = (char)0; +} + +void vkCmdEndRenderPass2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdEndRenderPass2_CALL_INSTANCE)); + CMOCK_vkCmdEndRenderPass2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndRenderPass2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdEndRenderPass2_CallInstance = CMock_Guts_MemChain(Mock.vkCmdEndRenderPass2_CallInstance, cmock_guts_index); + Mock.vkCmdEndRenderPass2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdEndRenderPass2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdEndRenderPass2_CALL_INSTANCE)); + CMOCK_vkCmdEndRenderPass2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndRenderPass2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdEndRenderPass2_CallInstance = CMock_Guts_MemChain(Mock.vkCmdEndRenderPass2_CallInstance, cmock_guts_index); + Mock.vkCmdEndRenderPass2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdEndRenderPass2(cmock_call_instance, commandBuffer, pSubpassEndInfo); +} + +void vkCmdEndRenderPass2_AddCallback(CMOCK_vkCmdEndRenderPass2_CALLBACK Callback) +{ + Mock.vkCmdEndRenderPass2_IgnoreBool = (char)0; + Mock.vkCmdEndRenderPass2_CallbackBool = (char)1; + Mock.vkCmdEndRenderPass2_CallbackFunctionPointer = Callback; +} + +void vkCmdEndRenderPass2_Stub(CMOCK_vkCmdEndRenderPass2_CALLBACK Callback) +{ + Mock.vkCmdEndRenderPass2_IgnoreBool = (char)0; + Mock.vkCmdEndRenderPass2_CallbackBool = (char)0; + Mock.vkCmdEndRenderPass2_CallbackFunctionPointer = Callback; +} + +void vkCmdEndRenderPass2_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdEndRenderPass2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndRenderPass2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdEndRenderPass2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdEndRenderPass2_CMockIgnoreArg_pSubpassEndInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdEndRenderPass2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndRenderPass2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdEndRenderPass2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSubpassEndInfo = 1; +} + +void vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkResetQueryPool_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkResetQueryPool); + cmock_call_instance = (CMOCK_vkResetQueryPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkResetQueryPool_CallInstance); + Mock.vkResetQueryPool_CallInstance = CMock_Guts_MemNext(Mock.vkResetQueryPool_CallInstance); + if (Mock.vkResetQueryPool_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkResetQueryPool_CallbackBool && + Mock.vkResetQueryPool_CallbackFunctionPointer != NULL) + { + Mock.vkResetQueryPool_CallbackFunctionPointer(device, queryPool, firstQuery, queryCount, Mock.vkResetQueryPool_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkResetQueryPool,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queryPool) + { + UNITY_SET_DETAILS(CMockString_vkResetQueryPool,CMockString_queryPool); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), sizeof(VkQueryPool), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstQuery) + { + UNITY_SET_DETAILS(CMockString_vkResetQueryPool,CMockString_firstQuery); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstQuery, firstQuery, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queryCount) + { + UNITY_SET_DETAILS(CMockString_vkResetQueryPool,CMockString_queryCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_queryCount, queryCount, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkResetQueryPool_CallbackFunctionPointer != NULL) + { + Mock.vkResetQueryPool_CallbackFunctionPointer(device, queryPool, firstQuery, queryCount, Mock.vkResetQueryPool_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkResetQueryPool(CMOCK_vkResetQueryPool_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); +void CMockExpectParameters_vkResetQueryPool(CMOCK_vkResetQueryPool_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), + sizeof(VkQueryPool[sizeof(queryPool) == sizeof(VkQueryPool) ? 1 : -1])); /* add VkQueryPool to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queryPool = 0; + cmock_call_instance->Expected_firstQuery = firstQuery; + cmock_call_instance->IgnoreArg_firstQuery = 0; + cmock_call_instance->Expected_queryCount = queryCount; + cmock_call_instance->IgnoreArg_queryCount = 0; +} + +void vkResetQueryPool_CMockIgnore(void) +{ + Mock.vkResetQueryPool_IgnoreBool = (char)1; +} + +void vkResetQueryPool_CMockStopIgnore(void) +{ + Mock.vkResetQueryPool_IgnoreBool = (char)0; +} + +void vkResetQueryPool_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkResetQueryPool_CALL_INSTANCE)); + CMOCK_vkResetQueryPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetQueryPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkResetQueryPool_CallInstance = CMock_Guts_MemChain(Mock.vkResetQueryPool_CallInstance, cmock_guts_index); + Mock.vkResetQueryPool_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkResetQueryPool_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkResetQueryPool_CALL_INSTANCE)); + CMOCK_vkResetQueryPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetQueryPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkResetQueryPool_CallInstance = CMock_Guts_MemChain(Mock.vkResetQueryPool_CallInstance, cmock_guts_index); + Mock.vkResetQueryPool_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkResetQueryPool(cmock_call_instance, device, queryPool, firstQuery, queryCount); +} + +void vkResetQueryPool_AddCallback(CMOCK_vkResetQueryPool_CALLBACK Callback) +{ + Mock.vkResetQueryPool_IgnoreBool = (char)0; + Mock.vkResetQueryPool_CallbackBool = (char)1; + Mock.vkResetQueryPool_CallbackFunctionPointer = Callback; +} + +void vkResetQueryPool_Stub(CMOCK_vkResetQueryPool_CALLBACK Callback) +{ + Mock.vkResetQueryPool_IgnoreBool = (char)0; + Mock.vkResetQueryPool_CallbackBool = (char)0; + Mock.vkResetQueryPool_CallbackFunctionPointer = Callback; +} + +void vkResetQueryPool_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkResetQueryPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetQueryPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkResetQueryPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkResetQueryPool_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkResetQueryPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetQueryPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkResetQueryPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queryPool = 1; +} + +void vkResetQueryPool_CMockIgnoreArg_firstQuery(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkResetQueryPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetQueryPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkResetQueryPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstQuery = 1; +} + +void vkResetQueryPool_CMockIgnoreArg_queryCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkResetQueryPool_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetQueryPool_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkResetQueryPool_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queryCount = 1; +} + +VkResult vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t* pValue) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetSemaphoreCounterValue_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetSemaphoreCounterValue); + cmock_call_instance = (CMOCK_vkGetSemaphoreCounterValue_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetSemaphoreCounterValue_CallInstance); + Mock.vkGetSemaphoreCounterValue_CallInstance = CMock_Guts_MemNext(Mock.vkGetSemaphoreCounterValue_CallInstance); + if (Mock.vkGetSemaphoreCounterValue_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetSemaphoreCounterValue_FinalReturn; + memcpy((void*)(&Mock.vkGetSemaphoreCounterValue_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetSemaphoreCounterValue_CallbackBool && + Mock.vkGetSemaphoreCounterValue_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetSemaphoreCounterValue_CallbackFunctionPointer(device, semaphore, pValue, Mock.vkGetSemaphoreCounterValue_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetSemaphoreCounterValue,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_semaphore) + { + UNITY_SET_DETAILS(CMockString_vkGetSemaphoreCounterValue,CMockString_semaphore); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_semaphore), (void*)(&semaphore), sizeof(VkSemaphore), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pValue) + { + UNITY_SET_DETAILS(CMockString_vkGetSemaphoreCounterValue,CMockString_pValue); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pValue), (void*)(pValue), sizeof(uint64_t), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetSemaphoreCounterValue_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetSemaphoreCounterValue_CallbackFunctionPointer(device, semaphore, pValue, Mock.vkGetSemaphoreCounterValue_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pValue_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pValue, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pValue, (const void*)cmock_call_instance->ReturnThruPtr_pValue_Val, + cmock_call_instance->ReturnThruPtr_pValue_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetSemaphoreCounterValue(CMOCK_vkGetSemaphoreCounterValue_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSemaphore semaphore, uint64_t* pValue); +void CMockExpectParameters_vkGetSemaphoreCounterValue(CMOCK_vkGetSemaphoreCounterValue_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSemaphore semaphore, uint64_t* pValue) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_semaphore), (void*)(&semaphore), + sizeof(VkSemaphore[sizeof(semaphore) == sizeof(VkSemaphore) ? 1 : -1])); /* add VkSemaphore to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_semaphore = 0; + cmock_call_instance->Expected_pValue = pValue; + cmock_call_instance->IgnoreArg_pValue = 0; + cmock_call_instance->ReturnThruPtr_pValue_Used = 0; +} + +void vkGetSemaphoreCounterValue_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetSemaphoreCounterValue_CALL_INSTANCE)); + CMOCK_vkGetSemaphoreCounterValue_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSemaphoreCounterValue_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetSemaphoreCounterValue_CallInstance = CMock_Guts_MemChain(Mock.vkGetSemaphoreCounterValue_CallInstance, cmock_guts_index); + Mock.vkGetSemaphoreCounterValue_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetSemaphoreCounterValue_IgnoreBool = (char)1; +} + +void vkGetSemaphoreCounterValue_CMockStopIgnore(void) +{ + if(Mock.vkGetSemaphoreCounterValue_IgnoreBool) + Mock.vkGetSemaphoreCounterValue_CallInstance = CMock_Guts_MemNext(Mock.vkGetSemaphoreCounterValue_CallInstance); + Mock.vkGetSemaphoreCounterValue_IgnoreBool = (char)0; +} + +void vkGetSemaphoreCounterValue_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetSemaphoreCounterValue_CALL_INSTANCE)); + CMOCK_vkGetSemaphoreCounterValue_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSemaphoreCounterValue_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetSemaphoreCounterValue_CallInstance = CMock_Guts_MemChain(Mock.vkGetSemaphoreCounterValue_CallInstance, cmock_guts_index); + Mock.vkGetSemaphoreCounterValue_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetSemaphoreCounterValue_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSemaphore semaphore, uint64_t* pValue, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetSemaphoreCounterValue_CALL_INSTANCE)); + CMOCK_vkGetSemaphoreCounterValue_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSemaphoreCounterValue_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetSemaphoreCounterValue_CallInstance = CMock_Guts_MemChain(Mock.vkGetSemaphoreCounterValue_CallInstance, cmock_guts_index); + Mock.vkGetSemaphoreCounterValue_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetSemaphoreCounterValue(cmock_call_instance, device, semaphore, pValue); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetSemaphoreCounterValue_AddCallback(CMOCK_vkGetSemaphoreCounterValue_CALLBACK Callback) +{ + Mock.vkGetSemaphoreCounterValue_IgnoreBool = (char)0; + Mock.vkGetSemaphoreCounterValue_CallbackBool = (char)1; + Mock.vkGetSemaphoreCounterValue_CallbackFunctionPointer = Callback; +} + +void vkGetSemaphoreCounterValue_Stub(CMOCK_vkGetSemaphoreCounterValue_CALLBACK Callback) +{ + Mock.vkGetSemaphoreCounterValue_IgnoreBool = (char)0; + Mock.vkGetSemaphoreCounterValue_CallbackBool = (char)0; + Mock.vkGetSemaphoreCounterValue_CallbackFunctionPointer = Callback; +} + +void vkGetSemaphoreCounterValue_CMockReturnMemThruPtr_pValue(UNITY_LINE_TYPE cmock_line, uint64_t const* pValue, size_t cmock_size) +{ + CMOCK_vkGetSemaphoreCounterValue_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSemaphoreCounterValue_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetSemaphoreCounterValue_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pValue_Used = 1; + cmock_call_instance->ReturnThruPtr_pValue_Val = pValue; + cmock_call_instance->ReturnThruPtr_pValue_Size = cmock_size; +} + +void vkGetSemaphoreCounterValue_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetSemaphoreCounterValue_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSemaphoreCounterValue_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetSemaphoreCounterValue_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetSemaphoreCounterValue_CMockIgnoreArg_semaphore(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetSemaphoreCounterValue_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSemaphoreCounterValue_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetSemaphoreCounterValue_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_semaphore = 1; +} + +void vkGetSemaphoreCounterValue_CMockIgnoreArg_pValue(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetSemaphoreCounterValue_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSemaphoreCounterValue_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetSemaphoreCounterValue_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pValue = 1; +} + +VkResult vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkWaitSemaphores_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkWaitSemaphores); + cmock_call_instance = (CMOCK_vkWaitSemaphores_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkWaitSemaphores_CallInstance); + Mock.vkWaitSemaphores_CallInstance = CMock_Guts_MemNext(Mock.vkWaitSemaphores_CallInstance); + if (Mock.vkWaitSemaphores_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkWaitSemaphores_FinalReturn; + memcpy((void*)(&Mock.vkWaitSemaphores_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkWaitSemaphores_CallbackBool && + Mock.vkWaitSemaphores_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkWaitSemaphores_CallbackFunctionPointer(device, pWaitInfo, timeout, Mock.vkWaitSemaphores_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkWaitSemaphores,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pWaitInfo) + { + UNITY_SET_DETAILS(CMockString_vkWaitSemaphores,CMockString_pWaitInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pWaitInfo), (void*)(pWaitInfo), sizeof(const VkSemaphoreWaitInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_timeout) + { + UNITY_SET_DETAILS(CMockString_vkWaitSemaphores,CMockString_timeout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_timeout), (void*)(&timeout), sizeof(uint64_t), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkWaitSemaphores_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkWaitSemaphores_CallbackFunctionPointer(device, pWaitInfo, timeout, Mock.vkWaitSemaphores_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkWaitSemaphores(CMOCK_vkWaitSemaphores_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout); +void CMockExpectParameters_vkWaitSemaphores(CMOCK_vkWaitSemaphores_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pWaitInfo = pWaitInfo; + cmock_call_instance->IgnoreArg_pWaitInfo = 0; + memcpy((void*)(&cmock_call_instance->Expected_timeout), (void*)(&timeout), + sizeof(uint64_t[sizeof(timeout) == sizeof(uint64_t) ? 1 : -1])); /* add uint64_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_timeout = 0; +} + +void vkWaitSemaphores_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkWaitSemaphores_CALL_INSTANCE)); + CMOCK_vkWaitSemaphores_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWaitSemaphores_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkWaitSemaphores_CallInstance = CMock_Guts_MemChain(Mock.vkWaitSemaphores_CallInstance, cmock_guts_index); + Mock.vkWaitSemaphores_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkWaitSemaphores_IgnoreBool = (char)1; +} + +void vkWaitSemaphores_CMockStopIgnore(void) +{ + if(Mock.vkWaitSemaphores_IgnoreBool) + Mock.vkWaitSemaphores_CallInstance = CMock_Guts_MemNext(Mock.vkWaitSemaphores_CallInstance); + Mock.vkWaitSemaphores_IgnoreBool = (char)0; +} + +void vkWaitSemaphores_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkWaitSemaphores_CALL_INSTANCE)); + CMOCK_vkWaitSemaphores_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWaitSemaphores_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkWaitSemaphores_CallInstance = CMock_Guts_MemChain(Mock.vkWaitSemaphores_CallInstance, cmock_guts_index); + Mock.vkWaitSemaphores_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkWaitSemaphores_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkWaitSemaphores_CALL_INSTANCE)); + CMOCK_vkWaitSemaphores_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWaitSemaphores_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkWaitSemaphores_CallInstance = CMock_Guts_MemChain(Mock.vkWaitSemaphores_CallInstance, cmock_guts_index); + Mock.vkWaitSemaphores_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkWaitSemaphores(cmock_call_instance, device, pWaitInfo, timeout); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkWaitSemaphores_AddCallback(CMOCK_vkWaitSemaphores_CALLBACK Callback) +{ + Mock.vkWaitSemaphores_IgnoreBool = (char)0; + Mock.vkWaitSemaphores_CallbackBool = (char)1; + Mock.vkWaitSemaphores_CallbackFunctionPointer = Callback; +} + +void vkWaitSemaphores_Stub(CMOCK_vkWaitSemaphores_CALLBACK Callback) +{ + Mock.vkWaitSemaphores_IgnoreBool = (char)0; + Mock.vkWaitSemaphores_CallbackBool = (char)0; + Mock.vkWaitSemaphores_CallbackFunctionPointer = Callback; +} + +void vkWaitSemaphores_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkWaitSemaphores_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWaitSemaphores_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWaitSemaphores_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkWaitSemaphores_CMockIgnoreArg_pWaitInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkWaitSemaphores_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWaitSemaphores_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWaitSemaphores_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pWaitInfo = 1; +} + +void vkWaitSemaphores_CMockIgnoreArg_timeout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkWaitSemaphores_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWaitSemaphores_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWaitSemaphores_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_timeout = 1; +} + +VkResult vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkSignalSemaphore_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkSignalSemaphore); + cmock_call_instance = (CMOCK_vkSignalSemaphore_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkSignalSemaphore_CallInstance); + Mock.vkSignalSemaphore_CallInstance = CMock_Guts_MemNext(Mock.vkSignalSemaphore_CallInstance); + if (Mock.vkSignalSemaphore_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkSignalSemaphore_FinalReturn; + memcpy((void*)(&Mock.vkSignalSemaphore_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkSignalSemaphore_CallbackBool && + Mock.vkSignalSemaphore_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkSignalSemaphore_CallbackFunctionPointer(device, pSignalInfo, Mock.vkSignalSemaphore_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkSignalSemaphore,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSignalInfo) + { + UNITY_SET_DETAILS(CMockString_vkSignalSemaphore,CMockString_pSignalInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSignalInfo), (void*)(pSignalInfo), sizeof(const VkSemaphoreSignalInfo), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkSignalSemaphore_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkSignalSemaphore_CallbackFunctionPointer(device, pSignalInfo, Mock.vkSignalSemaphore_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkSignalSemaphore(CMOCK_vkSignalSemaphore_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo); +void CMockExpectParameters_vkSignalSemaphore(CMOCK_vkSignalSemaphore_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pSignalInfo = pSignalInfo; + cmock_call_instance->IgnoreArg_pSignalInfo = 0; +} + +void vkSignalSemaphore_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkSignalSemaphore_CALL_INSTANCE)); + CMOCK_vkSignalSemaphore_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSignalSemaphore_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkSignalSemaphore_CallInstance = CMock_Guts_MemChain(Mock.vkSignalSemaphore_CallInstance, cmock_guts_index); + Mock.vkSignalSemaphore_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkSignalSemaphore_IgnoreBool = (char)1; +} + +void vkSignalSemaphore_CMockStopIgnore(void) +{ + if(Mock.vkSignalSemaphore_IgnoreBool) + Mock.vkSignalSemaphore_CallInstance = CMock_Guts_MemNext(Mock.vkSignalSemaphore_CallInstance); + Mock.vkSignalSemaphore_IgnoreBool = (char)0; +} + +void vkSignalSemaphore_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkSignalSemaphore_CALL_INSTANCE)); + CMOCK_vkSignalSemaphore_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSignalSemaphore_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkSignalSemaphore_CallInstance = CMock_Guts_MemChain(Mock.vkSignalSemaphore_CallInstance, cmock_guts_index); + Mock.vkSignalSemaphore_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkSignalSemaphore_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkSignalSemaphore_CALL_INSTANCE)); + CMOCK_vkSignalSemaphore_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSignalSemaphore_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkSignalSemaphore_CallInstance = CMock_Guts_MemChain(Mock.vkSignalSemaphore_CallInstance, cmock_guts_index); + Mock.vkSignalSemaphore_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkSignalSemaphore(cmock_call_instance, device, pSignalInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkSignalSemaphore_AddCallback(CMOCK_vkSignalSemaphore_CALLBACK Callback) +{ + Mock.vkSignalSemaphore_IgnoreBool = (char)0; + Mock.vkSignalSemaphore_CallbackBool = (char)1; + Mock.vkSignalSemaphore_CallbackFunctionPointer = Callback; +} + +void vkSignalSemaphore_Stub(CMOCK_vkSignalSemaphore_CALLBACK Callback) +{ + Mock.vkSignalSemaphore_IgnoreBool = (char)0; + Mock.vkSignalSemaphore_CallbackBool = (char)0; + Mock.vkSignalSemaphore_CallbackFunctionPointer = Callback; +} + +void vkSignalSemaphore_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSignalSemaphore_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSignalSemaphore_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSignalSemaphore_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkSignalSemaphore_CMockIgnoreArg_pSignalInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSignalSemaphore_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSignalSemaphore_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSignalSemaphore_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSignalInfo = 1; +} + +VkDeviceAddress vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetBufferDeviceAddress_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetBufferDeviceAddress); + cmock_call_instance = (CMOCK_vkGetBufferDeviceAddress_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetBufferDeviceAddress_CallInstance); + Mock.vkGetBufferDeviceAddress_CallInstance = CMock_Guts_MemNext(Mock.vkGetBufferDeviceAddress_CallInstance); + if (Mock.vkGetBufferDeviceAddress_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetBufferDeviceAddress_FinalReturn; + memcpy((void*)(&Mock.vkGetBufferDeviceAddress_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkDeviceAddress[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkDeviceAddress) ? 1 : -1])); /* add VkDeviceAddress to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetBufferDeviceAddress_CallbackBool && + Mock.vkGetBufferDeviceAddress_CallbackFunctionPointer != NULL) + { + VkDeviceAddress cmock_cb_ret = Mock.vkGetBufferDeviceAddress_CallbackFunctionPointer(device, pInfo, Mock.vkGetBufferDeviceAddress_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetBufferDeviceAddress,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetBufferDeviceAddress,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkBufferDeviceAddressInfo), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetBufferDeviceAddress_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetBufferDeviceAddress_CallbackFunctionPointer(device, pInfo, Mock.vkGetBufferDeviceAddress_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetBufferDeviceAddress(CMOCK_vkGetBufferDeviceAddress_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkBufferDeviceAddressInfo* pInfo); +void CMockExpectParameters_vkGetBufferDeviceAddress(CMOCK_vkGetBufferDeviceAddress_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkBufferDeviceAddressInfo* pInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; +} + +void vkGetBufferDeviceAddress_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkDeviceAddress cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetBufferDeviceAddress_CALL_INSTANCE)); + CMOCK_vkGetBufferDeviceAddress_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferDeviceAddress_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetBufferDeviceAddress_CallInstance = CMock_Guts_MemChain(Mock.vkGetBufferDeviceAddress_CallInstance, cmock_guts_index); + Mock.vkGetBufferDeviceAddress_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetBufferDeviceAddress_IgnoreBool = (char)1; +} + +void vkGetBufferDeviceAddress_CMockStopIgnore(void) +{ + if(Mock.vkGetBufferDeviceAddress_IgnoreBool) + Mock.vkGetBufferDeviceAddress_CallInstance = CMock_Guts_MemNext(Mock.vkGetBufferDeviceAddress_CallInstance); + Mock.vkGetBufferDeviceAddress_IgnoreBool = (char)0; +} + +void vkGetBufferDeviceAddress_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkDeviceAddress cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetBufferDeviceAddress_CALL_INSTANCE)); + CMOCK_vkGetBufferDeviceAddress_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferDeviceAddress_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetBufferDeviceAddress_CallInstance = CMock_Guts_MemChain(Mock.vkGetBufferDeviceAddress_CallInstance, cmock_guts_index); + Mock.vkGetBufferDeviceAddress_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetBufferDeviceAddress_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkBufferDeviceAddressInfo* pInfo, VkDeviceAddress cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetBufferDeviceAddress_CALL_INSTANCE)); + CMOCK_vkGetBufferDeviceAddress_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferDeviceAddress_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetBufferDeviceAddress_CallInstance = CMock_Guts_MemChain(Mock.vkGetBufferDeviceAddress_CallInstance, cmock_guts_index); + Mock.vkGetBufferDeviceAddress_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetBufferDeviceAddress(cmock_call_instance, device, pInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkDeviceAddress[sizeof(cmock_to_return) == sizeof(VkDeviceAddress) ? 1 : -1])); /* add VkDeviceAddress to :treat_as_array if this causes an error */ +} + +void vkGetBufferDeviceAddress_AddCallback(CMOCK_vkGetBufferDeviceAddress_CALLBACK Callback) +{ + Mock.vkGetBufferDeviceAddress_IgnoreBool = (char)0; + Mock.vkGetBufferDeviceAddress_CallbackBool = (char)1; + Mock.vkGetBufferDeviceAddress_CallbackFunctionPointer = Callback; +} + +void vkGetBufferDeviceAddress_Stub(CMOCK_vkGetBufferDeviceAddress_CALLBACK Callback) +{ + Mock.vkGetBufferDeviceAddress_IgnoreBool = (char)0; + Mock.vkGetBufferDeviceAddress_CallbackBool = (char)0; + Mock.vkGetBufferDeviceAddress_CallbackFunctionPointer = Callback; +} + +void vkGetBufferDeviceAddress_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetBufferDeviceAddress_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferDeviceAddress_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetBufferDeviceAddress_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetBufferDeviceAddress_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetBufferDeviceAddress_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferDeviceAddress_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetBufferDeviceAddress_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +uint64_t vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetBufferOpaqueCaptureAddress_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetBufferOpaqueCaptureAddress); + cmock_call_instance = (CMOCK_vkGetBufferOpaqueCaptureAddress_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetBufferOpaqueCaptureAddress_CallInstance); + Mock.vkGetBufferOpaqueCaptureAddress_CallInstance = CMock_Guts_MemNext(Mock.vkGetBufferOpaqueCaptureAddress_CallInstance); + if (Mock.vkGetBufferOpaqueCaptureAddress_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetBufferOpaqueCaptureAddress_FinalReturn; + memcpy((void*)(&Mock.vkGetBufferOpaqueCaptureAddress_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(uint64_t[sizeof(cmock_call_instance->ReturnVal) == sizeof(uint64_t) ? 1 : -1])); /* add uint64_t to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetBufferOpaqueCaptureAddress_CallbackBool && + Mock.vkGetBufferOpaqueCaptureAddress_CallbackFunctionPointer != NULL) + { + uint64_t cmock_cb_ret = Mock.vkGetBufferOpaqueCaptureAddress_CallbackFunctionPointer(device, pInfo, Mock.vkGetBufferOpaqueCaptureAddress_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetBufferOpaqueCaptureAddress,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetBufferOpaqueCaptureAddress,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkBufferDeviceAddressInfo), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetBufferOpaqueCaptureAddress_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetBufferOpaqueCaptureAddress_CallbackFunctionPointer(device, pInfo, Mock.vkGetBufferOpaqueCaptureAddress_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetBufferOpaqueCaptureAddress(CMOCK_vkGetBufferOpaqueCaptureAddress_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkBufferDeviceAddressInfo* pInfo); +void CMockExpectParameters_vkGetBufferOpaqueCaptureAddress(CMOCK_vkGetBufferOpaqueCaptureAddress_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkBufferDeviceAddressInfo* pInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; +} + +void vkGetBufferOpaqueCaptureAddress_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, uint64_t cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetBufferOpaqueCaptureAddress_CALL_INSTANCE)); + CMOCK_vkGetBufferOpaqueCaptureAddress_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferOpaqueCaptureAddress_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetBufferOpaqueCaptureAddress_CallInstance = CMock_Guts_MemChain(Mock.vkGetBufferOpaqueCaptureAddress_CallInstance, cmock_guts_index); + Mock.vkGetBufferOpaqueCaptureAddress_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetBufferOpaqueCaptureAddress_IgnoreBool = (char)1; +} + +void vkGetBufferOpaqueCaptureAddress_CMockStopIgnore(void) +{ + if(Mock.vkGetBufferOpaqueCaptureAddress_IgnoreBool) + Mock.vkGetBufferOpaqueCaptureAddress_CallInstance = CMock_Guts_MemNext(Mock.vkGetBufferOpaqueCaptureAddress_CallInstance); + Mock.vkGetBufferOpaqueCaptureAddress_IgnoreBool = (char)0; +} + +void vkGetBufferOpaqueCaptureAddress_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, uint64_t cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetBufferOpaqueCaptureAddress_CALL_INSTANCE)); + CMOCK_vkGetBufferOpaqueCaptureAddress_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferOpaqueCaptureAddress_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetBufferOpaqueCaptureAddress_CallInstance = CMock_Guts_MemChain(Mock.vkGetBufferOpaqueCaptureAddress_CallInstance, cmock_guts_index); + Mock.vkGetBufferOpaqueCaptureAddress_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetBufferOpaqueCaptureAddress_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkBufferDeviceAddressInfo* pInfo, uint64_t cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetBufferOpaqueCaptureAddress_CALL_INSTANCE)); + CMOCK_vkGetBufferOpaqueCaptureAddress_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferOpaqueCaptureAddress_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetBufferOpaqueCaptureAddress_CallInstance = CMock_Guts_MemChain(Mock.vkGetBufferOpaqueCaptureAddress_CallInstance, cmock_guts_index); + Mock.vkGetBufferOpaqueCaptureAddress_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetBufferOpaqueCaptureAddress(cmock_call_instance, device, pInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(uint64_t[sizeof(cmock_to_return) == sizeof(uint64_t) ? 1 : -1])); /* add uint64_t to :treat_as_array if this causes an error */ +} + +void vkGetBufferOpaqueCaptureAddress_AddCallback(CMOCK_vkGetBufferOpaqueCaptureAddress_CALLBACK Callback) +{ + Mock.vkGetBufferOpaqueCaptureAddress_IgnoreBool = (char)0; + Mock.vkGetBufferOpaqueCaptureAddress_CallbackBool = (char)1; + Mock.vkGetBufferOpaqueCaptureAddress_CallbackFunctionPointer = Callback; +} + +void vkGetBufferOpaqueCaptureAddress_Stub(CMOCK_vkGetBufferOpaqueCaptureAddress_CALLBACK Callback) +{ + Mock.vkGetBufferOpaqueCaptureAddress_IgnoreBool = (char)0; + Mock.vkGetBufferOpaqueCaptureAddress_CallbackBool = (char)0; + Mock.vkGetBufferOpaqueCaptureAddress_CallbackFunctionPointer = Callback; +} + +void vkGetBufferOpaqueCaptureAddress_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetBufferOpaqueCaptureAddress_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferOpaqueCaptureAddress_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetBufferOpaqueCaptureAddress_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetBufferOpaqueCaptureAddress_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetBufferOpaqueCaptureAddress_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferOpaqueCaptureAddress_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetBufferOpaqueCaptureAddress_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +uint64_t vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDeviceMemoryOpaqueCaptureAddress_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDeviceMemoryOpaqueCaptureAddress); + cmock_call_instance = (CMOCK_vkGetDeviceMemoryOpaqueCaptureAddress_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDeviceMemoryOpaqueCaptureAddress_CallInstance); + Mock.vkGetDeviceMemoryOpaqueCaptureAddress_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeviceMemoryOpaqueCaptureAddress_CallInstance); + if (Mock.vkGetDeviceMemoryOpaqueCaptureAddress_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetDeviceMemoryOpaqueCaptureAddress_FinalReturn; + memcpy((void*)(&Mock.vkGetDeviceMemoryOpaqueCaptureAddress_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(uint64_t[sizeof(cmock_call_instance->ReturnVal) == sizeof(uint64_t) ? 1 : -1])); /* add uint64_t to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetDeviceMemoryOpaqueCaptureAddress_CallbackBool && + Mock.vkGetDeviceMemoryOpaqueCaptureAddress_CallbackFunctionPointer != NULL) + { + uint64_t cmock_cb_ret = Mock.vkGetDeviceMemoryOpaqueCaptureAddress_CallbackFunctionPointer(device, pInfo, Mock.vkGetDeviceMemoryOpaqueCaptureAddress_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceMemoryOpaqueCaptureAddress,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceMemoryOpaqueCaptureAddress,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkDeviceMemoryOpaqueCaptureAddressInfo), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDeviceMemoryOpaqueCaptureAddress_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetDeviceMemoryOpaqueCaptureAddress_CallbackFunctionPointer(device, pInfo, Mock.vkGetDeviceMemoryOpaqueCaptureAddress_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetDeviceMemoryOpaqueCaptureAddress(CMOCK_vkGetDeviceMemoryOpaqueCaptureAddress_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); +void CMockExpectParameters_vkGetDeviceMemoryOpaqueCaptureAddress(CMOCK_vkGetDeviceMemoryOpaqueCaptureAddress_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; +} + +void vkGetDeviceMemoryOpaqueCaptureAddress_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, uint64_t cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceMemoryOpaqueCaptureAddress_CALL_INSTANCE)); + CMOCK_vkGetDeviceMemoryOpaqueCaptureAddress_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceMemoryOpaqueCaptureAddress_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceMemoryOpaqueCaptureAddress_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceMemoryOpaqueCaptureAddress_CallInstance, cmock_guts_index); + Mock.vkGetDeviceMemoryOpaqueCaptureAddress_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetDeviceMemoryOpaqueCaptureAddress_IgnoreBool = (char)1; +} + +void vkGetDeviceMemoryOpaqueCaptureAddress_CMockStopIgnore(void) +{ + if(Mock.vkGetDeviceMemoryOpaqueCaptureAddress_IgnoreBool) + Mock.vkGetDeviceMemoryOpaqueCaptureAddress_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeviceMemoryOpaqueCaptureAddress_CallInstance); + Mock.vkGetDeviceMemoryOpaqueCaptureAddress_IgnoreBool = (char)0; +} + +void vkGetDeviceMemoryOpaqueCaptureAddress_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, uint64_t cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceMemoryOpaqueCaptureAddress_CALL_INSTANCE)); + CMOCK_vkGetDeviceMemoryOpaqueCaptureAddress_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceMemoryOpaqueCaptureAddress_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceMemoryOpaqueCaptureAddress_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceMemoryOpaqueCaptureAddress_CallInstance, cmock_guts_index); + Mock.vkGetDeviceMemoryOpaqueCaptureAddress_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDeviceMemoryOpaqueCaptureAddress_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo, uint64_t cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceMemoryOpaqueCaptureAddress_CALL_INSTANCE)); + CMOCK_vkGetDeviceMemoryOpaqueCaptureAddress_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceMemoryOpaqueCaptureAddress_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceMemoryOpaqueCaptureAddress_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceMemoryOpaqueCaptureAddress_CallInstance, cmock_guts_index); + Mock.vkGetDeviceMemoryOpaqueCaptureAddress_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDeviceMemoryOpaqueCaptureAddress(cmock_call_instance, device, pInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(uint64_t[sizeof(cmock_to_return) == sizeof(uint64_t) ? 1 : -1])); /* add uint64_t to :treat_as_array if this causes an error */ +} + +void vkGetDeviceMemoryOpaqueCaptureAddress_AddCallback(CMOCK_vkGetDeviceMemoryOpaqueCaptureAddress_CALLBACK Callback) +{ + Mock.vkGetDeviceMemoryOpaqueCaptureAddress_IgnoreBool = (char)0; + Mock.vkGetDeviceMemoryOpaqueCaptureAddress_CallbackBool = (char)1; + Mock.vkGetDeviceMemoryOpaqueCaptureAddress_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceMemoryOpaqueCaptureAddress_Stub(CMOCK_vkGetDeviceMemoryOpaqueCaptureAddress_CALLBACK Callback) +{ + Mock.vkGetDeviceMemoryOpaqueCaptureAddress_IgnoreBool = (char)0; + Mock.vkGetDeviceMemoryOpaqueCaptureAddress_CallbackBool = (char)0; + Mock.vkGetDeviceMemoryOpaqueCaptureAddress_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceMemoryOpaqueCaptureAddress_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceMemoryOpaqueCaptureAddress_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceMemoryOpaqueCaptureAddress_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceMemoryOpaqueCaptureAddress_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetDeviceMemoryOpaqueCaptureAddress_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceMemoryOpaqueCaptureAddress_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceMemoryOpaqueCaptureAddress_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceMemoryOpaqueCaptureAddress_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +VkResult vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceToolProperties_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceToolProperties); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceToolProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceToolProperties_CallInstance); + Mock.vkGetPhysicalDeviceToolProperties_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceToolProperties_CallInstance); + if (Mock.vkGetPhysicalDeviceToolProperties_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPhysicalDeviceToolProperties_FinalReturn; + memcpy((void*)(&Mock.vkGetPhysicalDeviceToolProperties_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPhysicalDeviceToolProperties_CallbackBool && + Mock.vkGetPhysicalDeviceToolProperties_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPhysicalDeviceToolProperties_CallbackFunctionPointer(physicalDevice, pToolCount, pToolProperties, Mock.vkGetPhysicalDeviceToolProperties_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceToolProperties,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pToolCount) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceToolProperties,CMockString_pToolCount); + if (cmock_call_instance->Expected_pToolCount == NULL) + { UNITY_TEST_ASSERT_NULL(pToolCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pToolCount, pToolCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pToolProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceToolProperties,CMockString_pToolProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pToolProperties), (void*)(pToolProperties), sizeof(VkPhysicalDeviceToolProperties), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceToolProperties_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPhysicalDeviceToolProperties_CallbackFunctionPointer(physicalDevice, pToolCount, pToolProperties, Mock.vkGetPhysicalDeviceToolProperties_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pToolCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pToolCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pToolCount, (const void*)cmock_call_instance->ReturnThruPtr_pToolCount_Val, + cmock_call_instance->ReturnThruPtr_pToolCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pToolProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pToolProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pToolProperties, (const void*)cmock_call_instance->ReturnThruPtr_pToolProperties_Val, + cmock_call_instance->ReturnThruPtr_pToolProperties_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPhysicalDeviceToolProperties(CMOCK_vkGetPhysicalDeviceToolProperties_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties); +void CMockExpectParameters_vkGetPhysicalDeviceToolProperties(CMOCK_vkGetPhysicalDeviceToolProperties_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pToolCount = pToolCount; + cmock_call_instance->IgnoreArg_pToolCount = 0; + cmock_call_instance->ReturnThruPtr_pToolCount_Used = 0; + cmock_call_instance->Expected_pToolProperties = pToolProperties; + cmock_call_instance->IgnoreArg_pToolProperties = 0; + cmock_call_instance->ReturnThruPtr_pToolProperties_Used = 0; +} + +void vkGetPhysicalDeviceToolProperties_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceToolProperties_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceToolProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceToolProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceToolProperties_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceToolProperties_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceToolProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPhysicalDeviceToolProperties_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceToolProperties_CMockStopIgnore(void) +{ + if(Mock.vkGetPhysicalDeviceToolProperties_IgnoreBool) + Mock.vkGetPhysicalDeviceToolProperties_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceToolProperties_CallInstance); + Mock.vkGetPhysicalDeviceToolProperties_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceToolProperties_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceToolProperties_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceToolProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceToolProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceToolProperties_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceToolProperties_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceToolProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceToolProperties_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceToolProperties_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceToolProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceToolProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceToolProperties_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceToolProperties_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceToolProperties_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceToolProperties(cmock_call_instance, physicalDevice, pToolCount, pToolProperties); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPhysicalDeviceToolProperties_AddCallback(CMOCK_vkGetPhysicalDeviceToolProperties_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceToolProperties_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceToolProperties_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceToolProperties_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceToolProperties_Stub(CMOCK_vkGetPhysicalDeviceToolProperties_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceToolProperties_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceToolProperties_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceToolProperties_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceToolProperties_CMockReturnMemThruPtr_pToolCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pToolCount, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceToolProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceToolProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceToolProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pToolCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pToolCount_Val = pToolCount; + cmock_call_instance->ReturnThruPtr_pToolCount_Size = cmock_size; +} + +void vkGetPhysicalDeviceToolProperties_CMockReturnMemThruPtr_pToolProperties(UNITY_LINE_TYPE cmock_line, VkPhysicalDeviceToolProperties const* pToolProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceToolProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceToolProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceToolProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pToolProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pToolProperties_Val = pToolProperties; + cmock_call_instance->ReturnThruPtr_pToolProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceToolProperties_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceToolProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceToolProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceToolProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceToolProperties_CMockIgnoreArg_pToolCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceToolProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceToolProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceToolProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pToolCount = 1; +} + +void vkGetPhysicalDeviceToolProperties_CMockIgnoreArg_pToolProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceToolProperties_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceToolProperties_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceToolProperties_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pToolProperties = 1; +} + +VkResult vkCreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreatePrivateDataSlot_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreatePrivateDataSlot); + cmock_call_instance = (CMOCK_vkCreatePrivateDataSlot_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreatePrivateDataSlot_CallInstance); + Mock.vkCreatePrivateDataSlot_CallInstance = CMock_Guts_MemNext(Mock.vkCreatePrivateDataSlot_CallInstance); + if (Mock.vkCreatePrivateDataSlot_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreatePrivateDataSlot_FinalReturn; + memcpy((void*)(&Mock.vkCreatePrivateDataSlot_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreatePrivateDataSlot_CallbackBool && + Mock.vkCreatePrivateDataSlot_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreatePrivateDataSlot_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pPrivateDataSlot, Mock.vkCreatePrivateDataSlot_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreatePrivateDataSlot,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreatePrivateDataSlot,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkPrivateDataSlotCreateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreatePrivateDataSlot,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPrivateDataSlot) + { + UNITY_SET_DETAILS(CMockString_vkCreatePrivateDataSlot,CMockString_pPrivateDataSlot); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pPrivateDataSlot), (void*)(pPrivateDataSlot), sizeof(VkPrivateDataSlot), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreatePrivateDataSlot_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreatePrivateDataSlot_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pPrivateDataSlot, Mock.vkCreatePrivateDataSlot_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPrivateDataSlot_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPrivateDataSlot, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPrivateDataSlot, (const void*)cmock_call_instance->ReturnThruPtr_pPrivateDataSlot_Val, + cmock_call_instance->ReturnThruPtr_pPrivateDataSlot_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreatePrivateDataSlot(CMOCK_vkCreatePrivateDataSlot_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot); +void CMockExpectParameters_vkCreatePrivateDataSlot(CMOCK_vkCreatePrivateDataSlot_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pPrivateDataSlot = pPrivateDataSlot; + cmock_call_instance->IgnoreArg_pPrivateDataSlot = 0; + cmock_call_instance->ReturnThruPtr_pPrivateDataSlot_Used = 0; +} + +void vkCreatePrivateDataSlot_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreatePrivateDataSlot_CALL_INSTANCE)); + CMOCK_vkCreatePrivateDataSlot_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePrivateDataSlot_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreatePrivateDataSlot_CallInstance = CMock_Guts_MemChain(Mock.vkCreatePrivateDataSlot_CallInstance, cmock_guts_index); + Mock.vkCreatePrivateDataSlot_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreatePrivateDataSlot_IgnoreBool = (char)1; +} + +void vkCreatePrivateDataSlot_CMockStopIgnore(void) +{ + if(Mock.vkCreatePrivateDataSlot_IgnoreBool) + Mock.vkCreatePrivateDataSlot_CallInstance = CMock_Guts_MemNext(Mock.vkCreatePrivateDataSlot_CallInstance); + Mock.vkCreatePrivateDataSlot_IgnoreBool = (char)0; +} + +void vkCreatePrivateDataSlot_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreatePrivateDataSlot_CALL_INSTANCE)); + CMOCK_vkCreatePrivateDataSlot_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePrivateDataSlot_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreatePrivateDataSlot_CallInstance = CMock_Guts_MemChain(Mock.vkCreatePrivateDataSlot_CallInstance, cmock_guts_index); + Mock.vkCreatePrivateDataSlot_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreatePrivateDataSlot_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreatePrivateDataSlot_CALL_INSTANCE)); + CMOCK_vkCreatePrivateDataSlot_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePrivateDataSlot_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreatePrivateDataSlot_CallInstance = CMock_Guts_MemChain(Mock.vkCreatePrivateDataSlot_CallInstance, cmock_guts_index); + Mock.vkCreatePrivateDataSlot_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreatePrivateDataSlot(cmock_call_instance, device, pCreateInfo, pAllocator, pPrivateDataSlot); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreatePrivateDataSlot_AddCallback(CMOCK_vkCreatePrivateDataSlot_CALLBACK Callback) +{ + Mock.vkCreatePrivateDataSlot_IgnoreBool = (char)0; + Mock.vkCreatePrivateDataSlot_CallbackBool = (char)1; + Mock.vkCreatePrivateDataSlot_CallbackFunctionPointer = Callback; +} + +void vkCreatePrivateDataSlot_Stub(CMOCK_vkCreatePrivateDataSlot_CALLBACK Callback) +{ + Mock.vkCreatePrivateDataSlot_IgnoreBool = (char)0; + Mock.vkCreatePrivateDataSlot_CallbackBool = (char)0; + Mock.vkCreatePrivateDataSlot_CallbackFunctionPointer = Callback; +} + +void vkCreatePrivateDataSlot_CMockReturnMemThruPtr_pPrivateDataSlot(UNITY_LINE_TYPE cmock_line, VkPrivateDataSlot const* pPrivateDataSlot, size_t cmock_size) +{ + CMOCK_vkCreatePrivateDataSlot_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePrivateDataSlot_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreatePrivateDataSlot_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPrivateDataSlot_Used = 1; + cmock_call_instance->ReturnThruPtr_pPrivateDataSlot_Val = pPrivateDataSlot; + cmock_call_instance->ReturnThruPtr_pPrivateDataSlot_Size = cmock_size; +} + +void vkCreatePrivateDataSlot_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreatePrivateDataSlot_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePrivateDataSlot_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreatePrivateDataSlot_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreatePrivateDataSlot_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreatePrivateDataSlot_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePrivateDataSlot_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreatePrivateDataSlot_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreatePrivateDataSlot_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreatePrivateDataSlot_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePrivateDataSlot_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreatePrivateDataSlot_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreatePrivateDataSlot_CMockIgnoreArg_pPrivateDataSlot(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreatePrivateDataSlot_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePrivateDataSlot_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreatePrivateDataSlot_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPrivateDataSlot = 1; +} + +void vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyPrivateDataSlot_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyPrivateDataSlot); + cmock_call_instance = (CMOCK_vkDestroyPrivateDataSlot_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyPrivateDataSlot_CallInstance); + Mock.vkDestroyPrivateDataSlot_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyPrivateDataSlot_CallInstance); + if (Mock.vkDestroyPrivateDataSlot_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyPrivateDataSlot_CallbackBool && + Mock.vkDestroyPrivateDataSlot_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyPrivateDataSlot_CallbackFunctionPointer(device, privateDataSlot, pAllocator, Mock.vkDestroyPrivateDataSlot_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyPrivateDataSlot,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_privateDataSlot) + { + UNITY_SET_DETAILS(CMockString_vkDestroyPrivateDataSlot,CMockString_privateDataSlot); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_privateDataSlot), (void*)(&privateDataSlot), sizeof(VkPrivateDataSlot), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyPrivateDataSlot,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyPrivateDataSlot_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyPrivateDataSlot_CallbackFunctionPointer(device, privateDataSlot, pAllocator, Mock.vkDestroyPrivateDataSlot_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyPrivateDataSlot(CMOCK_vkDestroyPrivateDataSlot_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyPrivateDataSlot(CMOCK_vkDestroyPrivateDataSlot_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_privateDataSlot), (void*)(&privateDataSlot), + sizeof(VkPrivateDataSlot[sizeof(privateDataSlot) == sizeof(VkPrivateDataSlot) ? 1 : -1])); /* add VkPrivateDataSlot to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_privateDataSlot = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyPrivateDataSlot_CMockIgnore(void) +{ + Mock.vkDestroyPrivateDataSlot_IgnoreBool = (char)1; +} + +void vkDestroyPrivateDataSlot_CMockStopIgnore(void) +{ + Mock.vkDestroyPrivateDataSlot_IgnoreBool = (char)0; +} + +void vkDestroyPrivateDataSlot_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyPrivateDataSlot_CALL_INSTANCE)); + CMOCK_vkDestroyPrivateDataSlot_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyPrivateDataSlot_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyPrivateDataSlot_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyPrivateDataSlot_CallInstance, cmock_guts_index); + Mock.vkDestroyPrivateDataSlot_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyPrivateDataSlot_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyPrivateDataSlot_CALL_INSTANCE)); + CMOCK_vkDestroyPrivateDataSlot_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyPrivateDataSlot_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyPrivateDataSlot_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyPrivateDataSlot_CallInstance, cmock_guts_index); + Mock.vkDestroyPrivateDataSlot_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyPrivateDataSlot(cmock_call_instance, device, privateDataSlot, pAllocator); +} + +void vkDestroyPrivateDataSlot_AddCallback(CMOCK_vkDestroyPrivateDataSlot_CALLBACK Callback) +{ + Mock.vkDestroyPrivateDataSlot_IgnoreBool = (char)0; + Mock.vkDestroyPrivateDataSlot_CallbackBool = (char)1; + Mock.vkDestroyPrivateDataSlot_CallbackFunctionPointer = Callback; +} + +void vkDestroyPrivateDataSlot_Stub(CMOCK_vkDestroyPrivateDataSlot_CALLBACK Callback) +{ + Mock.vkDestroyPrivateDataSlot_IgnoreBool = (char)0; + Mock.vkDestroyPrivateDataSlot_CallbackBool = (char)0; + Mock.vkDestroyPrivateDataSlot_CallbackFunctionPointer = Callback; +} + +void vkDestroyPrivateDataSlot_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyPrivateDataSlot_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyPrivateDataSlot_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyPrivateDataSlot_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyPrivateDataSlot_CMockIgnoreArg_privateDataSlot(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyPrivateDataSlot_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyPrivateDataSlot_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyPrivateDataSlot_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_privateDataSlot = 1; +} + +void vkDestroyPrivateDataSlot_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyPrivateDataSlot_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyPrivateDataSlot_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyPrivateDataSlot_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +VkResult vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkSetPrivateData_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkSetPrivateData); + cmock_call_instance = (CMOCK_vkSetPrivateData_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkSetPrivateData_CallInstance); + Mock.vkSetPrivateData_CallInstance = CMock_Guts_MemNext(Mock.vkSetPrivateData_CallInstance); + if (Mock.vkSetPrivateData_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkSetPrivateData_FinalReturn; + memcpy((void*)(&Mock.vkSetPrivateData_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkSetPrivateData_CallbackBool && + Mock.vkSetPrivateData_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkSetPrivateData_CallbackFunctionPointer(device, objectType, objectHandle, privateDataSlot, data, Mock.vkSetPrivateData_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkSetPrivateData,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_objectType) + { + UNITY_SET_DETAILS(CMockString_vkSetPrivateData,CMockString_objectType); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_objectType), (void*)(&objectType), sizeof(VkObjectType), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_objectHandle) + { + UNITY_SET_DETAILS(CMockString_vkSetPrivateData,CMockString_objectHandle); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_objectHandle), (void*)(&objectHandle), sizeof(uint64_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_privateDataSlot) + { + UNITY_SET_DETAILS(CMockString_vkSetPrivateData,CMockString_privateDataSlot); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_privateDataSlot), (void*)(&privateDataSlot), sizeof(VkPrivateDataSlot), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_data) + { + UNITY_SET_DETAILS(CMockString_vkSetPrivateData,CMockString_data); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_data), (void*)(&data), sizeof(uint64_t), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkSetPrivateData_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkSetPrivateData_CallbackFunctionPointer(device, objectType, objectHandle, privateDataSlot, data, Mock.vkSetPrivateData_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkSetPrivateData(CMOCK_vkSetPrivateData_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data); +void CMockExpectParameters_vkSetPrivateData(CMOCK_vkSetPrivateData_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_objectType), (void*)(&objectType), + sizeof(VkObjectType[sizeof(objectType) == sizeof(VkObjectType) ? 1 : -1])); /* add VkObjectType to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_objectType = 0; + memcpy((void*)(&cmock_call_instance->Expected_objectHandle), (void*)(&objectHandle), + sizeof(uint64_t[sizeof(objectHandle) == sizeof(uint64_t) ? 1 : -1])); /* add uint64_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_objectHandle = 0; + memcpy((void*)(&cmock_call_instance->Expected_privateDataSlot), (void*)(&privateDataSlot), + sizeof(VkPrivateDataSlot[sizeof(privateDataSlot) == sizeof(VkPrivateDataSlot) ? 1 : -1])); /* add VkPrivateDataSlot to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_privateDataSlot = 0; + memcpy((void*)(&cmock_call_instance->Expected_data), (void*)(&data), + sizeof(uint64_t[sizeof(data) == sizeof(uint64_t) ? 1 : -1])); /* add uint64_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_data = 0; +} + +void vkSetPrivateData_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkSetPrivateData_CALL_INSTANCE)); + CMOCK_vkSetPrivateData_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetPrivateData_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkSetPrivateData_CallInstance = CMock_Guts_MemChain(Mock.vkSetPrivateData_CallInstance, cmock_guts_index); + Mock.vkSetPrivateData_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkSetPrivateData_IgnoreBool = (char)1; +} + +void vkSetPrivateData_CMockStopIgnore(void) +{ + if(Mock.vkSetPrivateData_IgnoreBool) + Mock.vkSetPrivateData_CallInstance = CMock_Guts_MemNext(Mock.vkSetPrivateData_CallInstance); + Mock.vkSetPrivateData_IgnoreBool = (char)0; +} + +void vkSetPrivateData_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkSetPrivateData_CALL_INSTANCE)); + CMOCK_vkSetPrivateData_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetPrivateData_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkSetPrivateData_CallInstance = CMock_Guts_MemChain(Mock.vkSetPrivateData_CallInstance, cmock_guts_index); + Mock.vkSetPrivateData_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkSetPrivateData_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkSetPrivateData_CALL_INSTANCE)); + CMOCK_vkSetPrivateData_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetPrivateData_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkSetPrivateData_CallInstance = CMock_Guts_MemChain(Mock.vkSetPrivateData_CallInstance, cmock_guts_index); + Mock.vkSetPrivateData_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkSetPrivateData(cmock_call_instance, device, objectType, objectHandle, privateDataSlot, data); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkSetPrivateData_AddCallback(CMOCK_vkSetPrivateData_CALLBACK Callback) +{ + Mock.vkSetPrivateData_IgnoreBool = (char)0; + Mock.vkSetPrivateData_CallbackBool = (char)1; + Mock.vkSetPrivateData_CallbackFunctionPointer = Callback; +} + +void vkSetPrivateData_Stub(CMOCK_vkSetPrivateData_CALLBACK Callback) +{ + Mock.vkSetPrivateData_IgnoreBool = (char)0; + Mock.vkSetPrivateData_CallbackBool = (char)0; + Mock.vkSetPrivateData_CallbackFunctionPointer = Callback; +} + +void vkSetPrivateData_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSetPrivateData_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetPrivateData_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSetPrivateData_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkSetPrivateData_CMockIgnoreArg_objectType(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSetPrivateData_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetPrivateData_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSetPrivateData_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_objectType = 1; +} + +void vkSetPrivateData_CMockIgnoreArg_objectHandle(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSetPrivateData_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetPrivateData_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSetPrivateData_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_objectHandle = 1; +} + +void vkSetPrivateData_CMockIgnoreArg_privateDataSlot(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSetPrivateData_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetPrivateData_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSetPrivateData_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_privateDataSlot = 1; +} + +void vkSetPrivateData_CMockIgnoreArg_data(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSetPrivateData_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetPrivateData_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSetPrivateData_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_data = 1; +} + +void vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPrivateData_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPrivateData); + cmock_call_instance = (CMOCK_vkGetPrivateData_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPrivateData_CallInstance); + Mock.vkGetPrivateData_CallInstance = CMock_Guts_MemNext(Mock.vkGetPrivateData_CallInstance); + if (Mock.vkGetPrivateData_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetPrivateData_CallbackBool && + Mock.vkGetPrivateData_CallbackFunctionPointer != NULL) + { + Mock.vkGetPrivateData_CallbackFunctionPointer(device, objectType, objectHandle, privateDataSlot, pData, Mock.vkGetPrivateData_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetPrivateData,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_objectType) + { + UNITY_SET_DETAILS(CMockString_vkGetPrivateData,CMockString_objectType); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_objectType), (void*)(&objectType), sizeof(VkObjectType), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_objectHandle) + { + UNITY_SET_DETAILS(CMockString_vkGetPrivateData,CMockString_objectHandle); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_objectHandle), (void*)(&objectHandle), sizeof(uint64_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_privateDataSlot) + { + UNITY_SET_DETAILS(CMockString_vkGetPrivateData,CMockString_privateDataSlot); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_privateDataSlot), (void*)(&privateDataSlot), sizeof(VkPrivateDataSlot), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pData) + { + UNITY_SET_DETAILS(CMockString_vkGetPrivateData,CMockString_pData); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pData), (void*)(pData), sizeof(uint64_t), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPrivateData_CallbackFunctionPointer != NULL) + { + Mock.vkGetPrivateData_CallbackFunctionPointer(device, objectType, objectHandle, privateDataSlot, pData, Mock.vkGetPrivateData_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pData_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pData, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pData, (const void*)cmock_call_instance->ReturnThruPtr_pData_Val, + cmock_call_instance->ReturnThruPtr_pData_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetPrivateData(CMOCK_vkGetPrivateData_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData); +void CMockExpectParameters_vkGetPrivateData(CMOCK_vkGetPrivateData_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_objectType), (void*)(&objectType), + sizeof(VkObjectType[sizeof(objectType) == sizeof(VkObjectType) ? 1 : -1])); /* add VkObjectType to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_objectType = 0; + memcpy((void*)(&cmock_call_instance->Expected_objectHandle), (void*)(&objectHandle), + sizeof(uint64_t[sizeof(objectHandle) == sizeof(uint64_t) ? 1 : -1])); /* add uint64_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_objectHandle = 0; + memcpy((void*)(&cmock_call_instance->Expected_privateDataSlot), (void*)(&privateDataSlot), + sizeof(VkPrivateDataSlot[sizeof(privateDataSlot) == sizeof(VkPrivateDataSlot) ? 1 : -1])); /* add VkPrivateDataSlot to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_privateDataSlot = 0; + cmock_call_instance->Expected_pData = pData; + cmock_call_instance->IgnoreArg_pData = 0; + cmock_call_instance->ReturnThruPtr_pData_Used = 0; +} + +void vkGetPrivateData_CMockIgnore(void) +{ + Mock.vkGetPrivateData_IgnoreBool = (char)1; +} + +void vkGetPrivateData_CMockStopIgnore(void) +{ + Mock.vkGetPrivateData_IgnoreBool = (char)0; +} + +void vkGetPrivateData_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPrivateData_CALL_INSTANCE)); + CMOCK_vkGetPrivateData_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPrivateData_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPrivateData_CallInstance = CMock_Guts_MemChain(Mock.vkGetPrivateData_CallInstance, cmock_guts_index); + Mock.vkGetPrivateData_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPrivateData_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPrivateData_CALL_INSTANCE)); + CMOCK_vkGetPrivateData_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPrivateData_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPrivateData_CallInstance = CMock_Guts_MemChain(Mock.vkGetPrivateData_CallInstance, cmock_guts_index); + Mock.vkGetPrivateData_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPrivateData(cmock_call_instance, device, objectType, objectHandle, privateDataSlot, pData); +} + +void vkGetPrivateData_AddCallback(CMOCK_vkGetPrivateData_CALLBACK Callback) +{ + Mock.vkGetPrivateData_IgnoreBool = (char)0; + Mock.vkGetPrivateData_CallbackBool = (char)1; + Mock.vkGetPrivateData_CallbackFunctionPointer = Callback; +} + +void vkGetPrivateData_Stub(CMOCK_vkGetPrivateData_CALLBACK Callback) +{ + Mock.vkGetPrivateData_IgnoreBool = (char)0; + Mock.vkGetPrivateData_CallbackBool = (char)0; + Mock.vkGetPrivateData_CallbackFunctionPointer = Callback; +} + +void vkGetPrivateData_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, uint64_t const* pData, size_t cmock_size) +{ + CMOCK_vkGetPrivateData_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPrivateData_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPrivateData_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pData_Used = 1; + cmock_call_instance->ReturnThruPtr_pData_Val = pData; + cmock_call_instance->ReturnThruPtr_pData_Size = cmock_size; +} + +void vkGetPrivateData_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPrivateData_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPrivateData_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPrivateData_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetPrivateData_CMockIgnoreArg_objectType(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPrivateData_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPrivateData_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPrivateData_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_objectType = 1; +} + +void vkGetPrivateData_CMockIgnoreArg_objectHandle(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPrivateData_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPrivateData_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPrivateData_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_objectHandle = 1; +} + +void vkGetPrivateData_CMockIgnoreArg_privateDataSlot(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPrivateData_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPrivateData_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPrivateData_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_privateDataSlot = 1; +} + +void vkGetPrivateData_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPrivateData_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPrivateData_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPrivateData_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pData = 1; +} + +void vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetEvent2_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetEvent2); + cmock_call_instance = (CMOCK_vkCmdSetEvent2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetEvent2_CallInstance); + Mock.vkCmdSetEvent2_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetEvent2_CallInstance); + if (Mock.vkCmdSetEvent2_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetEvent2_CallbackBool && + Mock.vkCmdSetEvent2_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetEvent2_CallbackFunctionPointer(commandBuffer, event, pDependencyInfo, Mock.vkCmdSetEvent2_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetEvent2,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_event) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetEvent2,CMockString_event); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_event), (void*)(&event), sizeof(VkEvent), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDependencyInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetEvent2,CMockString_pDependencyInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDependencyInfo), (void*)(pDependencyInfo), sizeof(const VkDependencyInfo), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetEvent2_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetEvent2_CallbackFunctionPointer(commandBuffer, event, pDependencyInfo, Mock.vkCmdSetEvent2_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetEvent2(CMOCK_vkCmdSetEvent2_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo); +void CMockExpectParameters_vkCmdSetEvent2(CMOCK_vkCmdSetEvent2_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_event), (void*)(&event), + sizeof(VkEvent[sizeof(event) == sizeof(VkEvent) ? 1 : -1])); /* add VkEvent to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_event = 0; + cmock_call_instance->Expected_pDependencyInfo = pDependencyInfo; + cmock_call_instance->IgnoreArg_pDependencyInfo = 0; +} + +void vkCmdSetEvent2_CMockIgnore(void) +{ + Mock.vkCmdSetEvent2_IgnoreBool = (char)1; +} + +void vkCmdSetEvent2_CMockStopIgnore(void) +{ + Mock.vkCmdSetEvent2_IgnoreBool = (char)0; +} + +void vkCmdSetEvent2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetEvent2_CALL_INSTANCE)); + CMOCK_vkCmdSetEvent2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetEvent2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetEvent2_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetEvent2_CallInstance, cmock_guts_index); + Mock.vkCmdSetEvent2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetEvent2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetEvent2_CALL_INSTANCE)); + CMOCK_vkCmdSetEvent2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetEvent2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetEvent2_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetEvent2_CallInstance, cmock_guts_index); + Mock.vkCmdSetEvent2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetEvent2(cmock_call_instance, commandBuffer, event, pDependencyInfo); +} + +void vkCmdSetEvent2_AddCallback(CMOCK_vkCmdSetEvent2_CALLBACK Callback) +{ + Mock.vkCmdSetEvent2_IgnoreBool = (char)0; + Mock.vkCmdSetEvent2_CallbackBool = (char)1; + Mock.vkCmdSetEvent2_CallbackFunctionPointer = Callback; +} + +void vkCmdSetEvent2_Stub(CMOCK_vkCmdSetEvent2_CALLBACK Callback) +{ + Mock.vkCmdSetEvent2_IgnoreBool = (char)0; + Mock.vkCmdSetEvent2_CallbackBool = (char)0; + Mock.vkCmdSetEvent2_CallbackFunctionPointer = Callback; +} + +void vkCmdSetEvent2_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetEvent2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetEvent2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetEvent2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetEvent2_CMockIgnoreArg_event(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetEvent2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetEvent2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetEvent2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_event = 1; +} + +void vkCmdSetEvent2_CMockIgnoreArg_pDependencyInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetEvent2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetEvent2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetEvent2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDependencyInfo = 1; +} + +void vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdResetEvent2_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdResetEvent2); + cmock_call_instance = (CMOCK_vkCmdResetEvent2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdResetEvent2_CallInstance); + Mock.vkCmdResetEvent2_CallInstance = CMock_Guts_MemNext(Mock.vkCmdResetEvent2_CallInstance); + if (Mock.vkCmdResetEvent2_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdResetEvent2_CallbackBool && + Mock.vkCmdResetEvent2_CallbackFunctionPointer != NULL) + { + Mock.vkCmdResetEvent2_CallbackFunctionPointer(commandBuffer, event, stageMask, Mock.vkCmdResetEvent2_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdResetEvent2,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_event) + { + UNITY_SET_DETAILS(CMockString_vkCmdResetEvent2,CMockString_event); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_event), (void*)(&event), sizeof(VkEvent), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_stageMask) + { + UNITY_SET_DETAILS(CMockString_vkCmdResetEvent2,CMockString_stageMask); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_stageMask), (void*)(&stageMask), sizeof(VkPipelineStageFlags2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdResetEvent2_CallbackFunctionPointer != NULL) + { + Mock.vkCmdResetEvent2_CallbackFunctionPointer(commandBuffer, event, stageMask, Mock.vkCmdResetEvent2_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdResetEvent2(CMOCK_vkCmdResetEvent2_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask); +void CMockExpectParameters_vkCmdResetEvent2(CMOCK_vkCmdResetEvent2_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_event), (void*)(&event), + sizeof(VkEvent[sizeof(event) == sizeof(VkEvent) ? 1 : -1])); /* add VkEvent to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_event = 0; + memcpy((void*)(&cmock_call_instance->Expected_stageMask), (void*)(&stageMask), + sizeof(VkPipelineStageFlags2[sizeof(stageMask) == sizeof(VkPipelineStageFlags2) ? 1 : -1])); /* add VkPipelineStageFlags2 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_stageMask = 0; +} + +void vkCmdResetEvent2_CMockIgnore(void) +{ + Mock.vkCmdResetEvent2_IgnoreBool = (char)1; +} + +void vkCmdResetEvent2_CMockStopIgnore(void) +{ + Mock.vkCmdResetEvent2_IgnoreBool = (char)0; +} + +void vkCmdResetEvent2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdResetEvent2_CALL_INSTANCE)); + CMOCK_vkCmdResetEvent2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResetEvent2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdResetEvent2_CallInstance = CMock_Guts_MemChain(Mock.vkCmdResetEvent2_CallInstance, cmock_guts_index); + Mock.vkCmdResetEvent2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdResetEvent2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdResetEvent2_CALL_INSTANCE)); + CMOCK_vkCmdResetEvent2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResetEvent2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdResetEvent2_CallInstance = CMock_Guts_MemChain(Mock.vkCmdResetEvent2_CallInstance, cmock_guts_index); + Mock.vkCmdResetEvent2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdResetEvent2(cmock_call_instance, commandBuffer, event, stageMask); +} + +void vkCmdResetEvent2_AddCallback(CMOCK_vkCmdResetEvent2_CALLBACK Callback) +{ + Mock.vkCmdResetEvent2_IgnoreBool = (char)0; + Mock.vkCmdResetEvent2_CallbackBool = (char)1; + Mock.vkCmdResetEvent2_CallbackFunctionPointer = Callback; +} + +void vkCmdResetEvent2_Stub(CMOCK_vkCmdResetEvent2_CALLBACK Callback) +{ + Mock.vkCmdResetEvent2_IgnoreBool = (char)0; + Mock.vkCmdResetEvent2_CallbackBool = (char)0; + Mock.vkCmdResetEvent2_CallbackFunctionPointer = Callback; +} + +void vkCmdResetEvent2_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdResetEvent2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResetEvent2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdResetEvent2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdResetEvent2_CMockIgnoreArg_event(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdResetEvent2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResetEvent2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdResetEvent2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_event = 1; +} + +void vkCmdResetEvent2_CMockIgnoreArg_stageMask(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdResetEvent2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResetEvent2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdResetEvent2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stageMask = 1; +} + +void vkCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdWaitEvents2_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdWaitEvents2); + cmock_call_instance = (CMOCK_vkCmdWaitEvents2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdWaitEvents2_CallInstance); + Mock.vkCmdWaitEvents2_CallInstance = CMock_Guts_MemNext(Mock.vkCmdWaitEvents2_CallInstance); + if (Mock.vkCmdWaitEvents2_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdWaitEvents2_CallbackBool && + Mock.vkCmdWaitEvents2_CallbackFunctionPointer != NULL) + { + Mock.vkCmdWaitEvents2_CallbackFunctionPointer(commandBuffer, eventCount, pEvents, pDependencyInfos, Mock.vkCmdWaitEvents2_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdWaitEvents2,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_eventCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdWaitEvents2,CMockString_eventCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_eventCount, eventCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pEvents) + { + UNITY_SET_DETAILS(CMockString_vkCmdWaitEvents2,CMockString_pEvents); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pEvents), (void*)(pEvents), sizeof(const VkEvent), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDependencyInfos) + { + UNITY_SET_DETAILS(CMockString_vkCmdWaitEvents2,CMockString_pDependencyInfos); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDependencyInfos), (void*)(pDependencyInfos), sizeof(const VkDependencyInfo), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdWaitEvents2_CallbackFunctionPointer != NULL) + { + Mock.vkCmdWaitEvents2_CallbackFunctionPointer(commandBuffer, eventCount, pEvents, pDependencyInfos, Mock.vkCmdWaitEvents2_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdWaitEvents2(CMOCK_vkCmdWaitEvents2_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos); +void CMockExpectParameters_vkCmdWaitEvents2(CMOCK_vkCmdWaitEvents2_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_eventCount = eventCount; + cmock_call_instance->IgnoreArg_eventCount = 0; + cmock_call_instance->Expected_pEvents = pEvents; + cmock_call_instance->IgnoreArg_pEvents = 0; + cmock_call_instance->Expected_pDependencyInfos = pDependencyInfos; + cmock_call_instance->IgnoreArg_pDependencyInfos = 0; +} + +void vkCmdWaitEvents2_CMockIgnore(void) +{ + Mock.vkCmdWaitEvents2_IgnoreBool = (char)1; +} + +void vkCmdWaitEvents2_CMockStopIgnore(void) +{ + Mock.vkCmdWaitEvents2_IgnoreBool = (char)0; +} + +void vkCmdWaitEvents2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdWaitEvents2_CALL_INSTANCE)); + CMOCK_vkCmdWaitEvents2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWaitEvents2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdWaitEvents2_CallInstance = CMock_Guts_MemChain(Mock.vkCmdWaitEvents2_CallInstance, cmock_guts_index); + Mock.vkCmdWaitEvents2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdWaitEvents2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdWaitEvents2_CALL_INSTANCE)); + CMOCK_vkCmdWaitEvents2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWaitEvents2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdWaitEvents2_CallInstance = CMock_Guts_MemChain(Mock.vkCmdWaitEvents2_CallInstance, cmock_guts_index); + Mock.vkCmdWaitEvents2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdWaitEvents2(cmock_call_instance, commandBuffer, eventCount, pEvents, pDependencyInfos); +} + +void vkCmdWaitEvents2_AddCallback(CMOCK_vkCmdWaitEvents2_CALLBACK Callback) +{ + Mock.vkCmdWaitEvents2_IgnoreBool = (char)0; + Mock.vkCmdWaitEvents2_CallbackBool = (char)1; + Mock.vkCmdWaitEvents2_CallbackFunctionPointer = Callback; +} + +void vkCmdWaitEvents2_Stub(CMOCK_vkCmdWaitEvents2_CALLBACK Callback) +{ + Mock.vkCmdWaitEvents2_IgnoreBool = (char)0; + Mock.vkCmdWaitEvents2_CallbackBool = (char)0; + Mock.vkCmdWaitEvents2_CallbackFunctionPointer = Callback; +} + +void vkCmdWaitEvents2_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWaitEvents2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWaitEvents2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWaitEvents2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdWaitEvents2_CMockIgnoreArg_eventCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWaitEvents2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWaitEvents2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWaitEvents2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_eventCount = 1; +} + +void vkCmdWaitEvents2_CMockIgnoreArg_pEvents(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWaitEvents2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWaitEvents2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWaitEvents2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pEvents = 1; +} + +void vkCmdWaitEvents2_CMockIgnoreArg_pDependencyInfos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWaitEvents2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWaitEvents2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWaitEvents2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDependencyInfos = 1; +} + +void vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdPipelineBarrier2_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdPipelineBarrier2); + cmock_call_instance = (CMOCK_vkCmdPipelineBarrier2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdPipelineBarrier2_CallInstance); + Mock.vkCmdPipelineBarrier2_CallInstance = CMock_Guts_MemNext(Mock.vkCmdPipelineBarrier2_CallInstance); + if (Mock.vkCmdPipelineBarrier2_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdPipelineBarrier2_CallbackBool && + Mock.vkCmdPipelineBarrier2_CallbackFunctionPointer != NULL) + { + Mock.vkCmdPipelineBarrier2_CallbackFunctionPointer(commandBuffer, pDependencyInfo, Mock.vkCmdPipelineBarrier2_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdPipelineBarrier2,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDependencyInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdPipelineBarrier2,CMockString_pDependencyInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDependencyInfo), (void*)(pDependencyInfo), sizeof(const VkDependencyInfo), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdPipelineBarrier2_CallbackFunctionPointer != NULL) + { + Mock.vkCmdPipelineBarrier2_CallbackFunctionPointer(commandBuffer, pDependencyInfo, Mock.vkCmdPipelineBarrier2_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdPipelineBarrier2(CMOCK_vkCmdPipelineBarrier2_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo); +void CMockExpectParameters_vkCmdPipelineBarrier2(CMOCK_vkCmdPipelineBarrier2_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pDependencyInfo = pDependencyInfo; + cmock_call_instance->IgnoreArg_pDependencyInfo = 0; +} + +void vkCmdPipelineBarrier2_CMockIgnore(void) +{ + Mock.vkCmdPipelineBarrier2_IgnoreBool = (char)1; +} + +void vkCmdPipelineBarrier2_CMockStopIgnore(void) +{ + Mock.vkCmdPipelineBarrier2_IgnoreBool = (char)0; +} + +void vkCmdPipelineBarrier2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdPipelineBarrier2_CALL_INSTANCE)); + CMOCK_vkCmdPipelineBarrier2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPipelineBarrier2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdPipelineBarrier2_CallInstance = CMock_Guts_MemChain(Mock.vkCmdPipelineBarrier2_CallInstance, cmock_guts_index); + Mock.vkCmdPipelineBarrier2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdPipelineBarrier2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdPipelineBarrier2_CALL_INSTANCE)); + CMOCK_vkCmdPipelineBarrier2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPipelineBarrier2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdPipelineBarrier2_CallInstance = CMock_Guts_MemChain(Mock.vkCmdPipelineBarrier2_CallInstance, cmock_guts_index); + Mock.vkCmdPipelineBarrier2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdPipelineBarrier2(cmock_call_instance, commandBuffer, pDependencyInfo); +} + +void vkCmdPipelineBarrier2_AddCallback(CMOCK_vkCmdPipelineBarrier2_CALLBACK Callback) +{ + Mock.vkCmdPipelineBarrier2_IgnoreBool = (char)0; + Mock.vkCmdPipelineBarrier2_CallbackBool = (char)1; + Mock.vkCmdPipelineBarrier2_CallbackFunctionPointer = Callback; +} + +void vkCmdPipelineBarrier2_Stub(CMOCK_vkCmdPipelineBarrier2_CALLBACK Callback) +{ + Mock.vkCmdPipelineBarrier2_IgnoreBool = (char)0; + Mock.vkCmdPipelineBarrier2_CallbackBool = (char)0; + Mock.vkCmdPipelineBarrier2_CallbackFunctionPointer = Callback; +} + +void vkCmdPipelineBarrier2_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPipelineBarrier2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPipelineBarrier2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPipelineBarrier2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdPipelineBarrier2_CMockIgnoreArg_pDependencyInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPipelineBarrier2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPipelineBarrier2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPipelineBarrier2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDependencyInfo = 1; +} + +void vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdWriteTimestamp2_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdWriteTimestamp2); + cmock_call_instance = (CMOCK_vkCmdWriteTimestamp2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdWriteTimestamp2_CallInstance); + Mock.vkCmdWriteTimestamp2_CallInstance = CMock_Guts_MemNext(Mock.vkCmdWriteTimestamp2_CallInstance); + if (Mock.vkCmdWriteTimestamp2_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdWriteTimestamp2_CallbackBool && + Mock.vkCmdWriteTimestamp2_CallbackFunctionPointer != NULL) + { + Mock.vkCmdWriteTimestamp2_CallbackFunctionPointer(commandBuffer, stage, queryPool, query, Mock.vkCmdWriteTimestamp2_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteTimestamp2,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_stage) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteTimestamp2,CMockString_stage); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_stage), (void*)(&stage), sizeof(VkPipelineStageFlags2), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queryPool) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteTimestamp2,CMockString_queryPool); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), sizeof(VkQueryPool), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_query) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteTimestamp2,CMockString_query); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_query, query, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdWriteTimestamp2_CallbackFunctionPointer != NULL) + { + Mock.vkCmdWriteTimestamp2_CallbackFunctionPointer(commandBuffer, stage, queryPool, query, Mock.vkCmdWriteTimestamp2_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdWriteTimestamp2(CMOCK_vkCmdWriteTimestamp2_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query); +void CMockExpectParameters_vkCmdWriteTimestamp2(CMOCK_vkCmdWriteTimestamp2_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_stage), (void*)(&stage), + sizeof(VkPipelineStageFlags2[sizeof(stage) == sizeof(VkPipelineStageFlags2) ? 1 : -1])); /* add VkPipelineStageFlags2 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_stage = 0; + memcpy((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), + sizeof(VkQueryPool[sizeof(queryPool) == sizeof(VkQueryPool) ? 1 : -1])); /* add VkQueryPool to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queryPool = 0; + cmock_call_instance->Expected_query = query; + cmock_call_instance->IgnoreArg_query = 0; +} + +void vkCmdWriteTimestamp2_CMockIgnore(void) +{ + Mock.vkCmdWriteTimestamp2_IgnoreBool = (char)1; +} + +void vkCmdWriteTimestamp2_CMockStopIgnore(void) +{ + Mock.vkCmdWriteTimestamp2_IgnoreBool = (char)0; +} + +void vkCmdWriteTimestamp2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdWriteTimestamp2_CALL_INSTANCE)); + CMOCK_vkCmdWriteTimestamp2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteTimestamp2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdWriteTimestamp2_CallInstance = CMock_Guts_MemChain(Mock.vkCmdWriteTimestamp2_CallInstance, cmock_guts_index); + Mock.vkCmdWriteTimestamp2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdWriteTimestamp2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdWriteTimestamp2_CALL_INSTANCE)); + CMOCK_vkCmdWriteTimestamp2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteTimestamp2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdWriteTimestamp2_CallInstance = CMock_Guts_MemChain(Mock.vkCmdWriteTimestamp2_CallInstance, cmock_guts_index); + Mock.vkCmdWriteTimestamp2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdWriteTimestamp2(cmock_call_instance, commandBuffer, stage, queryPool, query); +} + +void vkCmdWriteTimestamp2_AddCallback(CMOCK_vkCmdWriteTimestamp2_CALLBACK Callback) +{ + Mock.vkCmdWriteTimestamp2_IgnoreBool = (char)0; + Mock.vkCmdWriteTimestamp2_CallbackBool = (char)1; + Mock.vkCmdWriteTimestamp2_CallbackFunctionPointer = Callback; +} + +void vkCmdWriteTimestamp2_Stub(CMOCK_vkCmdWriteTimestamp2_CALLBACK Callback) +{ + Mock.vkCmdWriteTimestamp2_IgnoreBool = (char)0; + Mock.vkCmdWriteTimestamp2_CallbackBool = (char)0; + Mock.vkCmdWriteTimestamp2_CallbackFunctionPointer = Callback; +} + +void vkCmdWriteTimestamp2_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteTimestamp2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteTimestamp2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteTimestamp2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdWriteTimestamp2_CMockIgnoreArg_stage(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteTimestamp2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteTimestamp2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteTimestamp2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stage = 1; +} + +void vkCmdWriteTimestamp2_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteTimestamp2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteTimestamp2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteTimestamp2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queryPool = 1; +} + +void vkCmdWriteTimestamp2_CMockIgnoreArg_query(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteTimestamp2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteTimestamp2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteTimestamp2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_query = 1; +} + +VkResult vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkQueueSubmit2_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkQueueSubmit2); + cmock_call_instance = (CMOCK_vkQueueSubmit2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkQueueSubmit2_CallInstance); + Mock.vkQueueSubmit2_CallInstance = CMock_Guts_MemNext(Mock.vkQueueSubmit2_CallInstance); + if (Mock.vkQueueSubmit2_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkQueueSubmit2_FinalReturn; + memcpy((void*)(&Mock.vkQueueSubmit2_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkQueueSubmit2_CallbackBool && + Mock.vkQueueSubmit2_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkQueueSubmit2_CallbackFunctionPointer(queue, submitCount, pSubmits, fence, Mock.vkQueueSubmit2_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_queue) + { + UNITY_SET_DETAILS(CMockString_vkQueueSubmit2,CMockString_queue); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queue), (void*)(&queue), sizeof(VkQueue), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_submitCount) + { + UNITY_SET_DETAILS(CMockString_vkQueueSubmit2,CMockString_submitCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_submitCount, submitCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSubmits) + { + UNITY_SET_DETAILS(CMockString_vkQueueSubmit2,CMockString_pSubmits); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSubmits), (void*)(pSubmits), sizeof(const VkSubmitInfo2), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_fence) + { + UNITY_SET_DETAILS(CMockString_vkQueueSubmit2,CMockString_fence); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_fence), (void*)(&fence), sizeof(VkFence), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkQueueSubmit2_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkQueueSubmit2_CallbackFunctionPointer(queue, submitCount, pSubmits, fence, Mock.vkQueueSubmit2_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkQueueSubmit2(CMOCK_vkQueueSubmit2_CALL_INSTANCE* cmock_call_instance, VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence); +void CMockExpectParameters_vkQueueSubmit2(CMOCK_vkQueueSubmit2_CALL_INSTANCE* cmock_call_instance, VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) +{ + memcpy((void*)(&cmock_call_instance->Expected_queue), (void*)(&queue), + sizeof(VkQueue[sizeof(queue) == sizeof(VkQueue) ? 1 : -1])); /* add VkQueue to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queue = 0; + cmock_call_instance->Expected_submitCount = submitCount; + cmock_call_instance->IgnoreArg_submitCount = 0; + cmock_call_instance->Expected_pSubmits = pSubmits; + cmock_call_instance->IgnoreArg_pSubmits = 0; + memcpy((void*)(&cmock_call_instance->Expected_fence), (void*)(&fence), + sizeof(VkFence[sizeof(fence) == sizeof(VkFence) ? 1 : -1])); /* add VkFence to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_fence = 0; +} + +void vkQueueSubmit2_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkQueueSubmit2_CALL_INSTANCE)); + CMOCK_vkQueueSubmit2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueSubmit2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkQueueSubmit2_CallInstance = CMock_Guts_MemChain(Mock.vkQueueSubmit2_CallInstance, cmock_guts_index); + Mock.vkQueueSubmit2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkQueueSubmit2_IgnoreBool = (char)1; +} + +void vkQueueSubmit2_CMockStopIgnore(void) +{ + if(Mock.vkQueueSubmit2_IgnoreBool) + Mock.vkQueueSubmit2_CallInstance = CMock_Guts_MemNext(Mock.vkQueueSubmit2_CallInstance); + Mock.vkQueueSubmit2_IgnoreBool = (char)0; +} + +void vkQueueSubmit2_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkQueueSubmit2_CALL_INSTANCE)); + CMOCK_vkQueueSubmit2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueSubmit2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkQueueSubmit2_CallInstance = CMock_Guts_MemChain(Mock.vkQueueSubmit2_CallInstance, cmock_guts_index); + Mock.vkQueueSubmit2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkQueueSubmit2_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkQueueSubmit2_CALL_INSTANCE)); + CMOCK_vkQueueSubmit2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueSubmit2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkQueueSubmit2_CallInstance = CMock_Guts_MemChain(Mock.vkQueueSubmit2_CallInstance, cmock_guts_index); + Mock.vkQueueSubmit2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkQueueSubmit2(cmock_call_instance, queue, submitCount, pSubmits, fence); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkQueueSubmit2_AddCallback(CMOCK_vkQueueSubmit2_CALLBACK Callback) +{ + Mock.vkQueueSubmit2_IgnoreBool = (char)0; + Mock.vkQueueSubmit2_CallbackBool = (char)1; + Mock.vkQueueSubmit2_CallbackFunctionPointer = Callback; +} + +void vkQueueSubmit2_Stub(CMOCK_vkQueueSubmit2_CALLBACK Callback) +{ + Mock.vkQueueSubmit2_IgnoreBool = (char)0; + Mock.vkQueueSubmit2_CallbackBool = (char)0; + Mock.vkQueueSubmit2_CallbackFunctionPointer = Callback; +} + +void vkQueueSubmit2_CMockIgnoreArg_queue(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkQueueSubmit2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueSubmit2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkQueueSubmit2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queue = 1; +} + +void vkQueueSubmit2_CMockIgnoreArg_submitCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkQueueSubmit2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueSubmit2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkQueueSubmit2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_submitCount = 1; +} + +void vkQueueSubmit2_CMockIgnoreArg_pSubmits(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkQueueSubmit2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueSubmit2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkQueueSubmit2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSubmits = 1; +} + +void vkQueueSubmit2_CMockIgnoreArg_fence(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkQueueSubmit2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueSubmit2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkQueueSubmit2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_fence = 1; +} + +void vkCmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdCopyBuffer2_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdCopyBuffer2); + cmock_call_instance = (CMOCK_vkCmdCopyBuffer2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdCopyBuffer2_CallInstance); + Mock.vkCmdCopyBuffer2_CallInstance = CMock_Guts_MemNext(Mock.vkCmdCopyBuffer2_CallInstance); + if (Mock.vkCmdCopyBuffer2_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdCopyBuffer2_CallbackBool && + Mock.vkCmdCopyBuffer2_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyBuffer2_CallbackFunctionPointer(commandBuffer, pCopyBufferInfo, Mock.vkCmdCopyBuffer2_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyBuffer2,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCopyBufferInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyBuffer2,CMockString_pCopyBufferInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCopyBufferInfo), (void*)(pCopyBufferInfo), sizeof(const VkCopyBufferInfo2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdCopyBuffer2_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyBuffer2_CallbackFunctionPointer(commandBuffer, pCopyBufferInfo, Mock.vkCmdCopyBuffer2_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdCopyBuffer2(CMOCK_vkCmdCopyBuffer2_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo); +void CMockExpectParameters_vkCmdCopyBuffer2(CMOCK_vkCmdCopyBuffer2_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pCopyBufferInfo = pCopyBufferInfo; + cmock_call_instance->IgnoreArg_pCopyBufferInfo = 0; +} + +void vkCmdCopyBuffer2_CMockIgnore(void) +{ + Mock.vkCmdCopyBuffer2_IgnoreBool = (char)1; +} + +void vkCmdCopyBuffer2_CMockStopIgnore(void) +{ + Mock.vkCmdCopyBuffer2_IgnoreBool = (char)0; +} + +void vkCmdCopyBuffer2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyBuffer2_CALL_INSTANCE)); + CMOCK_vkCmdCopyBuffer2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBuffer2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyBuffer2_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyBuffer2_CallInstance, cmock_guts_index); + Mock.vkCmdCopyBuffer2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdCopyBuffer2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyBuffer2_CALL_INSTANCE)); + CMOCK_vkCmdCopyBuffer2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBuffer2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyBuffer2_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyBuffer2_CallInstance, cmock_guts_index); + Mock.vkCmdCopyBuffer2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdCopyBuffer2(cmock_call_instance, commandBuffer, pCopyBufferInfo); +} + +void vkCmdCopyBuffer2_AddCallback(CMOCK_vkCmdCopyBuffer2_CALLBACK Callback) +{ + Mock.vkCmdCopyBuffer2_IgnoreBool = (char)0; + Mock.vkCmdCopyBuffer2_CallbackBool = (char)1; + Mock.vkCmdCopyBuffer2_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyBuffer2_Stub(CMOCK_vkCmdCopyBuffer2_CALLBACK Callback) +{ + Mock.vkCmdCopyBuffer2_IgnoreBool = (char)0; + Mock.vkCmdCopyBuffer2_CallbackBool = (char)0; + Mock.vkCmdCopyBuffer2_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyBuffer2_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyBuffer2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBuffer2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyBuffer2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdCopyBuffer2_CMockIgnoreArg_pCopyBufferInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyBuffer2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBuffer2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyBuffer2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCopyBufferInfo = 1; +} + +void vkCmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdCopyImage2_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdCopyImage2); + cmock_call_instance = (CMOCK_vkCmdCopyImage2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdCopyImage2_CallInstance); + Mock.vkCmdCopyImage2_CallInstance = CMock_Guts_MemNext(Mock.vkCmdCopyImage2_CallInstance); + if (Mock.vkCmdCopyImage2_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdCopyImage2_CallbackBool && + Mock.vkCmdCopyImage2_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyImage2_CallbackFunctionPointer(commandBuffer, pCopyImageInfo, Mock.vkCmdCopyImage2_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyImage2,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCopyImageInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyImage2,CMockString_pCopyImageInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCopyImageInfo), (void*)(pCopyImageInfo), sizeof(const VkCopyImageInfo2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdCopyImage2_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyImage2_CallbackFunctionPointer(commandBuffer, pCopyImageInfo, Mock.vkCmdCopyImage2_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdCopyImage2(CMOCK_vkCmdCopyImage2_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo); +void CMockExpectParameters_vkCmdCopyImage2(CMOCK_vkCmdCopyImage2_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pCopyImageInfo = pCopyImageInfo; + cmock_call_instance->IgnoreArg_pCopyImageInfo = 0; +} + +void vkCmdCopyImage2_CMockIgnore(void) +{ + Mock.vkCmdCopyImage2_IgnoreBool = (char)1; +} + +void vkCmdCopyImage2_CMockStopIgnore(void) +{ + Mock.vkCmdCopyImage2_IgnoreBool = (char)0; +} + +void vkCmdCopyImage2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyImage2_CALL_INSTANCE)); + CMOCK_vkCmdCopyImage2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImage2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyImage2_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyImage2_CallInstance, cmock_guts_index); + Mock.vkCmdCopyImage2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdCopyImage2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyImage2_CALL_INSTANCE)); + CMOCK_vkCmdCopyImage2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImage2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyImage2_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyImage2_CallInstance, cmock_guts_index); + Mock.vkCmdCopyImage2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdCopyImage2(cmock_call_instance, commandBuffer, pCopyImageInfo); +} + +void vkCmdCopyImage2_AddCallback(CMOCK_vkCmdCopyImage2_CALLBACK Callback) +{ + Mock.vkCmdCopyImage2_IgnoreBool = (char)0; + Mock.vkCmdCopyImage2_CallbackBool = (char)1; + Mock.vkCmdCopyImage2_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyImage2_Stub(CMOCK_vkCmdCopyImage2_CALLBACK Callback) +{ + Mock.vkCmdCopyImage2_IgnoreBool = (char)0; + Mock.vkCmdCopyImage2_CallbackBool = (char)0; + Mock.vkCmdCopyImage2_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyImage2_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyImage2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImage2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyImage2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdCopyImage2_CMockIgnoreArg_pCopyImageInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyImage2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImage2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyImage2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCopyImageInfo = 1; +} + +void vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdCopyBufferToImage2_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdCopyBufferToImage2); + cmock_call_instance = (CMOCK_vkCmdCopyBufferToImage2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdCopyBufferToImage2_CallInstance); + Mock.vkCmdCopyBufferToImage2_CallInstance = CMock_Guts_MemNext(Mock.vkCmdCopyBufferToImage2_CallInstance); + if (Mock.vkCmdCopyBufferToImage2_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdCopyBufferToImage2_CallbackBool && + Mock.vkCmdCopyBufferToImage2_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyBufferToImage2_CallbackFunctionPointer(commandBuffer, pCopyBufferToImageInfo, Mock.vkCmdCopyBufferToImage2_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyBufferToImage2,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCopyBufferToImageInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyBufferToImage2,CMockString_pCopyBufferToImageInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCopyBufferToImageInfo), (void*)(pCopyBufferToImageInfo), sizeof(const VkCopyBufferToImageInfo2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdCopyBufferToImage2_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyBufferToImage2_CallbackFunctionPointer(commandBuffer, pCopyBufferToImageInfo, Mock.vkCmdCopyBufferToImage2_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdCopyBufferToImage2(CMOCK_vkCmdCopyBufferToImage2_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); +void CMockExpectParameters_vkCmdCopyBufferToImage2(CMOCK_vkCmdCopyBufferToImage2_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pCopyBufferToImageInfo = pCopyBufferToImageInfo; + cmock_call_instance->IgnoreArg_pCopyBufferToImageInfo = 0; +} + +void vkCmdCopyBufferToImage2_CMockIgnore(void) +{ + Mock.vkCmdCopyBufferToImage2_IgnoreBool = (char)1; +} + +void vkCmdCopyBufferToImage2_CMockStopIgnore(void) +{ + Mock.vkCmdCopyBufferToImage2_IgnoreBool = (char)0; +} + +void vkCmdCopyBufferToImage2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyBufferToImage2_CALL_INSTANCE)); + CMOCK_vkCmdCopyBufferToImage2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBufferToImage2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyBufferToImage2_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyBufferToImage2_CallInstance, cmock_guts_index); + Mock.vkCmdCopyBufferToImage2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdCopyBufferToImage2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyBufferToImage2_CALL_INSTANCE)); + CMOCK_vkCmdCopyBufferToImage2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBufferToImage2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyBufferToImage2_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyBufferToImage2_CallInstance, cmock_guts_index); + Mock.vkCmdCopyBufferToImage2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdCopyBufferToImage2(cmock_call_instance, commandBuffer, pCopyBufferToImageInfo); +} + +void vkCmdCopyBufferToImage2_AddCallback(CMOCK_vkCmdCopyBufferToImage2_CALLBACK Callback) +{ + Mock.vkCmdCopyBufferToImage2_IgnoreBool = (char)0; + Mock.vkCmdCopyBufferToImage2_CallbackBool = (char)1; + Mock.vkCmdCopyBufferToImage2_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyBufferToImage2_Stub(CMOCK_vkCmdCopyBufferToImage2_CALLBACK Callback) +{ + Mock.vkCmdCopyBufferToImage2_IgnoreBool = (char)0; + Mock.vkCmdCopyBufferToImage2_CallbackBool = (char)0; + Mock.vkCmdCopyBufferToImage2_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyBufferToImage2_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyBufferToImage2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBufferToImage2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyBufferToImage2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdCopyBufferToImage2_CMockIgnoreArg_pCopyBufferToImageInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyBufferToImage2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBufferToImage2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyBufferToImage2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCopyBufferToImageInfo = 1; +} + +void vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdCopyImageToBuffer2_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdCopyImageToBuffer2); + cmock_call_instance = (CMOCK_vkCmdCopyImageToBuffer2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdCopyImageToBuffer2_CallInstance); + Mock.vkCmdCopyImageToBuffer2_CallInstance = CMock_Guts_MemNext(Mock.vkCmdCopyImageToBuffer2_CallInstance); + if (Mock.vkCmdCopyImageToBuffer2_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdCopyImageToBuffer2_CallbackBool && + Mock.vkCmdCopyImageToBuffer2_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyImageToBuffer2_CallbackFunctionPointer(commandBuffer, pCopyImageToBufferInfo, Mock.vkCmdCopyImageToBuffer2_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyImageToBuffer2,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCopyImageToBufferInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyImageToBuffer2,CMockString_pCopyImageToBufferInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCopyImageToBufferInfo), (void*)(pCopyImageToBufferInfo), sizeof(const VkCopyImageToBufferInfo2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdCopyImageToBuffer2_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyImageToBuffer2_CallbackFunctionPointer(commandBuffer, pCopyImageToBufferInfo, Mock.vkCmdCopyImageToBuffer2_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdCopyImageToBuffer2(CMOCK_vkCmdCopyImageToBuffer2_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); +void CMockExpectParameters_vkCmdCopyImageToBuffer2(CMOCK_vkCmdCopyImageToBuffer2_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pCopyImageToBufferInfo = pCopyImageToBufferInfo; + cmock_call_instance->IgnoreArg_pCopyImageToBufferInfo = 0; +} + +void vkCmdCopyImageToBuffer2_CMockIgnore(void) +{ + Mock.vkCmdCopyImageToBuffer2_IgnoreBool = (char)1; +} + +void vkCmdCopyImageToBuffer2_CMockStopIgnore(void) +{ + Mock.vkCmdCopyImageToBuffer2_IgnoreBool = (char)0; +} + +void vkCmdCopyImageToBuffer2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyImageToBuffer2_CALL_INSTANCE)); + CMOCK_vkCmdCopyImageToBuffer2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImageToBuffer2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyImageToBuffer2_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyImageToBuffer2_CallInstance, cmock_guts_index); + Mock.vkCmdCopyImageToBuffer2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdCopyImageToBuffer2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyImageToBuffer2_CALL_INSTANCE)); + CMOCK_vkCmdCopyImageToBuffer2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImageToBuffer2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyImageToBuffer2_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyImageToBuffer2_CallInstance, cmock_guts_index); + Mock.vkCmdCopyImageToBuffer2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdCopyImageToBuffer2(cmock_call_instance, commandBuffer, pCopyImageToBufferInfo); +} + +void vkCmdCopyImageToBuffer2_AddCallback(CMOCK_vkCmdCopyImageToBuffer2_CALLBACK Callback) +{ + Mock.vkCmdCopyImageToBuffer2_IgnoreBool = (char)0; + Mock.vkCmdCopyImageToBuffer2_CallbackBool = (char)1; + Mock.vkCmdCopyImageToBuffer2_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyImageToBuffer2_Stub(CMOCK_vkCmdCopyImageToBuffer2_CALLBACK Callback) +{ + Mock.vkCmdCopyImageToBuffer2_IgnoreBool = (char)0; + Mock.vkCmdCopyImageToBuffer2_CallbackBool = (char)0; + Mock.vkCmdCopyImageToBuffer2_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyImageToBuffer2_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyImageToBuffer2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImageToBuffer2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyImageToBuffer2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdCopyImageToBuffer2_CMockIgnoreArg_pCopyImageToBufferInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyImageToBuffer2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImageToBuffer2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyImageToBuffer2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCopyImageToBufferInfo = 1; +} + +void vkCmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBlitImage2_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBlitImage2); + cmock_call_instance = (CMOCK_vkCmdBlitImage2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBlitImage2_CallInstance); + Mock.vkCmdBlitImage2_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBlitImage2_CallInstance); + if (Mock.vkCmdBlitImage2_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBlitImage2_CallbackBool && + Mock.vkCmdBlitImage2_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBlitImage2_CallbackFunctionPointer(commandBuffer, pBlitImageInfo, Mock.vkCmdBlitImage2_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBlitImage2,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pBlitImageInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdBlitImage2,CMockString_pBlitImageInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pBlitImageInfo), (void*)(pBlitImageInfo), sizeof(const VkBlitImageInfo2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdBlitImage2_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBlitImage2_CallbackFunctionPointer(commandBuffer, pBlitImageInfo, Mock.vkCmdBlitImage2_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBlitImage2(CMOCK_vkCmdBlitImage2_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo); +void CMockExpectParameters_vkCmdBlitImage2(CMOCK_vkCmdBlitImage2_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pBlitImageInfo = pBlitImageInfo; + cmock_call_instance->IgnoreArg_pBlitImageInfo = 0; +} + +void vkCmdBlitImage2_CMockIgnore(void) +{ + Mock.vkCmdBlitImage2_IgnoreBool = (char)1; +} + +void vkCmdBlitImage2_CMockStopIgnore(void) +{ + Mock.vkCmdBlitImage2_IgnoreBool = (char)0; +} + +void vkCmdBlitImage2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBlitImage2_CALL_INSTANCE)); + CMOCK_vkCmdBlitImage2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBlitImage2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBlitImage2_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBlitImage2_CallInstance, cmock_guts_index); + Mock.vkCmdBlitImage2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBlitImage2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBlitImage2_CALL_INSTANCE)); + CMOCK_vkCmdBlitImage2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBlitImage2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBlitImage2_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBlitImage2_CallInstance, cmock_guts_index); + Mock.vkCmdBlitImage2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBlitImage2(cmock_call_instance, commandBuffer, pBlitImageInfo); +} + +void vkCmdBlitImage2_AddCallback(CMOCK_vkCmdBlitImage2_CALLBACK Callback) +{ + Mock.vkCmdBlitImage2_IgnoreBool = (char)0; + Mock.vkCmdBlitImage2_CallbackBool = (char)1; + Mock.vkCmdBlitImage2_CallbackFunctionPointer = Callback; +} + +void vkCmdBlitImage2_Stub(CMOCK_vkCmdBlitImage2_CALLBACK Callback) +{ + Mock.vkCmdBlitImage2_IgnoreBool = (char)0; + Mock.vkCmdBlitImage2_CallbackBool = (char)0; + Mock.vkCmdBlitImage2_CallbackFunctionPointer = Callback; +} + +void vkCmdBlitImage2_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBlitImage2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBlitImage2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBlitImage2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBlitImage2_CMockIgnoreArg_pBlitImageInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBlitImage2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBlitImage2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBlitImage2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pBlitImageInfo = 1; +} + +void vkCmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdResolveImage2_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdResolveImage2); + cmock_call_instance = (CMOCK_vkCmdResolveImage2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdResolveImage2_CallInstance); + Mock.vkCmdResolveImage2_CallInstance = CMock_Guts_MemNext(Mock.vkCmdResolveImage2_CallInstance); + if (Mock.vkCmdResolveImage2_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdResolveImage2_CallbackBool && + Mock.vkCmdResolveImage2_CallbackFunctionPointer != NULL) + { + Mock.vkCmdResolveImage2_CallbackFunctionPointer(commandBuffer, pResolveImageInfo, Mock.vkCmdResolveImage2_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdResolveImage2,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pResolveImageInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdResolveImage2,CMockString_pResolveImageInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pResolveImageInfo), (void*)(pResolveImageInfo), sizeof(const VkResolveImageInfo2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdResolveImage2_CallbackFunctionPointer != NULL) + { + Mock.vkCmdResolveImage2_CallbackFunctionPointer(commandBuffer, pResolveImageInfo, Mock.vkCmdResolveImage2_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdResolveImage2(CMOCK_vkCmdResolveImage2_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo); +void CMockExpectParameters_vkCmdResolveImage2(CMOCK_vkCmdResolveImage2_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pResolveImageInfo = pResolveImageInfo; + cmock_call_instance->IgnoreArg_pResolveImageInfo = 0; +} + +void vkCmdResolveImage2_CMockIgnore(void) +{ + Mock.vkCmdResolveImage2_IgnoreBool = (char)1; +} + +void vkCmdResolveImage2_CMockStopIgnore(void) +{ + Mock.vkCmdResolveImage2_IgnoreBool = (char)0; +} + +void vkCmdResolveImage2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdResolveImage2_CALL_INSTANCE)); + CMOCK_vkCmdResolveImage2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResolveImage2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdResolveImage2_CallInstance = CMock_Guts_MemChain(Mock.vkCmdResolveImage2_CallInstance, cmock_guts_index); + Mock.vkCmdResolveImage2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdResolveImage2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdResolveImage2_CALL_INSTANCE)); + CMOCK_vkCmdResolveImage2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResolveImage2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdResolveImage2_CallInstance = CMock_Guts_MemChain(Mock.vkCmdResolveImage2_CallInstance, cmock_guts_index); + Mock.vkCmdResolveImage2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdResolveImage2(cmock_call_instance, commandBuffer, pResolveImageInfo); +} + +void vkCmdResolveImage2_AddCallback(CMOCK_vkCmdResolveImage2_CALLBACK Callback) +{ + Mock.vkCmdResolveImage2_IgnoreBool = (char)0; + Mock.vkCmdResolveImage2_CallbackBool = (char)1; + Mock.vkCmdResolveImage2_CallbackFunctionPointer = Callback; +} + +void vkCmdResolveImage2_Stub(CMOCK_vkCmdResolveImage2_CALLBACK Callback) +{ + Mock.vkCmdResolveImage2_IgnoreBool = (char)0; + Mock.vkCmdResolveImage2_CallbackBool = (char)0; + Mock.vkCmdResolveImage2_CallbackFunctionPointer = Callback; +} + +void vkCmdResolveImage2_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdResolveImage2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResolveImage2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdResolveImage2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdResolveImage2_CMockIgnoreArg_pResolveImageInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdResolveImage2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResolveImage2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdResolveImage2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pResolveImageInfo = 1; +} + +void vkCmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBeginRendering_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBeginRendering); + cmock_call_instance = (CMOCK_vkCmdBeginRendering_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBeginRendering_CallInstance); + Mock.vkCmdBeginRendering_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBeginRendering_CallInstance); + if (Mock.vkCmdBeginRendering_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBeginRendering_CallbackBool && + Mock.vkCmdBeginRendering_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBeginRendering_CallbackFunctionPointer(commandBuffer, pRenderingInfo, Mock.vkCmdBeginRendering_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginRendering,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pRenderingInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginRendering,CMockString_pRenderingInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pRenderingInfo), (void*)(pRenderingInfo), sizeof(const VkRenderingInfo), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdBeginRendering_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBeginRendering_CallbackFunctionPointer(commandBuffer, pRenderingInfo, Mock.vkCmdBeginRendering_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBeginRendering(CMOCK_vkCmdBeginRendering_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo); +void CMockExpectParameters_vkCmdBeginRendering(CMOCK_vkCmdBeginRendering_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pRenderingInfo = pRenderingInfo; + cmock_call_instance->IgnoreArg_pRenderingInfo = 0; +} + +void vkCmdBeginRendering_CMockIgnore(void) +{ + Mock.vkCmdBeginRendering_IgnoreBool = (char)1; +} + +void vkCmdBeginRendering_CMockStopIgnore(void) +{ + Mock.vkCmdBeginRendering_IgnoreBool = (char)0; +} + +void vkCmdBeginRendering_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBeginRendering_CALL_INSTANCE)); + CMOCK_vkCmdBeginRendering_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginRendering_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBeginRendering_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBeginRendering_CallInstance, cmock_guts_index); + Mock.vkCmdBeginRendering_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBeginRendering_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBeginRendering_CALL_INSTANCE)); + CMOCK_vkCmdBeginRendering_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginRendering_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBeginRendering_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBeginRendering_CallInstance, cmock_guts_index); + Mock.vkCmdBeginRendering_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBeginRendering(cmock_call_instance, commandBuffer, pRenderingInfo); +} + +void vkCmdBeginRendering_AddCallback(CMOCK_vkCmdBeginRendering_CALLBACK Callback) +{ + Mock.vkCmdBeginRendering_IgnoreBool = (char)0; + Mock.vkCmdBeginRendering_CallbackBool = (char)1; + Mock.vkCmdBeginRendering_CallbackFunctionPointer = Callback; +} + +void vkCmdBeginRendering_Stub(CMOCK_vkCmdBeginRendering_CALLBACK Callback) +{ + Mock.vkCmdBeginRendering_IgnoreBool = (char)0; + Mock.vkCmdBeginRendering_CallbackBool = (char)0; + Mock.vkCmdBeginRendering_CallbackFunctionPointer = Callback; +} + +void vkCmdBeginRendering_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginRendering_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginRendering_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginRendering_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBeginRendering_CMockIgnoreArg_pRenderingInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginRendering_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginRendering_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginRendering_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pRenderingInfo = 1; +} + +void vkCmdEndRendering(VkCommandBuffer commandBuffer) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdEndRendering_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdEndRendering); + cmock_call_instance = (CMOCK_vkCmdEndRendering_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdEndRendering_CallInstance); + Mock.vkCmdEndRendering_CallInstance = CMock_Guts_MemNext(Mock.vkCmdEndRendering_CallInstance); + if (Mock.vkCmdEndRendering_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdEndRendering_CallbackBool && + Mock.vkCmdEndRendering_CallbackFunctionPointer != NULL) + { + Mock.vkCmdEndRendering_CallbackFunctionPointer(commandBuffer, Mock.vkCmdEndRendering_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdEndRendering,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdEndRendering_CallbackFunctionPointer != NULL) + { + Mock.vkCmdEndRendering_CallbackFunctionPointer(commandBuffer, Mock.vkCmdEndRendering_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdEndRendering(CMOCK_vkCmdEndRendering_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer); +void CMockExpectParameters_vkCmdEndRendering(CMOCK_vkCmdEndRendering_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; +} + +void vkCmdEndRendering_CMockIgnore(void) +{ + Mock.vkCmdEndRendering_IgnoreBool = (char)1; +} + +void vkCmdEndRendering_CMockStopIgnore(void) +{ + Mock.vkCmdEndRendering_IgnoreBool = (char)0; +} + +void vkCmdEndRendering_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdEndRendering_CALL_INSTANCE)); + CMOCK_vkCmdEndRendering_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndRendering_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdEndRendering_CallInstance = CMock_Guts_MemChain(Mock.vkCmdEndRendering_CallInstance, cmock_guts_index); + Mock.vkCmdEndRendering_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdEndRendering_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdEndRendering_CALL_INSTANCE)); + CMOCK_vkCmdEndRendering_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndRendering_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdEndRendering_CallInstance = CMock_Guts_MemChain(Mock.vkCmdEndRendering_CallInstance, cmock_guts_index); + Mock.vkCmdEndRendering_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdEndRendering(cmock_call_instance, commandBuffer); +} + +void vkCmdEndRendering_AddCallback(CMOCK_vkCmdEndRendering_CALLBACK Callback) +{ + Mock.vkCmdEndRendering_IgnoreBool = (char)0; + Mock.vkCmdEndRendering_CallbackBool = (char)1; + Mock.vkCmdEndRendering_CallbackFunctionPointer = Callback; +} + +void vkCmdEndRendering_Stub(CMOCK_vkCmdEndRendering_CALLBACK Callback) +{ + Mock.vkCmdEndRendering_IgnoreBool = (char)0; + Mock.vkCmdEndRendering_CallbackBool = (char)0; + Mock.vkCmdEndRendering_CallbackFunctionPointer = Callback; +} + +void vkCmdEndRendering_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdEndRendering_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndRendering_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdEndRendering_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetCullMode_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetCullMode); + cmock_call_instance = (CMOCK_vkCmdSetCullMode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetCullMode_CallInstance); + Mock.vkCmdSetCullMode_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetCullMode_CallInstance); + if (Mock.vkCmdSetCullMode_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetCullMode_CallbackBool && + Mock.vkCmdSetCullMode_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetCullMode_CallbackFunctionPointer(commandBuffer, cullMode, Mock.vkCmdSetCullMode_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetCullMode,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_cullMode) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetCullMode,CMockString_cullMode); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_cullMode), (void*)(&cullMode), sizeof(VkCullModeFlags), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetCullMode_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetCullMode_CallbackFunctionPointer(commandBuffer, cullMode, Mock.vkCmdSetCullMode_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetCullMode(CMOCK_vkCmdSetCullMode_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkCullModeFlags cullMode); +void CMockExpectParameters_vkCmdSetCullMode(CMOCK_vkCmdSetCullMode_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_cullMode), (void*)(&cullMode), + sizeof(VkCullModeFlags[sizeof(cullMode) == sizeof(VkCullModeFlags) ? 1 : -1])); /* add VkCullModeFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_cullMode = 0; +} + +void vkCmdSetCullMode_CMockIgnore(void) +{ + Mock.vkCmdSetCullMode_IgnoreBool = (char)1; +} + +void vkCmdSetCullMode_CMockStopIgnore(void) +{ + Mock.vkCmdSetCullMode_IgnoreBool = (char)0; +} + +void vkCmdSetCullMode_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetCullMode_CALL_INSTANCE)); + CMOCK_vkCmdSetCullMode_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCullMode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetCullMode_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetCullMode_CallInstance, cmock_guts_index); + Mock.vkCmdSetCullMode_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetCullMode_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetCullMode_CALL_INSTANCE)); + CMOCK_vkCmdSetCullMode_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCullMode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetCullMode_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetCullMode_CallInstance, cmock_guts_index); + Mock.vkCmdSetCullMode_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetCullMode(cmock_call_instance, commandBuffer, cullMode); +} + +void vkCmdSetCullMode_AddCallback(CMOCK_vkCmdSetCullMode_CALLBACK Callback) +{ + Mock.vkCmdSetCullMode_IgnoreBool = (char)0; + Mock.vkCmdSetCullMode_CallbackBool = (char)1; + Mock.vkCmdSetCullMode_CallbackFunctionPointer = Callback; +} + +void vkCmdSetCullMode_Stub(CMOCK_vkCmdSetCullMode_CALLBACK Callback) +{ + Mock.vkCmdSetCullMode_IgnoreBool = (char)0; + Mock.vkCmdSetCullMode_CallbackBool = (char)0; + Mock.vkCmdSetCullMode_CallbackFunctionPointer = Callback; +} + +void vkCmdSetCullMode_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetCullMode_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCullMode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetCullMode_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetCullMode_CMockIgnoreArg_cullMode(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetCullMode_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCullMode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetCullMode_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_cullMode = 1; +} + +void vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetFrontFace_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetFrontFace); + cmock_call_instance = (CMOCK_vkCmdSetFrontFace_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetFrontFace_CallInstance); + Mock.vkCmdSetFrontFace_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetFrontFace_CallInstance); + if (Mock.vkCmdSetFrontFace_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetFrontFace_CallbackBool && + Mock.vkCmdSetFrontFace_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetFrontFace_CallbackFunctionPointer(commandBuffer, frontFace, Mock.vkCmdSetFrontFace_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetFrontFace,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_frontFace) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetFrontFace,CMockString_frontFace); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_frontFace), (void*)(&frontFace), sizeof(VkFrontFace), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetFrontFace_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetFrontFace_CallbackFunctionPointer(commandBuffer, frontFace, Mock.vkCmdSetFrontFace_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetFrontFace(CMOCK_vkCmdSetFrontFace_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkFrontFace frontFace); +void CMockExpectParameters_vkCmdSetFrontFace(CMOCK_vkCmdSetFrontFace_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkFrontFace frontFace) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_frontFace), (void*)(&frontFace), + sizeof(VkFrontFace[sizeof(frontFace) == sizeof(VkFrontFace) ? 1 : -1])); /* add VkFrontFace to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_frontFace = 0; +} + +void vkCmdSetFrontFace_CMockIgnore(void) +{ + Mock.vkCmdSetFrontFace_IgnoreBool = (char)1; +} + +void vkCmdSetFrontFace_CMockStopIgnore(void) +{ + Mock.vkCmdSetFrontFace_IgnoreBool = (char)0; +} + +void vkCmdSetFrontFace_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetFrontFace_CALL_INSTANCE)); + CMOCK_vkCmdSetFrontFace_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetFrontFace_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetFrontFace_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetFrontFace_CallInstance, cmock_guts_index); + Mock.vkCmdSetFrontFace_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetFrontFace_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkFrontFace frontFace) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetFrontFace_CALL_INSTANCE)); + CMOCK_vkCmdSetFrontFace_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetFrontFace_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetFrontFace_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetFrontFace_CallInstance, cmock_guts_index); + Mock.vkCmdSetFrontFace_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetFrontFace(cmock_call_instance, commandBuffer, frontFace); +} + +void vkCmdSetFrontFace_AddCallback(CMOCK_vkCmdSetFrontFace_CALLBACK Callback) +{ + Mock.vkCmdSetFrontFace_IgnoreBool = (char)0; + Mock.vkCmdSetFrontFace_CallbackBool = (char)1; + Mock.vkCmdSetFrontFace_CallbackFunctionPointer = Callback; +} + +void vkCmdSetFrontFace_Stub(CMOCK_vkCmdSetFrontFace_CALLBACK Callback) +{ + Mock.vkCmdSetFrontFace_IgnoreBool = (char)0; + Mock.vkCmdSetFrontFace_CallbackBool = (char)0; + Mock.vkCmdSetFrontFace_CallbackFunctionPointer = Callback; +} + +void vkCmdSetFrontFace_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetFrontFace_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetFrontFace_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetFrontFace_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetFrontFace_CMockIgnoreArg_frontFace(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetFrontFace_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetFrontFace_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetFrontFace_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_frontFace = 1; +} + +void vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetPrimitiveTopology_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetPrimitiveTopology); + cmock_call_instance = (CMOCK_vkCmdSetPrimitiveTopology_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetPrimitiveTopology_CallInstance); + Mock.vkCmdSetPrimitiveTopology_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetPrimitiveTopology_CallInstance); + if (Mock.vkCmdSetPrimitiveTopology_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetPrimitiveTopology_CallbackBool && + Mock.vkCmdSetPrimitiveTopology_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetPrimitiveTopology_CallbackFunctionPointer(commandBuffer, primitiveTopology, Mock.vkCmdSetPrimitiveTopology_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetPrimitiveTopology,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_primitiveTopology) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetPrimitiveTopology,CMockString_primitiveTopology); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_primitiveTopology), (void*)(&primitiveTopology), sizeof(VkPrimitiveTopology), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetPrimitiveTopology_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetPrimitiveTopology_CallbackFunctionPointer(commandBuffer, primitiveTopology, Mock.vkCmdSetPrimitiveTopology_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetPrimitiveTopology(CMOCK_vkCmdSetPrimitiveTopology_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology); +void CMockExpectParameters_vkCmdSetPrimitiveTopology(CMOCK_vkCmdSetPrimitiveTopology_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_primitiveTopology), (void*)(&primitiveTopology), + sizeof(VkPrimitiveTopology[sizeof(primitiveTopology) == sizeof(VkPrimitiveTopology) ? 1 : -1])); /* add VkPrimitiveTopology to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_primitiveTopology = 0; +} + +void vkCmdSetPrimitiveTopology_CMockIgnore(void) +{ + Mock.vkCmdSetPrimitiveTopology_IgnoreBool = (char)1; +} + +void vkCmdSetPrimitiveTopology_CMockStopIgnore(void) +{ + Mock.vkCmdSetPrimitiveTopology_IgnoreBool = (char)0; +} + +void vkCmdSetPrimitiveTopology_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetPrimitiveTopology_CALL_INSTANCE)); + CMOCK_vkCmdSetPrimitiveTopology_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPrimitiveTopology_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetPrimitiveTopology_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetPrimitiveTopology_CallInstance, cmock_guts_index); + Mock.vkCmdSetPrimitiveTopology_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetPrimitiveTopology_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetPrimitiveTopology_CALL_INSTANCE)); + CMOCK_vkCmdSetPrimitiveTopology_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPrimitiveTopology_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetPrimitiveTopology_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetPrimitiveTopology_CallInstance, cmock_guts_index); + Mock.vkCmdSetPrimitiveTopology_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetPrimitiveTopology(cmock_call_instance, commandBuffer, primitiveTopology); +} + +void vkCmdSetPrimitiveTopology_AddCallback(CMOCK_vkCmdSetPrimitiveTopology_CALLBACK Callback) +{ + Mock.vkCmdSetPrimitiveTopology_IgnoreBool = (char)0; + Mock.vkCmdSetPrimitiveTopology_CallbackBool = (char)1; + Mock.vkCmdSetPrimitiveTopology_CallbackFunctionPointer = Callback; +} + +void vkCmdSetPrimitiveTopology_Stub(CMOCK_vkCmdSetPrimitiveTopology_CALLBACK Callback) +{ + Mock.vkCmdSetPrimitiveTopology_IgnoreBool = (char)0; + Mock.vkCmdSetPrimitiveTopology_CallbackBool = (char)0; + Mock.vkCmdSetPrimitiveTopology_CallbackFunctionPointer = Callback; +} + +void vkCmdSetPrimitiveTopology_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetPrimitiveTopology_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPrimitiveTopology_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetPrimitiveTopology_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetPrimitiveTopology_CMockIgnoreArg_primitiveTopology(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetPrimitiveTopology_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPrimitiveTopology_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetPrimitiveTopology_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_primitiveTopology = 1; +} + +void vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetViewportWithCount_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetViewportWithCount); + cmock_call_instance = (CMOCK_vkCmdSetViewportWithCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetViewportWithCount_CallInstance); + Mock.vkCmdSetViewportWithCount_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetViewportWithCount_CallInstance); + if (Mock.vkCmdSetViewportWithCount_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetViewportWithCount_CallbackBool && + Mock.vkCmdSetViewportWithCount_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetViewportWithCount_CallbackFunctionPointer(commandBuffer, viewportCount, pViewports, Mock.vkCmdSetViewportWithCount_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetViewportWithCount,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_viewportCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetViewportWithCount,CMockString_viewportCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_viewportCount, viewportCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pViewports) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetViewportWithCount,CMockString_pViewports); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pViewports), (void*)(pViewports), sizeof(const VkViewport), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetViewportWithCount_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetViewportWithCount_CallbackFunctionPointer(commandBuffer, viewportCount, pViewports, Mock.vkCmdSetViewportWithCount_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetViewportWithCount(CMOCK_vkCmdSetViewportWithCount_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports); +void CMockExpectParameters_vkCmdSetViewportWithCount(CMOCK_vkCmdSetViewportWithCount_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_viewportCount = viewportCount; + cmock_call_instance->IgnoreArg_viewportCount = 0; + cmock_call_instance->Expected_pViewports = pViewports; + cmock_call_instance->IgnoreArg_pViewports = 0; +} + +void vkCmdSetViewportWithCount_CMockIgnore(void) +{ + Mock.vkCmdSetViewportWithCount_IgnoreBool = (char)1; +} + +void vkCmdSetViewportWithCount_CMockStopIgnore(void) +{ + Mock.vkCmdSetViewportWithCount_IgnoreBool = (char)0; +} + +void vkCmdSetViewportWithCount_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetViewportWithCount_CALL_INSTANCE)); + CMOCK_vkCmdSetViewportWithCount_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportWithCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetViewportWithCount_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetViewportWithCount_CallInstance, cmock_guts_index); + Mock.vkCmdSetViewportWithCount_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetViewportWithCount_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetViewportWithCount_CALL_INSTANCE)); + CMOCK_vkCmdSetViewportWithCount_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportWithCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetViewportWithCount_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetViewportWithCount_CallInstance, cmock_guts_index); + Mock.vkCmdSetViewportWithCount_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetViewportWithCount(cmock_call_instance, commandBuffer, viewportCount, pViewports); +} + +void vkCmdSetViewportWithCount_AddCallback(CMOCK_vkCmdSetViewportWithCount_CALLBACK Callback) +{ + Mock.vkCmdSetViewportWithCount_IgnoreBool = (char)0; + Mock.vkCmdSetViewportWithCount_CallbackBool = (char)1; + Mock.vkCmdSetViewportWithCount_CallbackFunctionPointer = Callback; +} + +void vkCmdSetViewportWithCount_Stub(CMOCK_vkCmdSetViewportWithCount_CALLBACK Callback) +{ + Mock.vkCmdSetViewportWithCount_IgnoreBool = (char)0; + Mock.vkCmdSetViewportWithCount_CallbackBool = (char)0; + Mock.vkCmdSetViewportWithCount_CallbackFunctionPointer = Callback; +} + +void vkCmdSetViewportWithCount_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetViewportWithCount_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportWithCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetViewportWithCount_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetViewportWithCount_CMockIgnoreArg_viewportCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetViewportWithCount_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportWithCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetViewportWithCount_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_viewportCount = 1; +} + +void vkCmdSetViewportWithCount_CMockIgnoreArg_pViewports(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetViewportWithCount_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportWithCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetViewportWithCount_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pViewports = 1; +} + +void vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetScissorWithCount_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetScissorWithCount); + cmock_call_instance = (CMOCK_vkCmdSetScissorWithCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetScissorWithCount_CallInstance); + Mock.vkCmdSetScissorWithCount_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetScissorWithCount_CallInstance); + if (Mock.vkCmdSetScissorWithCount_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetScissorWithCount_CallbackBool && + Mock.vkCmdSetScissorWithCount_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetScissorWithCount_CallbackFunctionPointer(commandBuffer, scissorCount, pScissors, Mock.vkCmdSetScissorWithCount_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetScissorWithCount,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_scissorCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetScissorWithCount,CMockString_scissorCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_scissorCount, scissorCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pScissors) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetScissorWithCount,CMockString_pScissors); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pScissors), (void*)(pScissors), sizeof(const VkRect2D), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetScissorWithCount_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetScissorWithCount_CallbackFunctionPointer(commandBuffer, scissorCount, pScissors, Mock.vkCmdSetScissorWithCount_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetScissorWithCount(CMOCK_vkCmdSetScissorWithCount_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors); +void CMockExpectParameters_vkCmdSetScissorWithCount(CMOCK_vkCmdSetScissorWithCount_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_scissorCount = scissorCount; + cmock_call_instance->IgnoreArg_scissorCount = 0; + cmock_call_instance->Expected_pScissors = pScissors; + cmock_call_instance->IgnoreArg_pScissors = 0; +} + +void vkCmdSetScissorWithCount_CMockIgnore(void) +{ + Mock.vkCmdSetScissorWithCount_IgnoreBool = (char)1; +} + +void vkCmdSetScissorWithCount_CMockStopIgnore(void) +{ + Mock.vkCmdSetScissorWithCount_IgnoreBool = (char)0; +} + +void vkCmdSetScissorWithCount_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetScissorWithCount_CALL_INSTANCE)); + CMOCK_vkCmdSetScissorWithCount_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetScissorWithCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetScissorWithCount_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetScissorWithCount_CallInstance, cmock_guts_index); + Mock.vkCmdSetScissorWithCount_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetScissorWithCount_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetScissorWithCount_CALL_INSTANCE)); + CMOCK_vkCmdSetScissorWithCount_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetScissorWithCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetScissorWithCount_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetScissorWithCount_CallInstance, cmock_guts_index); + Mock.vkCmdSetScissorWithCount_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetScissorWithCount(cmock_call_instance, commandBuffer, scissorCount, pScissors); +} + +void vkCmdSetScissorWithCount_AddCallback(CMOCK_vkCmdSetScissorWithCount_CALLBACK Callback) +{ + Mock.vkCmdSetScissorWithCount_IgnoreBool = (char)0; + Mock.vkCmdSetScissorWithCount_CallbackBool = (char)1; + Mock.vkCmdSetScissorWithCount_CallbackFunctionPointer = Callback; +} + +void vkCmdSetScissorWithCount_Stub(CMOCK_vkCmdSetScissorWithCount_CALLBACK Callback) +{ + Mock.vkCmdSetScissorWithCount_IgnoreBool = (char)0; + Mock.vkCmdSetScissorWithCount_CallbackBool = (char)0; + Mock.vkCmdSetScissorWithCount_CallbackFunctionPointer = Callback; +} + +void vkCmdSetScissorWithCount_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetScissorWithCount_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetScissorWithCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetScissorWithCount_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetScissorWithCount_CMockIgnoreArg_scissorCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetScissorWithCount_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetScissorWithCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetScissorWithCount_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_scissorCount = 1; +} + +void vkCmdSetScissorWithCount_CMockIgnoreArg_pScissors(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetScissorWithCount_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetScissorWithCount_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetScissorWithCount_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pScissors = 1; +} + +void vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBindVertexBuffers2_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBindVertexBuffers2); + cmock_call_instance = (CMOCK_vkCmdBindVertexBuffers2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBindVertexBuffers2_CallInstance); + Mock.vkCmdBindVertexBuffers2_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBindVertexBuffers2_CallInstance); + if (Mock.vkCmdBindVertexBuffers2_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBindVertexBuffers2_CallbackBool && + Mock.vkCmdBindVertexBuffers2_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBindVertexBuffers2_CallbackFunctionPointer(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides, Mock.vkCmdBindVertexBuffers2_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindVertexBuffers2,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstBinding) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindVertexBuffers2,CMockString_firstBinding); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstBinding, firstBinding, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_bindingCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindVertexBuffers2,CMockString_bindingCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_bindingCount, bindingCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pBuffers) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindVertexBuffers2,CMockString_pBuffers); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pBuffers), (void*)(pBuffers), sizeof(const VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pOffsets) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindVertexBuffers2,CMockString_pOffsets); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pOffsets), (void*)(pOffsets), sizeof(const VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSizes) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindVertexBuffers2,CMockString_pSizes); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSizes), (void*)(pSizes), sizeof(const VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pStrides) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindVertexBuffers2,CMockString_pStrides); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pStrides), (void*)(pStrides), sizeof(const VkDeviceSize), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdBindVertexBuffers2_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBindVertexBuffers2_CallbackFunctionPointer(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides, Mock.vkCmdBindVertexBuffers2_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBindVertexBuffers2(CMOCK_vkCmdBindVertexBuffers2_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides); +void CMockExpectParameters_vkCmdBindVertexBuffers2(CMOCK_vkCmdBindVertexBuffers2_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_firstBinding = firstBinding; + cmock_call_instance->IgnoreArg_firstBinding = 0; + cmock_call_instance->Expected_bindingCount = bindingCount; + cmock_call_instance->IgnoreArg_bindingCount = 0; + cmock_call_instance->Expected_pBuffers = pBuffers; + cmock_call_instance->IgnoreArg_pBuffers = 0; + cmock_call_instance->Expected_pOffsets = pOffsets; + cmock_call_instance->IgnoreArg_pOffsets = 0; + cmock_call_instance->Expected_pSizes = pSizes; + cmock_call_instance->IgnoreArg_pSizes = 0; + cmock_call_instance->Expected_pStrides = pStrides; + cmock_call_instance->IgnoreArg_pStrides = 0; +} + +void vkCmdBindVertexBuffers2_CMockIgnore(void) +{ + Mock.vkCmdBindVertexBuffers2_IgnoreBool = (char)1; +} + +void vkCmdBindVertexBuffers2_CMockStopIgnore(void) +{ + Mock.vkCmdBindVertexBuffers2_IgnoreBool = (char)0; +} + +void vkCmdBindVertexBuffers2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBindVertexBuffers2_CALL_INSTANCE)); + CMOCK_vkCmdBindVertexBuffers2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindVertexBuffers2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBindVertexBuffers2_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBindVertexBuffers2_CallInstance, cmock_guts_index); + Mock.vkCmdBindVertexBuffers2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBindVertexBuffers2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBindVertexBuffers2_CALL_INSTANCE)); + CMOCK_vkCmdBindVertexBuffers2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindVertexBuffers2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBindVertexBuffers2_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBindVertexBuffers2_CallInstance, cmock_guts_index); + Mock.vkCmdBindVertexBuffers2_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBindVertexBuffers2(cmock_call_instance, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); +} + +void vkCmdBindVertexBuffers2_AddCallback(CMOCK_vkCmdBindVertexBuffers2_CALLBACK Callback) +{ + Mock.vkCmdBindVertexBuffers2_IgnoreBool = (char)0; + Mock.vkCmdBindVertexBuffers2_CallbackBool = (char)1; + Mock.vkCmdBindVertexBuffers2_CallbackFunctionPointer = Callback; +} + +void vkCmdBindVertexBuffers2_Stub(CMOCK_vkCmdBindVertexBuffers2_CALLBACK Callback) +{ + Mock.vkCmdBindVertexBuffers2_IgnoreBool = (char)0; + Mock.vkCmdBindVertexBuffers2_CallbackBool = (char)0; + Mock.vkCmdBindVertexBuffers2_CallbackFunctionPointer = Callback; +} + +void vkCmdBindVertexBuffers2_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindVertexBuffers2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindVertexBuffers2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindVertexBuffers2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBindVertexBuffers2_CMockIgnoreArg_firstBinding(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindVertexBuffers2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindVertexBuffers2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindVertexBuffers2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstBinding = 1; +} + +void vkCmdBindVertexBuffers2_CMockIgnoreArg_bindingCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindVertexBuffers2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindVertexBuffers2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindVertexBuffers2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_bindingCount = 1; +} + +void vkCmdBindVertexBuffers2_CMockIgnoreArg_pBuffers(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindVertexBuffers2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindVertexBuffers2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindVertexBuffers2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pBuffers = 1; +} + +void vkCmdBindVertexBuffers2_CMockIgnoreArg_pOffsets(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindVertexBuffers2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindVertexBuffers2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindVertexBuffers2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pOffsets = 1; +} + +void vkCmdBindVertexBuffers2_CMockIgnoreArg_pSizes(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindVertexBuffers2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindVertexBuffers2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindVertexBuffers2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSizes = 1; +} + +void vkCmdBindVertexBuffers2_CMockIgnoreArg_pStrides(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindVertexBuffers2_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindVertexBuffers2_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindVertexBuffers2_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pStrides = 1; +} + +void vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetDepthTestEnable_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetDepthTestEnable); + cmock_call_instance = (CMOCK_vkCmdSetDepthTestEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetDepthTestEnable_CallInstance); + Mock.vkCmdSetDepthTestEnable_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetDepthTestEnable_CallInstance); + if (Mock.vkCmdSetDepthTestEnable_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetDepthTestEnable_CallbackBool && + Mock.vkCmdSetDepthTestEnable_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDepthTestEnable_CallbackFunctionPointer(commandBuffer, depthTestEnable, Mock.vkCmdSetDepthTestEnable_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthTestEnable,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_depthTestEnable) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthTestEnable,CMockString_depthTestEnable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_depthTestEnable), (void*)(&depthTestEnable), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetDepthTestEnable_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDepthTestEnable_CallbackFunctionPointer(commandBuffer, depthTestEnable, Mock.vkCmdSetDepthTestEnable_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetDepthTestEnable(CMOCK_vkCmdSetDepthTestEnable_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 depthTestEnable); +void CMockExpectParameters_vkCmdSetDepthTestEnable(CMOCK_vkCmdSetDepthTestEnable_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_depthTestEnable), (void*)(&depthTestEnable), + sizeof(VkBool32[sizeof(depthTestEnable) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_depthTestEnable = 0; +} + +void vkCmdSetDepthTestEnable_CMockIgnore(void) +{ + Mock.vkCmdSetDepthTestEnable_IgnoreBool = (char)1; +} + +void vkCmdSetDepthTestEnable_CMockStopIgnore(void) +{ + Mock.vkCmdSetDepthTestEnable_IgnoreBool = (char)0; +} + +void vkCmdSetDepthTestEnable_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDepthTestEnable_CALL_INSTANCE)); + CMOCK_vkCmdSetDepthTestEnable_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthTestEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDepthTestEnable_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDepthTestEnable_CallInstance, cmock_guts_index); + Mock.vkCmdSetDepthTestEnable_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetDepthTestEnable_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDepthTestEnable_CALL_INSTANCE)); + CMOCK_vkCmdSetDepthTestEnable_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthTestEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDepthTestEnable_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDepthTestEnable_CallInstance, cmock_guts_index); + Mock.vkCmdSetDepthTestEnable_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetDepthTestEnable(cmock_call_instance, commandBuffer, depthTestEnable); +} + +void vkCmdSetDepthTestEnable_AddCallback(CMOCK_vkCmdSetDepthTestEnable_CALLBACK Callback) +{ + Mock.vkCmdSetDepthTestEnable_IgnoreBool = (char)0; + Mock.vkCmdSetDepthTestEnable_CallbackBool = (char)1; + Mock.vkCmdSetDepthTestEnable_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDepthTestEnable_Stub(CMOCK_vkCmdSetDepthTestEnable_CALLBACK Callback) +{ + Mock.vkCmdSetDepthTestEnable_IgnoreBool = (char)0; + Mock.vkCmdSetDepthTestEnable_CallbackBool = (char)0; + Mock.vkCmdSetDepthTestEnable_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDepthTestEnable_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthTestEnable_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthTestEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthTestEnable_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetDepthTestEnable_CMockIgnoreArg_depthTestEnable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthTestEnable_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthTestEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthTestEnable_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_depthTestEnable = 1; +} + +void vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetDepthWriteEnable_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetDepthWriteEnable); + cmock_call_instance = (CMOCK_vkCmdSetDepthWriteEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetDepthWriteEnable_CallInstance); + Mock.vkCmdSetDepthWriteEnable_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetDepthWriteEnable_CallInstance); + if (Mock.vkCmdSetDepthWriteEnable_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetDepthWriteEnable_CallbackBool && + Mock.vkCmdSetDepthWriteEnable_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDepthWriteEnable_CallbackFunctionPointer(commandBuffer, depthWriteEnable, Mock.vkCmdSetDepthWriteEnable_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthWriteEnable,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_depthWriteEnable) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthWriteEnable,CMockString_depthWriteEnable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_depthWriteEnable), (void*)(&depthWriteEnable), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetDepthWriteEnable_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDepthWriteEnable_CallbackFunctionPointer(commandBuffer, depthWriteEnable, Mock.vkCmdSetDepthWriteEnable_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetDepthWriteEnable(CMOCK_vkCmdSetDepthWriteEnable_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); +void CMockExpectParameters_vkCmdSetDepthWriteEnable(CMOCK_vkCmdSetDepthWriteEnable_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_depthWriteEnable), (void*)(&depthWriteEnable), + sizeof(VkBool32[sizeof(depthWriteEnable) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_depthWriteEnable = 0; +} + +void vkCmdSetDepthWriteEnable_CMockIgnore(void) +{ + Mock.vkCmdSetDepthWriteEnable_IgnoreBool = (char)1; +} + +void vkCmdSetDepthWriteEnable_CMockStopIgnore(void) +{ + Mock.vkCmdSetDepthWriteEnable_IgnoreBool = (char)0; +} + +void vkCmdSetDepthWriteEnable_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDepthWriteEnable_CALL_INSTANCE)); + CMOCK_vkCmdSetDepthWriteEnable_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthWriteEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDepthWriteEnable_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDepthWriteEnable_CallInstance, cmock_guts_index); + Mock.vkCmdSetDepthWriteEnable_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetDepthWriteEnable_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDepthWriteEnable_CALL_INSTANCE)); + CMOCK_vkCmdSetDepthWriteEnable_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthWriteEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDepthWriteEnable_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDepthWriteEnable_CallInstance, cmock_guts_index); + Mock.vkCmdSetDepthWriteEnable_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetDepthWriteEnable(cmock_call_instance, commandBuffer, depthWriteEnable); +} + +void vkCmdSetDepthWriteEnable_AddCallback(CMOCK_vkCmdSetDepthWriteEnable_CALLBACK Callback) +{ + Mock.vkCmdSetDepthWriteEnable_IgnoreBool = (char)0; + Mock.vkCmdSetDepthWriteEnable_CallbackBool = (char)1; + Mock.vkCmdSetDepthWriteEnable_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDepthWriteEnable_Stub(CMOCK_vkCmdSetDepthWriteEnable_CALLBACK Callback) +{ + Mock.vkCmdSetDepthWriteEnable_IgnoreBool = (char)0; + Mock.vkCmdSetDepthWriteEnable_CallbackBool = (char)0; + Mock.vkCmdSetDepthWriteEnable_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDepthWriteEnable_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthWriteEnable_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthWriteEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthWriteEnable_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetDepthWriteEnable_CMockIgnoreArg_depthWriteEnable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthWriteEnable_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthWriteEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthWriteEnable_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_depthWriteEnable = 1; +} + +void vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetDepthCompareOp_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetDepthCompareOp); + cmock_call_instance = (CMOCK_vkCmdSetDepthCompareOp_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetDepthCompareOp_CallInstance); + Mock.vkCmdSetDepthCompareOp_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetDepthCompareOp_CallInstance); + if (Mock.vkCmdSetDepthCompareOp_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetDepthCompareOp_CallbackBool && + Mock.vkCmdSetDepthCompareOp_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDepthCompareOp_CallbackFunctionPointer(commandBuffer, depthCompareOp, Mock.vkCmdSetDepthCompareOp_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthCompareOp,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_depthCompareOp) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthCompareOp,CMockString_depthCompareOp); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_depthCompareOp), (void*)(&depthCompareOp), sizeof(VkCompareOp), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetDepthCompareOp_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDepthCompareOp_CallbackFunctionPointer(commandBuffer, depthCompareOp, Mock.vkCmdSetDepthCompareOp_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetDepthCompareOp(CMOCK_vkCmdSetDepthCompareOp_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp); +void CMockExpectParameters_vkCmdSetDepthCompareOp(CMOCK_vkCmdSetDepthCompareOp_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_depthCompareOp), (void*)(&depthCompareOp), + sizeof(VkCompareOp[sizeof(depthCompareOp) == sizeof(VkCompareOp) ? 1 : -1])); /* add VkCompareOp to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_depthCompareOp = 0; +} + +void vkCmdSetDepthCompareOp_CMockIgnore(void) +{ + Mock.vkCmdSetDepthCompareOp_IgnoreBool = (char)1; +} + +void vkCmdSetDepthCompareOp_CMockStopIgnore(void) +{ + Mock.vkCmdSetDepthCompareOp_IgnoreBool = (char)0; +} + +void vkCmdSetDepthCompareOp_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDepthCompareOp_CALL_INSTANCE)); + CMOCK_vkCmdSetDepthCompareOp_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthCompareOp_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDepthCompareOp_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDepthCompareOp_CallInstance, cmock_guts_index); + Mock.vkCmdSetDepthCompareOp_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetDepthCompareOp_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDepthCompareOp_CALL_INSTANCE)); + CMOCK_vkCmdSetDepthCompareOp_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthCompareOp_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDepthCompareOp_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDepthCompareOp_CallInstance, cmock_guts_index); + Mock.vkCmdSetDepthCompareOp_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetDepthCompareOp(cmock_call_instance, commandBuffer, depthCompareOp); +} + +void vkCmdSetDepthCompareOp_AddCallback(CMOCK_vkCmdSetDepthCompareOp_CALLBACK Callback) +{ + Mock.vkCmdSetDepthCompareOp_IgnoreBool = (char)0; + Mock.vkCmdSetDepthCompareOp_CallbackBool = (char)1; + Mock.vkCmdSetDepthCompareOp_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDepthCompareOp_Stub(CMOCK_vkCmdSetDepthCompareOp_CALLBACK Callback) +{ + Mock.vkCmdSetDepthCompareOp_IgnoreBool = (char)0; + Mock.vkCmdSetDepthCompareOp_CallbackBool = (char)0; + Mock.vkCmdSetDepthCompareOp_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDepthCompareOp_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthCompareOp_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthCompareOp_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthCompareOp_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetDepthCompareOp_CMockIgnoreArg_depthCompareOp(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthCompareOp_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthCompareOp_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthCompareOp_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_depthCompareOp = 1; +} + +void vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetDepthBoundsTestEnable_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetDepthBoundsTestEnable); + cmock_call_instance = (CMOCK_vkCmdSetDepthBoundsTestEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetDepthBoundsTestEnable_CallInstance); + Mock.vkCmdSetDepthBoundsTestEnable_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetDepthBoundsTestEnable_CallInstance); + if (Mock.vkCmdSetDepthBoundsTestEnable_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetDepthBoundsTestEnable_CallbackBool && + Mock.vkCmdSetDepthBoundsTestEnable_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDepthBoundsTestEnable_CallbackFunctionPointer(commandBuffer, depthBoundsTestEnable, Mock.vkCmdSetDepthBoundsTestEnable_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthBoundsTestEnable,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_depthBoundsTestEnable) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthBoundsTestEnable,CMockString_depthBoundsTestEnable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_depthBoundsTestEnable), (void*)(&depthBoundsTestEnable), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetDepthBoundsTestEnable_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDepthBoundsTestEnable_CallbackFunctionPointer(commandBuffer, depthBoundsTestEnable, Mock.vkCmdSetDepthBoundsTestEnable_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetDepthBoundsTestEnable(CMOCK_vkCmdSetDepthBoundsTestEnable_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable); +void CMockExpectParameters_vkCmdSetDepthBoundsTestEnable(CMOCK_vkCmdSetDepthBoundsTestEnable_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_depthBoundsTestEnable), (void*)(&depthBoundsTestEnable), + sizeof(VkBool32[sizeof(depthBoundsTestEnable) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_depthBoundsTestEnable = 0; +} + +void vkCmdSetDepthBoundsTestEnable_CMockIgnore(void) +{ + Mock.vkCmdSetDepthBoundsTestEnable_IgnoreBool = (char)1; +} + +void vkCmdSetDepthBoundsTestEnable_CMockStopIgnore(void) +{ + Mock.vkCmdSetDepthBoundsTestEnable_IgnoreBool = (char)0; +} + +void vkCmdSetDepthBoundsTestEnable_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDepthBoundsTestEnable_CALL_INSTANCE)); + CMOCK_vkCmdSetDepthBoundsTestEnable_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthBoundsTestEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDepthBoundsTestEnable_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDepthBoundsTestEnable_CallInstance, cmock_guts_index); + Mock.vkCmdSetDepthBoundsTestEnable_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetDepthBoundsTestEnable_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDepthBoundsTestEnable_CALL_INSTANCE)); + CMOCK_vkCmdSetDepthBoundsTestEnable_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthBoundsTestEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDepthBoundsTestEnable_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDepthBoundsTestEnable_CallInstance, cmock_guts_index); + Mock.vkCmdSetDepthBoundsTestEnable_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetDepthBoundsTestEnable(cmock_call_instance, commandBuffer, depthBoundsTestEnable); +} + +void vkCmdSetDepthBoundsTestEnable_AddCallback(CMOCK_vkCmdSetDepthBoundsTestEnable_CALLBACK Callback) +{ + Mock.vkCmdSetDepthBoundsTestEnable_IgnoreBool = (char)0; + Mock.vkCmdSetDepthBoundsTestEnable_CallbackBool = (char)1; + Mock.vkCmdSetDepthBoundsTestEnable_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDepthBoundsTestEnable_Stub(CMOCK_vkCmdSetDepthBoundsTestEnable_CALLBACK Callback) +{ + Mock.vkCmdSetDepthBoundsTestEnable_IgnoreBool = (char)0; + Mock.vkCmdSetDepthBoundsTestEnable_CallbackBool = (char)0; + Mock.vkCmdSetDepthBoundsTestEnable_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDepthBoundsTestEnable_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthBoundsTestEnable_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthBoundsTestEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthBoundsTestEnable_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetDepthBoundsTestEnable_CMockIgnoreArg_depthBoundsTestEnable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthBoundsTestEnable_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthBoundsTestEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthBoundsTestEnable_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_depthBoundsTestEnable = 1; +} + +void vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetStencilTestEnable_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetStencilTestEnable); + cmock_call_instance = (CMOCK_vkCmdSetStencilTestEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetStencilTestEnable_CallInstance); + Mock.vkCmdSetStencilTestEnable_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetStencilTestEnable_CallInstance); + if (Mock.vkCmdSetStencilTestEnable_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetStencilTestEnable_CallbackBool && + Mock.vkCmdSetStencilTestEnable_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetStencilTestEnable_CallbackFunctionPointer(commandBuffer, stencilTestEnable, Mock.vkCmdSetStencilTestEnable_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetStencilTestEnable,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_stencilTestEnable) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetStencilTestEnable,CMockString_stencilTestEnable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_stencilTestEnable), (void*)(&stencilTestEnable), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetStencilTestEnable_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetStencilTestEnable_CallbackFunctionPointer(commandBuffer, stencilTestEnable, Mock.vkCmdSetStencilTestEnable_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetStencilTestEnable(CMOCK_vkCmdSetStencilTestEnable_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable); +void CMockExpectParameters_vkCmdSetStencilTestEnable(CMOCK_vkCmdSetStencilTestEnable_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_stencilTestEnable), (void*)(&stencilTestEnable), + sizeof(VkBool32[sizeof(stencilTestEnable) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_stencilTestEnable = 0; +} + +void vkCmdSetStencilTestEnable_CMockIgnore(void) +{ + Mock.vkCmdSetStencilTestEnable_IgnoreBool = (char)1; +} + +void vkCmdSetStencilTestEnable_CMockStopIgnore(void) +{ + Mock.vkCmdSetStencilTestEnable_IgnoreBool = (char)0; +} + +void vkCmdSetStencilTestEnable_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetStencilTestEnable_CALL_INSTANCE)); + CMOCK_vkCmdSetStencilTestEnable_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilTestEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetStencilTestEnable_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetStencilTestEnable_CallInstance, cmock_guts_index); + Mock.vkCmdSetStencilTestEnable_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetStencilTestEnable_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetStencilTestEnable_CALL_INSTANCE)); + CMOCK_vkCmdSetStencilTestEnable_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilTestEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetStencilTestEnable_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetStencilTestEnable_CallInstance, cmock_guts_index); + Mock.vkCmdSetStencilTestEnable_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetStencilTestEnable(cmock_call_instance, commandBuffer, stencilTestEnable); +} + +void vkCmdSetStencilTestEnable_AddCallback(CMOCK_vkCmdSetStencilTestEnable_CALLBACK Callback) +{ + Mock.vkCmdSetStencilTestEnable_IgnoreBool = (char)0; + Mock.vkCmdSetStencilTestEnable_CallbackBool = (char)1; + Mock.vkCmdSetStencilTestEnable_CallbackFunctionPointer = Callback; +} + +void vkCmdSetStencilTestEnable_Stub(CMOCK_vkCmdSetStencilTestEnable_CALLBACK Callback) +{ + Mock.vkCmdSetStencilTestEnable_IgnoreBool = (char)0; + Mock.vkCmdSetStencilTestEnable_CallbackBool = (char)0; + Mock.vkCmdSetStencilTestEnable_CallbackFunctionPointer = Callback; +} + +void vkCmdSetStencilTestEnable_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetStencilTestEnable_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilTestEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetStencilTestEnable_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetStencilTestEnable_CMockIgnoreArg_stencilTestEnable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetStencilTestEnable_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilTestEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetStencilTestEnable_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stencilTestEnable = 1; +} + +void vkCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetStencilOp_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetStencilOp); + cmock_call_instance = (CMOCK_vkCmdSetStencilOp_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetStencilOp_CallInstance); + Mock.vkCmdSetStencilOp_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetStencilOp_CallInstance); + if (Mock.vkCmdSetStencilOp_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetStencilOp_CallbackBool && + Mock.vkCmdSetStencilOp_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetStencilOp_CallbackFunctionPointer(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp, Mock.vkCmdSetStencilOp_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetStencilOp,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_faceMask) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetStencilOp,CMockString_faceMask); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_faceMask), (void*)(&faceMask), sizeof(VkStencilFaceFlags), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_failOp) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetStencilOp,CMockString_failOp); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_failOp), (void*)(&failOp), sizeof(VkStencilOp), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_passOp) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetStencilOp,CMockString_passOp); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_passOp), (void*)(&passOp), sizeof(VkStencilOp), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_depthFailOp) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetStencilOp,CMockString_depthFailOp); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_depthFailOp), (void*)(&depthFailOp), sizeof(VkStencilOp), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_compareOp) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetStencilOp,CMockString_compareOp); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_compareOp), (void*)(&compareOp), sizeof(VkCompareOp), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetStencilOp_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetStencilOp_CallbackFunctionPointer(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp, Mock.vkCmdSetStencilOp_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetStencilOp(CMOCK_vkCmdSetStencilOp_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp); +void CMockExpectParameters_vkCmdSetStencilOp(CMOCK_vkCmdSetStencilOp_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_faceMask), (void*)(&faceMask), + sizeof(VkStencilFaceFlags[sizeof(faceMask) == sizeof(VkStencilFaceFlags) ? 1 : -1])); /* add VkStencilFaceFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_faceMask = 0; + memcpy((void*)(&cmock_call_instance->Expected_failOp), (void*)(&failOp), + sizeof(VkStencilOp[sizeof(failOp) == sizeof(VkStencilOp) ? 1 : -1])); /* add VkStencilOp to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_failOp = 0; + memcpy((void*)(&cmock_call_instance->Expected_passOp), (void*)(&passOp), + sizeof(VkStencilOp[sizeof(passOp) == sizeof(VkStencilOp) ? 1 : -1])); /* add VkStencilOp to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_passOp = 0; + memcpy((void*)(&cmock_call_instance->Expected_depthFailOp), (void*)(&depthFailOp), + sizeof(VkStencilOp[sizeof(depthFailOp) == sizeof(VkStencilOp) ? 1 : -1])); /* add VkStencilOp to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_depthFailOp = 0; + memcpy((void*)(&cmock_call_instance->Expected_compareOp), (void*)(&compareOp), + sizeof(VkCompareOp[sizeof(compareOp) == sizeof(VkCompareOp) ? 1 : -1])); /* add VkCompareOp to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_compareOp = 0; +} + +void vkCmdSetStencilOp_CMockIgnore(void) +{ + Mock.vkCmdSetStencilOp_IgnoreBool = (char)1; +} + +void vkCmdSetStencilOp_CMockStopIgnore(void) +{ + Mock.vkCmdSetStencilOp_IgnoreBool = (char)0; +} + +void vkCmdSetStencilOp_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetStencilOp_CALL_INSTANCE)); + CMOCK_vkCmdSetStencilOp_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilOp_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetStencilOp_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetStencilOp_CallInstance, cmock_guts_index); + Mock.vkCmdSetStencilOp_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetStencilOp_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetStencilOp_CALL_INSTANCE)); + CMOCK_vkCmdSetStencilOp_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilOp_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetStencilOp_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetStencilOp_CallInstance, cmock_guts_index); + Mock.vkCmdSetStencilOp_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetStencilOp(cmock_call_instance, commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); +} + +void vkCmdSetStencilOp_AddCallback(CMOCK_vkCmdSetStencilOp_CALLBACK Callback) +{ + Mock.vkCmdSetStencilOp_IgnoreBool = (char)0; + Mock.vkCmdSetStencilOp_CallbackBool = (char)1; + Mock.vkCmdSetStencilOp_CallbackFunctionPointer = Callback; +} + +void vkCmdSetStencilOp_Stub(CMOCK_vkCmdSetStencilOp_CALLBACK Callback) +{ + Mock.vkCmdSetStencilOp_IgnoreBool = (char)0; + Mock.vkCmdSetStencilOp_CallbackBool = (char)0; + Mock.vkCmdSetStencilOp_CallbackFunctionPointer = Callback; +} + +void vkCmdSetStencilOp_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetStencilOp_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilOp_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetStencilOp_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetStencilOp_CMockIgnoreArg_faceMask(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetStencilOp_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilOp_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetStencilOp_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_faceMask = 1; +} + +void vkCmdSetStencilOp_CMockIgnoreArg_failOp(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetStencilOp_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilOp_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetStencilOp_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_failOp = 1; +} + +void vkCmdSetStencilOp_CMockIgnoreArg_passOp(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetStencilOp_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilOp_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetStencilOp_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_passOp = 1; +} + +void vkCmdSetStencilOp_CMockIgnoreArg_depthFailOp(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetStencilOp_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilOp_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetStencilOp_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_depthFailOp = 1; +} + +void vkCmdSetStencilOp_CMockIgnoreArg_compareOp(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetStencilOp_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilOp_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetStencilOp_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_compareOp = 1; +} + +void vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetRasterizerDiscardEnable_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetRasterizerDiscardEnable); + cmock_call_instance = (CMOCK_vkCmdSetRasterizerDiscardEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetRasterizerDiscardEnable_CallInstance); + Mock.vkCmdSetRasterizerDiscardEnable_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetRasterizerDiscardEnable_CallInstance); + if (Mock.vkCmdSetRasterizerDiscardEnable_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetRasterizerDiscardEnable_CallbackBool && + Mock.vkCmdSetRasterizerDiscardEnable_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetRasterizerDiscardEnable_CallbackFunctionPointer(commandBuffer, rasterizerDiscardEnable, Mock.vkCmdSetRasterizerDiscardEnable_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetRasterizerDiscardEnable,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_rasterizerDiscardEnable) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetRasterizerDiscardEnable,CMockString_rasterizerDiscardEnable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_rasterizerDiscardEnable), (void*)(&rasterizerDiscardEnable), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetRasterizerDiscardEnable_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetRasterizerDiscardEnable_CallbackFunctionPointer(commandBuffer, rasterizerDiscardEnable, Mock.vkCmdSetRasterizerDiscardEnable_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetRasterizerDiscardEnable(CMOCK_vkCmdSetRasterizerDiscardEnable_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); +void CMockExpectParameters_vkCmdSetRasterizerDiscardEnable(CMOCK_vkCmdSetRasterizerDiscardEnable_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_rasterizerDiscardEnable), (void*)(&rasterizerDiscardEnable), + sizeof(VkBool32[sizeof(rasterizerDiscardEnable) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_rasterizerDiscardEnable = 0; +} + +void vkCmdSetRasterizerDiscardEnable_CMockIgnore(void) +{ + Mock.vkCmdSetRasterizerDiscardEnable_IgnoreBool = (char)1; +} + +void vkCmdSetRasterizerDiscardEnable_CMockStopIgnore(void) +{ + Mock.vkCmdSetRasterizerDiscardEnable_IgnoreBool = (char)0; +} + +void vkCmdSetRasterizerDiscardEnable_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetRasterizerDiscardEnable_CALL_INSTANCE)); + CMOCK_vkCmdSetRasterizerDiscardEnable_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetRasterizerDiscardEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetRasterizerDiscardEnable_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetRasterizerDiscardEnable_CallInstance, cmock_guts_index); + Mock.vkCmdSetRasterizerDiscardEnable_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetRasterizerDiscardEnable_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetRasterizerDiscardEnable_CALL_INSTANCE)); + CMOCK_vkCmdSetRasterizerDiscardEnable_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetRasterizerDiscardEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetRasterizerDiscardEnable_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetRasterizerDiscardEnable_CallInstance, cmock_guts_index); + Mock.vkCmdSetRasterizerDiscardEnable_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetRasterizerDiscardEnable(cmock_call_instance, commandBuffer, rasterizerDiscardEnable); +} + +void vkCmdSetRasterizerDiscardEnable_AddCallback(CMOCK_vkCmdSetRasterizerDiscardEnable_CALLBACK Callback) +{ + Mock.vkCmdSetRasterizerDiscardEnable_IgnoreBool = (char)0; + Mock.vkCmdSetRasterizerDiscardEnable_CallbackBool = (char)1; + Mock.vkCmdSetRasterizerDiscardEnable_CallbackFunctionPointer = Callback; +} + +void vkCmdSetRasterizerDiscardEnable_Stub(CMOCK_vkCmdSetRasterizerDiscardEnable_CALLBACK Callback) +{ + Mock.vkCmdSetRasterizerDiscardEnable_IgnoreBool = (char)0; + Mock.vkCmdSetRasterizerDiscardEnable_CallbackBool = (char)0; + Mock.vkCmdSetRasterizerDiscardEnable_CallbackFunctionPointer = Callback; +} + +void vkCmdSetRasterizerDiscardEnable_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetRasterizerDiscardEnable_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetRasterizerDiscardEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetRasterizerDiscardEnable_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetRasterizerDiscardEnable_CMockIgnoreArg_rasterizerDiscardEnable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetRasterizerDiscardEnable_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetRasterizerDiscardEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetRasterizerDiscardEnable_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_rasterizerDiscardEnable = 1; +} + +void vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetDepthBiasEnable_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetDepthBiasEnable); + cmock_call_instance = (CMOCK_vkCmdSetDepthBiasEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetDepthBiasEnable_CallInstance); + Mock.vkCmdSetDepthBiasEnable_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetDepthBiasEnable_CallInstance); + if (Mock.vkCmdSetDepthBiasEnable_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetDepthBiasEnable_CallbackBool && + Mock.vkCmdSetDepthBiasEnable_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDepthBiasEnable_CallbackFunctionPointer(commandBuffer, depthBiasEnable, Mock.vkCmdSetDepthBiasEnable_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthBiasEnable,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_depthBiasEnable) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthBiasEnable,CMockString_depthBiasEnable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_depthBiasEnable), (void*)(&depthBiasEnable), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetDepthBiasEnable_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDepthBiasEnable_CallbackFunctionPointer(commandBuffer, depthBiasEnable, Mock.vkCmdSetDepthBiasEnable_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetDepthBiasEnable(CMOCK_vkCmdSetDepthBiasEnable_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable); +void CMockExpectParameters_vkCmdSetDepthBiasEnable(CMOCK_vkCmdSetDepthBiasEnable_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_depthBiasEnable), (void*)(&depthBiasEnable), + sizeof(VkBool32[sizeof(depthBiasEnable) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_depthBiasEnable = 0; +} + +void vkCmdSetDepthBiasEnable_CMockIgnore(void) +{ + Mock.vkCmdSetDepthBiasEnable_IgnoreBool = (char)1; +} + +void vkCmdSetDepthBiasEnable_CMockStopIgnore(void) +{ + Mock.vkCmdSetDepthBiasEnable_IgnoreBool = (char)0; +} + +void vkCmdSetDepthBiasEnable_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDepthBiasEnable_CALL_INSTANCE)); + CMOCK_vkCmdSetDepthBiasEnable_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthBiasEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDepthBiasEnable_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDepthBiasEnable_CallInstance, cmock_guts_index); + Mock.vkCmdSetDepthBiasEnable_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetDepthBiasEnable_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDepthBiasEnable_CALL_INSTANCE)); + CMOCK_vkCmdSetDepthBiasEnable_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthBiasEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDepthBiasEnable_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDepthBiasEnable_CallInstance, cmock_guts_index); + Mock.vkCmdSetDepthBiasEnable_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetDepthBiasEnable(cmock_call_instance, commandBuffer, depthBiasEnable); +} + +void vkCmdSetDepthBiasEnable_AddCallback(CMOCK_vkCmdSetDepthBiasEnable_CALLBACK Callback) +{ + Mock.vkCmdSetDepthBiasEnable_IgnoreBool = (char)0; + Mock.vkCmdSetDepthBiasEnable_CallbackBool = (char)1; + Mock.vkCmdSetDepthBiasEnable_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDepthBiasEnable_Stub(CMOCK_vkCmdSetDepthBiasEnable_CALLBACK Callback) +{ + Mock.vkCmdSetDepthBiasEnable_IgnoreBool = (char)0; + Mock.vkCmdSetDepthBiasEnable_CallbackBool = (char)0; + Mock.vkCmdSetDepthBiasEnable_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDepthBiasEnable_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthBiasEnable_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthBiasEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthBiasEnable_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetDepthBiasEnable_CMockIgnoreArg_depthBiasEnable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthBiasEnable_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthBiasEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthBiasEnable_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_depthBiasEnable = 1; +} + +void vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetPrimitiveRestartEnable_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetPrimitiveRestartEnable); + cmock_call_instance = (CMOCK_vkCmdSetPrimitiveRestartEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetPrimitiveRestartEnable_CallInstance); + Mock.vkCmdSetPrimitiveRestartEnable_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetPrimitiveRestartEnable_CallInstance); + if (Mock.vkCmdSetPrimitiveRestartEnable_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetPrimitiveRestartEnable_CallbackBool && + Mock.vkCmdSetPrimitiveRestartEnable_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetPrimitiveRestartEnable_CallbackFunctionPointer(commandBuffer, primitiveRestartEnable, Mock.vkCmdSetPrimitiveRestartEnable_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetPrimitiveRestartEnable,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_primitiveRestartEnable) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetPrimitiveRestartEnable,CMockString_primitiveRestartEnable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_primitiveRestartEnable), (void*)(&primitiveRestartEnable), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetPrimitiveRestartEnable_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetPrimitiveRestartEnable_CallbackFunctionPointer(commandBuffer, primitiveRestartEnable, Mock.vkCmdSetPrimitiveRestartEnable_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetPrimitiveRestartEnable(CMOCK_vkCmdSetPrimitiveRestartEnable_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); +void CMockExpectParameters_vkCmdSetPrimitiveRestartEnable(CMOCK_vkCmdSetPrimitiveRestartEnable_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_primitiveRestartEnable), (void*)(&primitiveRestartEnable), + sizeof(VkBool32[sizeof(primitiveRestartEnable) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_primitiveRestartEnable = 0; +} + +void vkCmdSetPrimitiveRestartEnable_CMockIgnore(void) +{ + Mock.vkCmdSetPrimitiveRestartEnable_IgnoreBool = (char)1; +} + +void vkCmdSetPrimitiveRestartEnable_CMockStopIgnore(void) +{ + Mock.vkCmdSetPrimitiveRestartEnable_IgnoreBool = (char)0; +} + +void vkCmdSetPrimitiveRestartEnable_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetPrimitiveRestartEnable_CALL_INSTANCE)); + CMOCK_vkCmdSetPrimitiveRestartEnable_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPrimitiveRestartEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetPrimitiveRestartEnable_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetPrimitiveRestartEnable_CallInstance, cmock_guts_index); + Mock.vkCmdSetPrimitiveRestartEnable_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetPrimitiveRestartEnable_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetPrimitiveRestartEnable_CALL_INSTANCE)); + CMOCK_vkCmdSetPrimitiveRestartEnable_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPrimitiveRestartEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetPrimitiveRestartEnable_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetPrimitiveRestartEnable_CallInstance, cmock_guts_index); + Mock.vkCmdSetPrimitiveRestartEnable_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetPrimitiveRestartEnable(cmock_call_instance, commandBuffer, primitiveRestartEnable); +} + +void vkCmdSetPrimitiveRestartEnable_AddCallback(CMOCK_vkCmdSetPrimitiveRestartEnable_CALLBACK Callback) +{ + Mock.vkCmdSetPrimitiveRestartEnable_IgnoreBool = (char)0; + Mock.vkCmdSetPrimitiveRestartEnable_CallbackBool = (char)1; + Mock.vkCmdSetPrimitiveRestartEnable_CallbackFunctionPointer = Callback; +} + +void vkCmdSetPrimitiveRestartEnable_Stub(CMOCK_vkCmdSetPrimitiveRestartEnable_CALLBACK Callback) +{ + Mock.vkCmdSetPrimitiveRestartEnable_IgnoreBool = (char)0; + Mock.vkCmdSetPrimitiveRestartEnable_CallbackBool = (char)0; + Mock.vkCmdSetPrimitiveRestartEnable_CallbackFunctionPointer = Callback; +} + +void vkCmdSetPrimitiveRestartEnable_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetPrimitiveRestartEnable_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPrimitiveRestartEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetPrimitiveRestartEnable_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetPrimitiveRestartEnable_CMockIgnoreArg_primitiveRestartEnable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetPrimitiveRestartEnable_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPrimitiveRestartEnable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetPrimitiveRestartEnable_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_primitiveRestartEnable = 1; +} + +void vkGetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDeviceBufferMemoryRequirements_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDeviceBufferMemoryRequirements); + cmock_call_instance = (CMOCK_vkGetDeviceBufferMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDeviceBufferMemoryRequirements_CallInstance); + Mock.vkGetDeviceBufferMemoryRequirements_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeviceBufferMemoryRequirements_CallInstance); + if (Mock.vkGetDeviceBufferMemoryRequirements_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetDeviceBufferMemoryRequirements_CallbackBool && + Mock.vkGetDeviceBufferMemoryRequirements_CallbackFunctionPointer != NULL) + { + Mock.vkGetDeviceBufferMemoryRequirements_CallbackFunctionPointer(device, pInfo, pMemoryRequirements, Mock.vkGetDeviceBufferMemoryRequirements_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceBufferMemoryRequirements,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceBufferMemoryRequirements,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkDeviceBufferMemoryRequirements), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMemoryRequirements) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceBufferMemoryRequirements,CMockString_pMemoryRequirements); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMemoryRequirements), (void*)(pMemoryRequirements), sizeof(VkMemoryRequirements2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDeviceBufferMemoryRequirements_CallbackFunctionPointer != NULL) + { + Mock.vkGetDeviceBufferMemoryRequirements_CallbackFunctionPointer(device, pInfo, pMemoryRequirements, Mock.vkGetDeviceBufferMemoryRequirements_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pMemoryRequirements, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pMemoryRequirements, (const void*)cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Val, + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetDeviceBufferMemoryRequirements(CMOCK_vkGetDeviceBufferMemoryRequirements_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +void CMockExpectParameters_vkGetDeviceBufferMemoryRequirements(CMOCK_vkGetDeviceBufferMemoryRequirements_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; + cmock_call_instance->Expected_pMemoryRequirements = pMemoryRequirements; + cmock_call_instance->IgnoreArg_pMemoryRequirements = 0; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used = 0; +} + +void vkGetDeviceBufferMemoryRequirements_CMockIgnore(void) +{ + Mock.vkGetDeviceBufferMemoryRequirements_IgnoreBool = (char)1; +} + +void vkGetDeviceBufferMemoryRequirements_CMockStopIgnore(void) +{ + Mock.vkGetDeviceBufferMemoryRequirements_IgnoreBool = (char)0; +} + +void vkGetDeviceBufferMemoryRequirements_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceBufferMemoryRequirements_CALL_INSTANCE)); + CMOCK_vkGetDeviceBufferMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceBufferMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceBufferMemoryRequirements_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceBufferMemoryRequirements_CallInstance, cmock_guts_index); + Mock.vkGetDeviceBufferMemoryRequirements_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDeviceBufferMemoryRequirements_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceBufferMemoryRequirements_CALL_INSTANCE)); + CMOCK_vkGetDeviceBufferMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceBufferMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceBufferMemoryRequirements_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceBufferMemoryRequirements_CallInstance, cmock_guts_index); + Mock.vkGetDeviceBufferMemoryRequirements_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDeviceBufferMemoryRequirements(cmock_call_instance, device, pInfo, pMemoryRequirements); +} + +void vkGetDeviceBufferMemoryRequirements_AddCallback(CMOCK_vkGetDeviceBufferMemoryRequirements_CALLBACK Callback) +{ + Mock.vkGetDeviceBufferMemoryRequirements_IgnoreBool = (char)0; + Mock.vkGetDeviceBufferMemoryRequirements_CallbackBool = (char)1; + Mock.vkGetDeviceBufferMemoryRequirements_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceBufferMemoryRequirements_Stub(CMOCK_vkGetDeviceBufferMemoryRequirements_CALLBACK Callback) +{ + Mock.vkGetDeviceBufferMemoryRequirements_IgnoreBool = (char)0; + Mock.vkGetDeviceBufferMemoryRequirements_CallbackBool = (char)0; + Mock.vkGetDeviceBufferMemoryRequirements_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceBufferMemoryRequirements_CMockReturnMemThruPtr_pMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkMemoryRequirements2 const* pMemoryRequirements, size_t cmock_size) +{ + CMOCK_vkGetDeviceBufferMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceBufferMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceBufferMemoryRequirements_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used = 1; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Val = pMemoryRequirements; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Size = cmock_size; +} + +void vkGetDeviceBufferMemoryRequirements_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceBufferMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceBufferMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceBufferMemoryRequirements_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetDeviceBufferMemoryRequirements_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceBufferMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceBufferMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceBufferMemoryRequirements_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +void vkGetDeviceBufferMemoryRequirements_CMockIgnoreArg_pMemoryRequirements(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceBufferMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceBufferMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceBufferMemoryRequirements_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMemoryRequirements = 1; +} + +void vkGetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDeviceImageMemoryRequirements_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDeviceImageMemoryRequirements); + cmock_call_instance = (CMOCK_vkGetDeviceImageMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDeviceImageMemoryRequirements_CallInstance); + Mock.vkGetDeviceImageMemoryRequirements_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeviceImageMemoryRequirements_CallInstance); + if (Mock.vkGetDeviceImageMemoryRequirements_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetDeviceImageMemoryRequirements_CallbackBool && + Mock.vkGetDeviceImageMemoryRequirements_CallbackFunctionPointer != NULL) + { + Mock.vkGetDeviceImageMemoryRequirements_CallbackFunctionPointer(device, pInfo, pMemoryRequirements, Mock.vkGetDeviceImageMemoryRequirements_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceImageMemoryRequirements,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceImageMemoryRequirements,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkDeviceImageMemoryRequirements), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMemoryRequirements) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceImageMemoryRequirements,CMockString_pMemoryRequirements); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMemoryRequirements), (void*)(pMemoryRequirements), sizeof(VkMemoryRequirements2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDeviceImageMemoryRequirements_CallbackFunctionPointer != NULL) + { + Mock.vkGetDeviceImageMemoryRequirements_CallbackFunctionPointer(device, pInfo, pMemoryRequirements, Mock.vkGetDeviceImageMemoryRequirements_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pMemoryRequirements, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pMemoryRequirements, (const void*)cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Val, + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetDeviceImageMemoryRequirements(CMOCK_vkGetDeviceImageMemoryRequirements_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +void CMockExpectParameters_vkGetDeviceImageMemoryRequirements(CMOCK_vkGetDeviceImageMemoryRequirements_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; + cmock_call_instance->Expected_pMemoryRequirements = pMemoryRequirements; + cmock_call_instance->IgnoreArg_pMemoryRequirements = 0; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used = 0; +} + +void vkGetDeviceImageMemoryRequirements_CMockIgnore(void) +{ + Mock.vkGetDeviceImageMemoryRequirements_IgnoreBool = (char)1; +} + +void vkGetDeviceImageMemoryRequirements_CMockStopIgnore(void) +{ + Mock.vkGetDeviceImageMemoryRequirements_IgnoreBool = (char)0; +} + +void vkGetDeviceImageMemoryRequirements_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceImageMemoryRequirements_CALL_INSTANCE)); + CMOCK_vkGetDeviceImageMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceImageMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceImageMemoryRequirements_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceImageMemoryRequirements_CallInstance, cmock_guts_index); + Mock.vkGetDeviceImageMemoryRequirements_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDeviceImageMemoryRequirements_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceImageMemoryRequirements_CALL_INSTANCE)); + CMOCK_vkGetDeviceImageMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceImageMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceImageMemoryRequirements_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceImageMemoryRequirements_CallInstance, cmock_guts_index); + Mock.vkGetDeviceImageMemoryRequirements_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDeviceImageMemoryRequirements(cmock_call_instance, device, pInfo, pMemoryRequirements); +} + +void vkGetDeviceImageMemoryRequirements_AddCallback(CMOCK_vkGetDeviceImageMemoryRequirements_CALLBACK Callback) +{ + Mock.vkGetDeviceImageMemoryRequirements_IgnoreBool = (char)0; + Mock.vkGetDeviceImageMemoryRequirements_CallbackBool = (char)1; + Mock.vkGetDeviceImageMemoryRequirements_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceImageMemoryRequirements_Stub(CMOCK_vkGetDeviceImageMemoryRequirements_CALLBACK Callback) +{ + Mock.vkGetDeviceImageMemoryRequirements_IgnoreBool = (char)0; + Mock.vkGetDeviceImageMemoryRequirements_CallbackBool = (char)0; + Mock.vkGetDeviceImageMemoryRequirements_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceImageMemoryRequirements_CMockReturnMemThruPtr_pMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkMemoryRequirements2 const* pMemoryRequirements, size_t cmock_size) +{ + CMOCK_vkGetDeviceImageMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceImageMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceImageMemoryRequirements_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used = 1; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Val = pMemoryRequirements; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Size = cmock_size; +} + +void vkGetDeviceImageMemoryRequirements_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceImageMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceImageMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceImageMemoryRequirements_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetDeviceImageMemoryRequirements_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceImageMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceImageMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceImageMemoryRequirements_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +void vkGetDeviceImageMemoryRequirements_CMockIgnoreArg_pMemoryRequirements(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceImageMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceImageMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceImageMemoryRequirements_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMemoryRequirements = 1; +} + +void vkGetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDeviceImageSparseMemoryRequirements_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDeviceImageSparseMemoryRequirements); + cmock_call_instance = (CMOCK_vkGetDeviceImageSparseMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDeviceImageSparseMemoryRequirements_CallInstance); + Mock.vkGetDeviceImageSparseMemoryRequirements_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeviceImageSparseMemoryRequirements_CallInstance); + if (Mock.vkGetDeviceImageSparseMemoryRequirements_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetDeviceImageSparseMemoryRequirements_CallbackBool && + Mock.vkGetDeviceImageSparseMemoryRequirements_CallbackFunctionPointer != NULL) + { + Mock.vkGetDeviceImageSparseMemoryRequirements_CallbackFunctionPointer(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, Mock.vkGetDeviceImageSparseMemoryRequirements_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceImageSparseMemoryRequirements,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceImageSparseMemoryRequirements,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkDeviceImageMemoryRequirements), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSparseMemoryRequirementCount) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceImageSparseMemoryRequirements,CMockString_pSparseMemoryRequirementCount); + if (cmock_call_instance->Expected_pSparseMemoryRequirementCount == NULL) + { UNITY_TEST_ASSERT_NULL(pSparseMemoryRequirementCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pSparseMemoryRequirementCount, pSparseMemoryRequirementCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pSparseMemoryRequirements) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceImageSparseMemoryRequirements,CMockString_pSparseMemoryRequirements); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSparseMemoryRequirements), (void*)(pSparseMemoryRequirements), sizeof(VkSparseImageMemoryRequirements2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDeviceImageSparseMemoryRequirements_CallbackFunctionPointer != NULL) + { + Mock.vkGetDeviceImageSparseMemoryRequirements_CallbackFunctionPointer(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, Mock.vkGetDeviceImageSparseMemoryRequirements_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSparseMemoryRequirementCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSparseMemoryRequirementCount, (const void*)cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Val, + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSparseMemoryRequirements, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSparseMemoryRequirements, (const void*)cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Val, + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetDeviceImageSparseMemoryRequirements(CMOCK_vkGetDeviceImageSparseMemoryRequirements_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +void CMockExpectParameters_vkGetDeviceImageSparseMemoryRequirements(CMOCK_vkGetDeviceImageSparseMemoryRequirements_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; + cmock_call_instance->Expected_pSparseMemoryRequirementCount = pSparseMemoryRequirementCount; + cmock_call_instance->IgnoreArg_pSparseMemoryRequirementCount = 0; + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Used = 0; + cmock_call_instance->Expected_pSparseMemoryRequirements = pSparseMemoryRequirements; + cmock_call_instance->IgnoreArg_pSparseMemoryRequirements = 0; + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Used = 0; +} + +void vkGetDeviceImageSparseMemoryRequirements_CMockIgnore(void) +{ + Mock.vkGetDeviceImageSparseMemoryRequirements_IgnoreBool = (char)1; +} + +void vkGetDeviceImageSparseMemoryRequirements_CMockStopIgnore(void) +{ + Mock.vkGetDeviceImageSparseMemoryRequirements_IgnoreBool = (char)0; +} + +void vkGetDeviceImageSparseMemoryRequirements_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceImageSparseMemoryRequirements_CALL_INSTANCE)); + CMOCK_vkGetDeviceImageSparseMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceImageSparseMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceImageSparseMemoryRequirements_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceImageSparseMemoryRequirements_CallInstance, cmock_guts_index); + Mock.vkGetDeviceImageSparseMemoryRequirements_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDeviceImageSparseMemoryRequirements_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceImageSparseMemoryRequirements_CALL_INSTANCE)); + CMOCK_vkGetDeviceImageSparseMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceImageSparseMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceImageSparseMemoryRequirements_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceImageSparseMemoryRequirements_CallInstance, cmock_guts_index); + Mock.vkGetDeviceImageSparseMemoryRequirements_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDeviceImageSparseMemoryRequirements(cmock_call_instance, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); +} + +void vkGetDeviceImageSparseMemoryRequirements_AddCallback(CMOCK_vkGetDeviceImageSparseMemoryRequirements_CALLBACK Callback) +{ + Mock.vkGetDeviceImageSparseMemoryRequirements_IgnoreBool = (char)0; + Mock.vkGetDeviceImageSparseMemoryRequirements_CallbackBool = (char)1; + Mock.vkGetDeviceImageSparseMemoryRequirements_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceImageSparseMemoryRequirements_Stub(CMOCK_vkGetDeviceImageSparseMemoryRequirements_CALLBACK Callback) +{ + Mock.vkGetDeviceImageSparseMemoryRequirements_IgnoreBool = (char)0; + Mock.vkGetDeviceImageSparseMemoryRequirements_CallbackBool = (char)0; + Mock.vkGetDeviceImageSparseMemoryRequirements_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceImageSparseMemoryRequirements_CMockReturnMemThruPtr_pSparseMemoryRequirementCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pSparseMemoryRequirementCount, size_t cmock_size) +{ + CMOCK_vkGetDeviceImageSparseMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceImageSparseMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceImageSparseMemoryRequirements_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Val = pSparseMemoryRequirementCount; + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Size = cmock_size; +} + +void vkGetDeviceImageSparseMemoryRequirements_CMockReturnMemThruPtr_pSparseMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkSparseImageMemoryRequirements2 const* pSparseMemoryRequirements, size_t cmock_size) +{ + CMOCK_vkGetDeviceImageSparseMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceImageSparseMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceImageSparseMemoryRequirements_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Used = 1; + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Val = pSparseMemoryRequirements; + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Size = cmock_size; +} + +void vkGetDeviceImageSparseMemoryRequirements_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceImageSparseMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceImageSparseMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceImageSparseMemoryRequirements_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetDeviceImageSparseMemoryRequirements_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceImageSparseMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceImageSparseMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceImageSparseMemoryRequirements_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +void vkGetDeviceImageSparseMemoryRequirements_CMockIgnoreArg_pSparseMemoryRequirementCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceImageSparseMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceImageSparseMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceImageSparseMemoryRequirements_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSparseMemoryRequirementCount = 1; +} + +void vkGetDeviceImageSparseMemoryRequirements_CMockIgnoreArg_pSparseMemoryRequirements(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceImageSparseMemoryRequirements_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceImageSparseMemoryRequirements_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceImageSparseMemoryRequirements_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSparseMemoryRequirements = 1; +} + +void vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroySurfaceKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroySurfaceKHR); + cmock_call_instance = (CMOCK_vkDestroySurfaceKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroySurfaceKHR_CallInstance); + Mock.vkDestroySurfaceKHR_CallInstance = CMock_Guts_MemNext(Mock.vkDestroySurfaceKHR_CallInstance); + if (Mock.vkDestroySurfaceKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroySurfaceKHR_CallbackBool && + Mock.vkDestroySurfaceKHR_CallbackFunctionPointer != NULL) + { + Mock.vkDestroySurfaceKHR_CallbackFunctionPointer(instance, surface, pAllocator, Mock.vkDestroySurfaceKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_instance) + { + UNITY_SET_DETAILS(CMockString_vkDestroySurfaceKHR,CMockString_instance); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), sizeof(VkInstance), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_surface) + { + UNITY_SET_DETAILS(CMockString_vkDestroySurfaceKHR,CMockString_surface); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_surface), (void*)(&surface), sizeof(VkSurfaceKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroySurfaceKHR,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroySurfaceKHR_CallbackFunctionPointer != NULL) + { + Mock.vkDestroySurfaceKHR_CallbackFunctionPointer(instance, surface, pAllocator, Mock.vkDestroySurfaceKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroySurfaceKHR(CMOCK_vkDestroySurfaceKHR_CALL_INSTANCE* cmock_call_instance, VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroySurfaceKHR(CMOCK_vkDestroySurfaceKHR_CALL_INSTANCE* cmock_call_instance, VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), + sizeof(VkInstance[sizeof(instance) == sizeof(VkInstance) ? 1 : -1])); /* add VkInstance to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_instance = 0; + memcpy((void*)(&cmock_call_instance->Expected_surface), (void*)(&surface), + sizeof(VkSurfaceKHR[sizeof(surface) == sizeof(VkSurfaceKHR) ? 1 : -1])); /* add VkSurfaceKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_surface = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroySurfaceKHR_CMockIgnore(void) +{ + Mock.vkDestroySurfaceKHR_IgnoreBool = (char)1; +} + +void vkDestroySurfaceKHR_CMockStopIgnore(void) +{ + Mock.vkDestroySurfaceKHR_IgnoreBool = (char)0; +} + +void vkDestroySurfaceKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroySurfaceKHR_CALL_INSTANCE)); + CMOCK_vkDestroySurfaceKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroySurfaceKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroySurfaceKHR_CallInstance = CMock_Guts_MemChain(Mock.vkDestroySurfaceKHR_CallInstance, cmock_guts_index); + Mock.vkDestroySurfaceKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroySurfaceKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroySurfaceKHR_CALL_INSTANCE)); + CMOCK_vkDestroySurfaceKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroySurfaceKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroySurfaceKHR_CallInstance = CMock_Guts_MemChain(Mock.vkDestroySurfaceKHR_CallInstance, cmock_guts_index); + Mock.vkDestroySurfaceKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroySurfaceKHR(cmock_call_instance, instance, surface, pAllocator); +} + +void vkDestroySurfaceKHR_AddCallback(CMOCK_vkDestroySurfaceKHR_CALLBACK Callback) +{ + Mock.vkDestroySurfaceKHR_IgnoreBool = (char)0; + Mock.vkDestroySurfaceKHR_CallbackBool = (char)1; + Mock.vkDestroySurfaceKHR_CallbackFunctionPointer = Callback; +} + +void vkDestroySurfaceKHR_Stub(CMOCK_vkDestroySurfaceKHR_CALLBACK Callback) +{ + Mock.vkDestroySurfaceKHR_IgnoreBool = (char)0; + Mock.vkDestroySurfaceKHR_CallbackBool = (char)0; + Mock.vkDestroySurfaceKHR_CallbackFunctionPointer = Callback; +} + +void vkDestroySurfaceKHR_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroySurfaceKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroySurfaceKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroySurfaceKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_instance = 1; +} + +void vkDestroySurfaceKHR_CMockIgnoreArg_surface(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroySurfaceKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroySurfaceKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroySurfaceKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_surface = 1; +} + +void vkDestroySurfaceKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroySurfaceKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroySurfaceKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroySurfaceKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceSurfaceSupportKHR); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceSurfaceSupportKHR_CallInstance); + Mock.vkGetPhysicalDeviceSurfaceSupportKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceSurfaceSupportKHR_CallInstance); + if (Mock.vkGetPhysicalDeviceSurfaceSupportKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPhysicalDeviceSurfaceSupportKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetPhysicalDeviceSurfaceSupportKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPhysicalDeviceSurfaceSupportKHR_CallbackBool && + Mock.vkGetPhysicalDeviceSurfaceSupportKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPhysicalDeviceSurfaceSupportKHR_CallbackFunctionPointer(physicalDevice, queueFamilyIndex, surface, pSupported, Mock.vkGetPhysicalDeviceSurfaceSupportKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSurfaceSupportKHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queueFamilyIndex) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSurfaceSupportKHR,CMockString_queueFamilyIndex); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_queueFamilyIndex, queueFamilyIndex, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_surface) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSurfaceSupportKHR,CMockString_surface); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_surface), (void*)(&surface), sizeof(VkSurfaceKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSupported) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSurfaceSupportKHR,CMockString_pSupported); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSupported), (void*)(pSupported), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceSurfaceSupportKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPhysicalDeviceSurfaceSupportKHR_CallbackFunctionPointer(physicalDevice, queueFamilyIndex, surface, pSupported, Mock.vkGetPhysicalDeviceSurfaceSupportKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pSupported_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSupported, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSupported, (const void*)cmock_call_instance->ReturnThruPtr_pSupported_Val, + cmock_call_instance->ReturnThruPtr_pSupported_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPhysicalDeviceSurfaceSupportKHR(CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported); +void CMockExpectParameters_vkGetPhysicalDeviceSurfaceSupportKHR(CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_queueFamilyIndex = queueFamilyIndex; + cmock_call_instance->IgnoreArg_queueFamilyIndex = 0; + memcpy((void*)(&cmock_call_instance->Expected_surface), (void*)(&surface), + sizeof(VkSurfaceKHR[sizeof(surface) == sizeof(VkSurfaceKHR) ? 1 : -1])); /* add VkSurfaceKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_surface = 0; + cmock_call_instance->Expected_pSupported = pSupported; + cmock_call_instance->IgnoreArg_pSupported = 0; + cmock_call_instance->ReturnThruPtr_pSupported_Used = 0; +} + +void vkGetPhysicalDeviceSurfaceSupportKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceSurfaceSupportKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceSurfaceSupportKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceSurfaceSupportKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPhysicalDeviceSurfaceSupportKHR_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceSurfaceSupportKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetPhysicalDeviceSurfaceSupportKHR_IgnoreBool) + Mock.vkGetPhysicalDeviceSurfaceSupportKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceSurfaceSupportKHR_CallInstance); + Mock.vkGetPhysicalDeviceSurfaceSupportKHR_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceSurfaceSupportKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceSurfaceSupportKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceSurfaceSupportKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceSurfaceSupportKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceSurfaceSupportKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceSurfaceSupportKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceSurfaceSupportKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceSurfaceSupportKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceSurfaceSupportKHR(cmock_call_instance, physicalDevice, queueFamilyIndex, surface, pSupported); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPhysicalDeviceSurfaceSupportKHR_AddCallback(CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceSurfaceSupportKHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceSurfaceSupportKHR_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceSurfaceSupportKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceSurfaceSupportKHR_Stub(CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceSurfaceSupportKHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceSurfaceSupportKHR_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceSurfaceSupportKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceSurfaceSupportKHR_CMockReturnMemThruPtr_pSupported(UNITY_LINE_TYPE cmock_line, VkBool32 const* pSupported, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfaceSupportKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSupported_Used = 1; + cmock_call_instance->ReturnThruPtr_pSupported_Val = pSupported; + cmock_call_instance->ReturnThruPtr_pSupported_Size = cmock_size; +} + +void vkGetPhysicalDeviceSurfaceSupportKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfaceSupportKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceSurfaceSupportKHR_CMockIgnoreArg_queueFamilyIndex(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfaceSupportKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queueFamilyIndex = 1; +} + +void vkGetPhysicalDeviceSurfaceSupportKHR_CMockIgnoreArg_surface(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfaceSupportKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_surface = 1; +} + +void vkGetPhysicalDeviceSurfaceSupportKHR_CMockIgnoreArg_pSupported(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfaceSupportKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSupported = 1; +} + +VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceSurfaceCapabilitiesKHR); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallInstance); + Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallInstance); + if (Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallbackBool && + Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallbackFunctionPointer(physicalDevice, surface, pSurfaceCapabilities, Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSurfaceCapabilitiesKHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_surface) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSurfaceCapabilitiesKHR,CMockString_surface); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_surface), (void*)(&surface), sizeof(VkSurfaceKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSurfaceCapabilities) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSurfaceCapabilitiesKHR,CMockString_pSurfaceCapabilities); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSurfaceCapabilities), (void*)(pSurfaceCapabilities), sizeof(VkSurfaceCapabilitiesKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallbackFunctionPointer(physicalDevice, surface, pSurfaceCapabilities, Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pSurfaceCapabilities_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSurfaceCapabilities, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSurfaceCapabilities, (const void*)cmock_call_instance->ReturnThruPtr_pSurfaceCapabilities_Val, + cmock_call_instance->ReturnThruPtr_pSurfaceCapabilities_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(CMOCK_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); +void CMockExpectParameters_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(CMOCK_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + memcpy((void*)(&cmock_call_instance->Expected_surface), (void*)(&surface), + sizeof(VkSurfaceKHR[sizeof(surface) == sizeof(VkSurfaceKHR) ? 1 : -1])); /* add VkSurfaceKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_surface = 0; + cmock_call_instance->Expected_pSurfaceCapabilities = pSurfaceCapabilities; + cmock_call_instance->IgnoreArg_pSurfaceCapabilities = 0; + cmock_call_instance->ReturnThruPtr_pSurfaceCapabilities_Used = 0; +} + +void vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_IgnoreBool) + Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallInstance); + Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(cmock_call_instance, physicalDevice, surface, pSurfaceCapabilities); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPhysicalDeviceSurfaceCapabilitiesKHR_AddCallback(CMOCK_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceSurfaceCapabilitiesKHR_Stub(CMOCK_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CMockReturnMemThruPtr_pSurfaceCapabilities(UNITY_LINE_TYPE cmock_line, VkSurfaceCapabilitiesKHR const* pSurfaceCapabilities, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSurfaceCapabilities_Used = 1; + cmock_call_instance->ReturnThruPtr_pSurfaceCapabilities_Val = pSurfaceCapabilities; + cmock_call_instance->ReturnThruPtr_pSurfaceCapabilities_Size = cmock_size; +} + +void vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CMockIgnoreArg_surface(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_surface = 1; +} + +void vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CMockIgnoreArg_pSurfaceCapabilities(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSurfaceCapabilities = 1; +} + +VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceSurfaceFormatsKHR); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_CallInstance); + Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_CallInstance); + if (Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_CallbackBool && + Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_CallbackFunctionPointer(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats, Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSurfaceFormatsKHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_surface) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSurfaceFormatsKHR,CMockString_surface); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_surface), (void*)(&surface), sizeof(VkSurfaceKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSurfaceFormatCount) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSurfaceFormatsKHR,CMockString_pSurfaceFormatCount); + if (cmock_call_instance->Expected_pSurfaceFormatCount == NULL) + { UNITY_TEST_ASSERT_NULL(pSurfaceFormatCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pSurfaceFormatCount, pSurfaceFormatCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pSurfaceFormats) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSurfaceFormatsKHR,CMockString_pSurfaceFormats); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSurfaceFormats), (void*)(pSurfaceFormats), sizeof(VkSurfaceFormatKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_CallbackFunctionPointer(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats, Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pSurfaceFormatCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSurfaceFormatCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSurfaceFormatCount, (const void*)cmock_call_instance->ReturnThruPtr_pSurfaceFormatCount_Val, + cmock_call_instance->ReturnThruPtr_pSurfaceFormatCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pSurfaceFormats_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSurfaceFormats, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSurfaceFormats, (const void*)cmock_call_instance->ReturnThruPtr_pSurfaceFormats_Val, + cmock_call_instance->ReturnThruPtr_pSurfaceFormats_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPhysicalDeviceSurfaceFormatsKHR(CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats); +void CMockExpectParameters_vkGetPhysicalDeviceSurfaceFormatsKHR(CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + memcpy((void*)(&cmock_call_instance->Expected_surface), (void*)(&surface), + sizeof(VkSurfaceKHR[sizeof(surface) == sizeof(VkSurfaceKHR) ? 1 : -1])); /* add VkSurfaceKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_surface = 0; + cmock_call_instance->Expected_pSurfaceFormatCount = pSurfaceFormatCount; + cmock_call_instance->IgnoreArg_pSurfaceFormatCount = 0; + cmock_call_instance->ReturnThruPtr_pSurfaceFormatCount_Used = 0; + cmock_call_instance->Expected_pSurfaceFormats = pSurfaceFormats; + cmock_call_instance->IgnoreArg_pSurfaceFormats = 0; + cmock_call_instance->ReturnThruPtr_pSurfaceFormats_Used = 0; +} + +void vkGetPhysicalDeviceSurfaceFormatsKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceSurfaceFormatsKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_IgnoreBool) + Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_CallInstance); + Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceSurfaceFormatsKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceSurfaceFormatsKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceSurfaceFormatsKHR(cmock_call_instance, physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPhysicalDeviceSurfaceFormatsKHR_AddCallback(CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceSurfaceFormatsKHR_Stub(CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceSurfaceFormatsKHR_CMockReturnMemThruPtr_pSurfaceFormatCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pSurfaceFormatCount, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSurfaceFormatCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pSurfaceFormatCount_Val = pSurfaceFormatCount; + cmock_call_instance->ReturnThruPtr_pSurfaceFormatCount_Size = cmock_size; +} + +void vkGetPhysicalDeviceSurfaceFormatsKHR_CMockReturnMemThruPtr_pSurfaceFormats(UNITY_LINE_TYPE cmock_line, VkSurfaceFormatKHR const* pSurfaceFormats, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSurfaceFormats_Used = 1; + cmock_call_instance->ReturnThruPtr_pSurfaceFormats_Val = pSurfaceFormats; + cmock_call_instance->ReturnThruPtr_pSurfaceFormats_Size = cmock_size; +} + +void vkGetPhysicalDeviceSurfaceFormatsKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceSurfaceFormatsKHR_CMockIgnoreArg_surface(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_surface = 1; +} + +void vkGetPhysicalDeviceSurfaceFormatsKHR_CMockIgnoreArg_pSurfaceFormatCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSurfaceFormatCount = 1; +} + +void vkGetPhysicalDeviceSurfaceFormatsKHR_CMockIgnoreArg_pSurfaceFormats(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfaceFormatsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSurfaceFormats = 1; +} + +VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceSurfacePresentModesKHR); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_CallInstance); + Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_CallInstance); + if (Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_CallbackBool && + Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_CallbackFunctionPointer(physicalDevice, surface, pPresentModeCount, pPresentModes, Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSurfacePresentModesKHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_surface) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSurfacePresentModesKHR,CMockString_surface); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_surface), (void*)(&surface), sizeof(VkSurfaceKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPresentModeCount) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSurfacePresentModesKHR,CMockString_pPresentModeCount); + if (cmock_call_instance->Expected_pPresentModeCount == NULL) + { UNITY_TEST_ASSERT_NULL(pPresentModeCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pPresentModeCount, pPresentModeCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pPresentModes) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSurfacePresentModesKHR,CMockString_pPresentModes); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pPresentModes), (void*)(pPresentModes), sizeof(VkPresentModeKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_CallbackFunctionPointer(physicalDevice, surface, pPresentModeCount, pPresentModes, Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPresentModeCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPresentModeCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPresentModeCount, (const void*)cmock_call_instance->ReturnThruPtr_pPresentModeCount_Val, + cmock_call_instance->ReturnThruPtr_pPresentModeCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pPresentModes_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPresentModes, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPresentModes, (const void*)cmock_call_instance->ReturnThruPtr_pPresentModes_Val, + cmock_call_instance->ReturnThruPtr_pPresentModes_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPhysicalDeviceSurfacePresentModesKHR(CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes); +void CMockExpectParameters_vkGetPhysicalDeviceSurfacePresentModesKHR(CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + memcpy((void*)(&cmock_call_instance->Expected_surface), (void*)(&surface), + sizeof(VkSurfaceKHR[sizeof(surface) == sizeof(VkSurfaceKHR) ? 1 : -1])); /* add VkSurfaceKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_surface = 0; + cmock_call_instance->Expected_pPresentModeCount = pPresentModeCount; + cmock_call_instance->IgnoreArg_pPresentModeCount = 0; + cmock_call_instance->ReturnThruPtr_pPresentModeCount_Used = 0; + cmock_call_instance->Expected_pPresentModes = pPresentModes; + cmock_call_instance->IgnoreArg_pPresentModes = 0; + cmock_call_instance->ReturnThruPtr_pPresentModes_Used = 0; +} + +void vkGetPhysicalDeviceSurfacePresentModesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceSurfacePresentModesKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_IgnoreBool) + Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_CallInstance); + Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceSurfacePresentModesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceSurfacePresentModesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceSurfacePresentModesKHR(cmock_call_instance, physicalDevice, surface, pPresentModeCount, pPresentModes); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPhysicalDeviceSurfacePresentModesKHR_AddCallback(CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceSurfacePresentModesKHR_Stub(CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceSurfacePresentModesKHR_CMockReturnMemThruPtr_pPresentModeCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPresentModeCount, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPresentModeCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pPresentModeCount_Val = pPresentModeCount; + cmock_call_instance->ReturnThruPtr_pPresentModeCount_Size = cmock_size; +} + +void vkGetPhysicalDeviceSurfacePresentModesKHR_CMockReturnMemThruPtr_pPresentModes(UNITY_LINE_TYPE cmock_line, VkPresentModeKHR const* pPresentModes, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPresentModes_Used = 1; + cmock_call_instance->ReturnThruPtr_pPresentModes_Val = pPresentModes; + cmock_call_instance->ReturnThruPtr_pPresentModes_Size = cmock_size; +} + +void vkGetPhysicalDeviceSurfacePresentModesKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceSurfacePresentModesKHR_CMockIgnoreArg_surface(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_surface = 1; +} + +void vkGetPhysicalDeviceSurfacePresentModesKHR_CMockIgnoreArg_pPresentModeCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPresentModeCount = 1; +} + +void vkGetPhysicalDeviceSurfacePresentModesKHR_CMockIgnoreArg_pPresentModes(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfacePresentModesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPresentModes = 1; +} + +VkResult vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateSwapchainKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateSwapchainKHR); + cmock_call_instance = (CMOCK_vkCreateSwapchainKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateSwapchainKHR_CallInstance); + Mock.vkCreateSwapchainKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCreateSwapchainKHR_CallInstance); + if (Mock.vkCreateSwapchainKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateSwapchainKHR_FinalReturn; + memcpy((void*)(&Mock.vkCreateSwapchainKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateSwapchainKHR_CallbackBool && + Mock.vkCreateSwapchainKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateSwapchainKHR_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pSwapchain, Mock.vkCreateSwapchainKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateSwapchainKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateSwapchainKHR,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkSwapchainCreateInfoKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateSwapchainKHR,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSwapchain) + { + UNITY_SET_DETAILS(CMockString_vkCreateSwapchainKHR,CMockString_pSwapchain); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSwapchain), (void*)(pSwapchain), sizeof(VkSwapchainKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateSwapchainKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateSwapchainKHR_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pSwapchain, Mock.vkCreateSwapchainKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pSwapchain_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSwapchain, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSwapchain, (const void*)cmock_call_instance->ReturnThruPtr_pSwapchain_Val, + cmock_call_instance->ReturnThruPtr_pSwapchain_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateSwapchainKHR(CMOCK_vkCreateSwapchainKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain); +void CMockExpectParameters_vkCreateSwapchainKHR(CMOCK_vkCreateSwapchainKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pSwapchain = pSwapchain; + cmock_call_instance->IgnoreArg_pSwapchain = 0; + cmock_call_instance->ReturnThruPtr_pSwapchain_Used = 0; +} + +void vkCreateSwapchainKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateSwapchainKHR_CALL_INSTANCE)); + CMOCK_vkCreateSwapchainKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSwapchainKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateSwapchainKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateSwapchainKHR_CallInstance, cmock_guts_index); + Mock.vkCreateSwapchainKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateSwapchainKHR_IgnoreBool = (char)1; +} + +void vkCreateSwapchainKHR_CMockStopIgnore(void) +{ + if(Mock.vkCreateSwapchainKHR_IgnoreBool) + Mock.vkCreateSwapchainKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCreateSwapchainKHR_CallInstance); + Mock.vkCreateSwapchainKHR_IgnoreBool = (char)0; +} + +void vkCreateSwapchainKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateSwapchainKHR_CALL_INSTANCE)); + CMOCK_vkCreateSwapchainKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSwapchainKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateSwapchainKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateSwapchainKHR_CallInstance, cmock_guts_index); + Mock.vkCreateSwapchainKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateSwapchainKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateSwapchainKHR_CALL_INSTANCE)); + CMOCK_vkCreateSwapchainKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSwapchainKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateSwapchainKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateSwapchainKHR_CallInstance, cmock_guts_index); + Mock.vkCreateSwapchainKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateSwapchainKHR(cmock_call_instance, device, pCreateInfo, pAllocator, pSwapchain); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateSwapchainKHR_AddCallback(CMOCK_vkCreateSwapchainKHR_CALLBACK Callback) +{ + Mock.vkCreateSwapchainKHR_IgnoreBool = (char)0; + Mock.vkCreateSwapchainKHR_CallbackBool = (char)1; + Mock.vkCreateSwapchainKHR_CallbackFunctionPointer = Callback; +} + +void vkCreateSwapchainKHR_Stub(CMOCK_vkCreateSwapchainKHR_CALLBACK Callback) +{ + Mock.vkCreateSwapchainKHR_IgnoreBool = (char)0; + Mock.vkCreateSwapchainKHR_CallbackBool = (char)0; + Mock.vkCreateSwapchainKHR_CallbackFunctionPointer = Callback; +} + +void vkCreateSwapchainKHR_CMockReturnMemThruPtr_pSwapchain(UNITY_LINE_TYPE cmock_line, VkSwapchainKHR const* pSwapchain, size_t cmock_size) +{ + CMOCK_vkCreateSwapchainKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSwapchainKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSwapchainKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSwapchain_Used = 1; + cmock_call_instance->ReturnThruPtr_pSwapchain_Val = pSwapchain; + cmock_call_instance->ReturnThruPtr_pSwapchain_Size = cmock_size; +} + +void vkCreateSwapchainKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateSwapchainKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSwapchainKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSwapchainKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateSwapchainKHR_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateSwapchainKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSwapchainKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSwapchainKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateSwapchainKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateSwapchainKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSwapchainKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSwapchainKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateSwapchainKHR_CMockIgnoreArg_pSwapchain(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateSwapchainKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSwapchainKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSwapchainKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSwapchain = 1; +} + +void vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroySwapchainKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroySwapchainKHR); + cmock_call_instance = (CMOCK_vkDestroySwapchainKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroySwapchainKHR_CallInstance); + Mock.vkDestroySwapchainKHR_CallInstance = CMock_Guts_MemNext(Mock.vkDestroySwapchainKHR_CallInstance); + if (Mock.vkDestroySwapchainKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroySwapchainKHR_CallbackBool && + Mock.vkDestroySwapchainKHR_CallbackFunctionPointer != NULL) + { + Mock.vkDestroySwapchainKHR_CallbackFunctionPointer(device, swapchain, pAllocator, Mock.vkDestroySwapchainKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroySwapchainKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_swapchain) + { + UNITY_SET_DETAILS(CMockString_vkDestroySwapchainKHR,CMockString_swapchain); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_swapchain), (void*)(&swapchain), sizeof(VkSwapchainKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroySwapchainKHR,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroySwapchainKHR_CallbackFunctionPointer != NULL) + { + Mock.vkDestroySwapchainKHR_CallbackFunctionPointer(device, swapchain, pAllocator, Mock.vkDestroySwapchainKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroySwapchainKHR(CMOCK_vkDestroySwapchainKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroySwapchainKHR(CMOCK_vkDestroySwapchainKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_swapchain), (void*)(&swapchain), + sizeof(VkSwapchainKHR[sizeof(swapchain) == sizeof(VkSwapchainKHR) ? 1 : -1])); /* add VkSwapchainKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_swapchain = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroySwapchainKHR_CMockIgnore(void) +{ + Mock.vkDestroySwapchainKHR_IgnoreBool = (char)1; +} + +void vkDestroySwapchainKHR_CMockStopIgnore(void) +{ + Mock.vkDestroySwapchainKHR_IgnoreBool = (char)0; +} + +void vkDestroySwapchainKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroySwapchainKHR_CALL_INSTANCE)); + CMOCK_vkDestroySwapchainKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroySwapchainKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroySwapchainKHR_CallInstance = CMock_Guts_MemChain(Mock.vkDestroySwapchainKHR_CallInstance, cmock_guts_index); + Mock.vkDestroySwapchainKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroySwapchainKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroySwapchainKHR_CALL_INSTANCE)); + CMOCK_vkDestroySwapchainKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroySwapchainKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroySwapchainKHR_CallInstance = CMock_Guts_MemChain(Mock.vkDestroySwapchainKHR_CallInstance, cmock_guts_index); + Mock.vkDestroySwapchainKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroySwapchainKHR(cmock_call_instance, device, swapchain, pAllocator); +} + +void vkDestroySwapchainKHR_AddCallback(CMOCK_vkDestroySwapchainKHR_CALLBACK Callback) +{ + Mock.vkDestroySwapchainKHR_IgnoreBool = (char)0; + Mock.vkDestroySwapchainKHR_CallbackBool = (char)1; + Mock.vkDestroySwapchainKHR_CallbackFunctionPointer = Callback; +} + +void vkDestroySwapchainKHR_Stub(CMOCK_vkDestroySwapchainKHR_CALLBACK Callback) +{ + Mock.vkDestroySwapchainKHR_IgnoreBool = (char)0; + Mock.vkDestroySwapchainKHR_CallbackBool = (char)0; + Mock.vkDestroySwapchainKHR_CallbackFunctionPointer = Callback; +} + +void vkDestroySwapchainKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroySwapchainKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroySwapchainKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroySwapchainKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroySwapchainKHR_CMockIgnoreArg_swapchain(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroySwapchainKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroySwapchainKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroySwapchainKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_swapchain = 1; +} + +void vkDestroySwapchainKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroySwapchainKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroySwapchainKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroySwapchainKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +VkResult vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetSwapchainImagesKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetSwapchainImagesKHR); + cmock_call_instance = (CMOCK_vkGetSwapchainImagesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetSwapchainImagesKHR_CallInstance); + Mock.vkGetSwapchainImagesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetSwapchainImagesKHR_CallInstance); + if (Mock.vkGetSwapchainImagesKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetSwapchainImagesKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetSwapchainImagesKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetSwapchainImagesKHR_CallbackBool && + Mock.vkGetSwapchainImagesKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetSwapchainImagesKHR_CallbackFunctionPointer(device, swapchain, pSwapchainImageCount, pSwapchainImages, Mock.vkGetSwapchainImagesKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetSwapchainImagesKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_swapchain) + { + UNITY_SET_DETAILS(CMockString_vkGetSwapchainImagesKHR,CMockString_swapchain); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_swapchain), (void*)(&swapchain), sizeof(VkSwapchainKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSwapchainImageCount) + { + UNITY_SET_DETAILS(CMockString_vkGetSwapchainImagesKHR,CMockString_pSwapchainImageCount); + if (cmock_call_instance->Expected_pSwapchainImageCount == NULL) + { UNITY_TEST_ASSERT_NULL(pSwapchainImageCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pSwapchainImageCount, pSwapchainImageCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pSwapchainImages) + { + UNITY_SET_DETAILS(CMockString_vkGetSwapchainImagesKHR,CMockString_pSwapchainImages); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSwapchainImages), (void*)(pSwapchainImages), sizeof(VkImage), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetSwapchainImagesKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetSwapchainImagesKHR_CallbackFunctionPointer(device, swapchain, pSwapchainImageCount, pSwapchainImages, Mock.vkGetSwapchainImagesKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pSwapchainImageCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSwapchainImageCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSwapchainImageCount, (const void*)cmock_call_instance->ReturnThruPtr_pSwapchainImageCount_Val, + cmock_call_instance->ReturnThruPtr_pSwapchainImageCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pSwapchainImages_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSwapchainImages, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSwapchainImages, (const void*)cmock_call_instance->ReturnThruPtr_pSwapchainImages_Val, + cmock_call_instance->ReturnThruPtr_pSwapchainImages_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetSwapchainImagesKHR(CMOCK_vkGetSwapchainImagesKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages); +void CMockExpectParameters_vkGetSwapchainImagesKHR(CMOCK_vkGetSwapchainImagesKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_swapchain), (void*)(&swapchain), + sizeof(VkSwapchainKHR[sizeof(swapchain) == sizeof(VkSwapchainKHR) ? 1 : -1])); /* add VkSwapchainKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_swapchain = 0; + cmock_call_instance->Expected_pSwapchainImageCount = pSwapchainImageCount; + cmock_call_instance->IgnoreArg_pSwapchainImageCount = 0; + cmock_call_instance->ReturnThruPtr_pSwapchainImageCount_Used = 0; + cmock_call_instance->Expected_pSwapchainImages = pSwapchainImages; + cmock_call_instance->IgnoreArg_pSwapchainImages = 0; + cmock_call_instance->ReturnThruPtr_pSwapchainImages_Used = 0; +} + +void vkGetSwapchainImagesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetSwapchainImagesKHR_CALL_INSTANCE)); + CMOCK_vkGetSwapchainImagesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSwapchainImagesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetSwapchainImagesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetSwapchainImagesKHR_CallInstance, cmock_guts_index); + Mock.vkGetSwapchainImagesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetSwapchainImagesKHR_IgnoreBool = (char)1; +} + +void vkGetSwapchainImagesKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetSwapchainImagesKHR_IgnoreBool) + Mock.vkGetSwapchainImagesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetSwapchainImagesKHR_CallInstance); + Mock.vkGetSwapchainImagesKHR_IgnoreBool = (char)0; +} + +void vkGetSwapchainImagesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetSwapchainImagesKHR_CALL_INSTANCE)); + CMOCK_vkGetSwapchainImagesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSwapchainImagesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetSwapchainImagesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetSwapchainImagesKHR_CallInstance, cmock_guts_index); + Mock.vkGetSwapchainImagesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetSwapchainImagesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetSwapchainImagesKHR_CALL_INSTANCE)); + CMOCK_vkGetSwapchainImagesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSwapchainImagesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetSwapchainImagesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetSwapchainImagesKHR_CallInstance, cmock_guts_index); + Mock.vkGetSwapchainImagesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetSwapchainImagesKHR(cmock_call_instance, device, swapchain, pSwapchainImageCount, pSwapchainImages); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetSwapchainImagesKHR_AddCallback(CMOCK_vkGetSwapchainImagesKHR_CALLBACK Callback) +{ + Mock.vkGetSwapchainImagesKHR_IgnoreBool = (char)0; + Mock.vkGetSwapchainImagesKHR_CallbackBool = (char)1; + Mock.vkGetSwapchainImagesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetSwapchainImagesKHR_Stub(CMOCK_vkGetSwapchainImagesKHR_CALLBACK Callback) +{ + Mock.vkGetSwapchainImagesKHR_IgnoreBool = (char)0; + Mock.vkGetSwapchainImagesKHR_CallbackBool = (char)0; + Mock.vkGetSwapchainImagesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetSwapchainImagesKHR_CMockReturnMemThruPtr_pSwapchainImageCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pSwapchainImageCount, size_t cmock_size) +{ + CMOCK_vkGetSwapchainImagesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSwapchainImagesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetSwapchainImagesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSwapchainImageCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pSwapchainImageCount_Val = pSwapchainImageCount; + cmock_call_instance->ReturnThruPtr_pSwapchainImageCount_Size = cmock_size; +} + +void vkGetSwapchainImagesKHR_CMockReturnMemThruPtr_pSwapchainImages(UNITY_LINE_TYPE cmock_line, VkImage const* pSwapchainImages, size_t cmock_size) +{ + CMOCK_vkGetSwapchainImagesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSwapchainImagesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetSwapchainImagesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSwapchainImages_Used = 1; + cmock_call_instance->ReturnThruPtr_pSwapchainImages_Val = pSwapchainImages; + cmock_call_instance->ReturnThruPtr_pSwapchainImages_Size = cmock_size; +} + +void vkGetSwapchainImagesKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetSwapchainImagesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSwapchainImagesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetSwapchainImagesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetSwapchainImagesKHR_CMockIgnoreArg_swapchain(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetSwapchainImagesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSwapchainImagesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetSwapchainImagesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_swapchain = 1; +} + +void vkGetSwapchainImagesKHR_CMockIgnoreArg_pSwapchainImageCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetSwapchainImagesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSwapchainImagesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetSwapchainImagesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSwapchainImageCount = 1; +} + +void vkGetSwapchainImagesKHR_CMockIgnoreArg_pSwapchainImages(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetSwapchainImagesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSwapchainImagesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetSwapchainImagesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSwapchainImages = 1; +} + +VkResult vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkAcquireNextImageKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkAcquireNextImageKHR); + cmock_call_instance = (CMOCK_vkAcquireNextImageKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkAcquireNextImageKHR_CallInstance); + Mock.vkAcquireNextImageKHR_CallInstance = CMock_Guts_MemNext(Mock.vkAcquireNextImageKHR_CallInstance); + if (Mock.vkAcquireNextImageKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkAcquireNextImageKHR_FinalReturn; + memcpy((void*)(&Mock.vkAcquireNextImageKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkAcquireNextImageKHR_CallbackBool && + Mock.vkAcquireNextImageKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkAcquireNextImageKHR_CallbackFunctionPointer(device, swapchain, timeout, semaphore, fence, pImageIndex, Mock.vkAcquireNextImageKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkAcquireNextImageKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_swapchain) + { + UNITY_SET_DETAILS(CMockString_vkAcquireNextImageKHR,CMockString_swapchain); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_swapchain), (void*)(&swapchain), sizeof(VkSwapchainKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_timeout) + { + UNITY_SET_DETAILS(CMockString_vkAcquireNextImageKHR,CMockString_timeout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_timeout), (void*)(&timeout), sizeof(uint64_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_semaphore) + { + UNITY_SET_DETAILS(CMockString_vkAcquireNextImageKHR,CMockString_semaphore); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_semaphore), (void*)(&semaphore), sizeof(VkSemaphore), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_fence) + { + UNITY_SET_DETAILS(CMockString_vkAcquireNextImageKHR,CMockString_fence); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_fence), (void*)(&fence), sizeof(VkFence), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pImageIndex) + { + UNITY_SET_DETAILS(CMockString_vkAcquireNextImageKHR,CMockString_pImageIndex); + if (cmock_call_instance->Expected_pImageIndex == NULL) + { UNITY_TEST_ASSERT_NULL(pImageIndex, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pImageIndex, pImageIndex, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkAcquireNextImageKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkAcquireNextImageKHR_CallbackFunctionPointer(device, swapchain, timeout, semaphore, fence, pImageIndex, Mock.vkAcquireNextImageKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pImageIndex_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pImageIndex, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pImageIndex, (const void*)cmock_call_instance->ReturnThruPtr_pImageIndex_Val, + cmock_call_instance->ReturnThruPtr_pImageIndex_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkAcquireNextImageKHR(CMOCK_vkAcquireNextImageKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex); +void CMockExpectParameters_vkAcquireNextImageKHR(CMOCK_vkAcquireNextImageKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_swapchain), (void*)(&swapchain), + sizeof(VkSwapchainKHR[sizeof(swapchain) == sizeof(VkSwapchainKHR) ? 1 : -1])); /* add VkSwapchainKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_swapchain = 0; + memcpy((void*)(&cmock_call_instance->Expected_timeout), (void*)(&timeout), + sizeof(uint64_t[sizeof(timeout) == sizeof(uint64_t) ? 1 : -1])); /* add uint64_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_timeout = 0; + memcpy((void*)(&cmock_call_instance->Expected_semaphore), (void*)(&semaphore), + sizeof(VkSemaphore[sizeof(semaphore) == sizeof(VkSemaphore) ? 1 : -1])); /* add VkSemaphore to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_semaphore = 0; + memcpy((void*)(&cmock_call_instance->Expected_fence), (void*)(&fence), + sizeof(VkFence[sizeof(fence) == sizeof(VkFence) ? 1 : -1])); /* add VkFence to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_fence = 0; + cmock_call_instance->Expected_pImageIndex = pImageIndex; + cmock_call_instance->IgnoreArg_pImageIndex = 0; + cmock_call_instance->ReturnThruPtr_pImageIndex_Used = 0; +} + +void vkAcquireNextImageKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkAcquireNextImageKHR_CALL_INSTANCE)); + CMOCK_vkAcquireNextImageKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquireNextImageKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkAcquireNextImageKHR_CallInstance = CMock_Guts_MemChain(Mock.vkAcquireNextImageKHR_CallInstance, cmock_guts_index); + Mock.vkAcquireNextImageKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkAcquireNextImageKHR_IgnoreBool = (char)1; +} + +void vkAcquireNextImageKHR_CMockStopIgnore(void) +{ + if(Mock.vkAcquireNextImageKHR_IgnoreBool) + Mock.vkAcquireNextImageKHR_CallInstance = CMock_Guts_MemNext(Mock.vkAcquireNextImageKHR_CallInstance); + Mock.vkAcquireNextImageKHR_IgnoreBool = (char)0; +} + +void vkAcquireNextImageKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkAcquireNextImageKHR_CALL_INSTANCE)); + CMOCK_vkAcquireNextImageKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquireNextImageKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkAcquireNextImageKHR_CallInstance = CMock_Guts_MemChain(Mock.vkAcquireNextImageKHR_CallInstance, cmock_guts_index); + Mock.vkAcquireNextImageKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkAcquireNextImageKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkAcquireNextImageKHR_CALL_INSTANCE)); + CMOCK_vkAcquireNextImageKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquireNextImageKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkAcquireNextImageKHR_CallInstance = CMock_Guts_MemChain(Mock.vkAcquireNextImageKHR_CallInstance, cmock_guts_index); + Mock.vkAcquireNextImageKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkAcquireNextImageKHR(cmock_call_instance, device, swapchain, timeout, semaphore, fence, pImageIndex); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkAcquireNextImageKHR_AddCallback(CMOCK_vkAcquireNextImageKHR_CALLBACK Callback) +{ + Mock.vkAcquireNextImageKHR_IgnoreBool = (char)0; + Mock.vkAcquireNextImageKHR_CallbackBool = (char)1; + Mock.vkAcquireNextImageKHR_CallbackFunctionPointer = Callback; +} + +void vkAcquireNextImageKHR_Stub(CMOCK_vkAcquireNextImageKHR_CALLBACK Callback) +{ + Mock.vkAcquireNextImageKHR_IgnoreBool = (char)0; + Mock.vkAcquireNextImageKHR_CallbackBool = (char)0; + Mock.vkAcquireNextImageKHR_CallbackFunctionPointer = Callback; +} + +void vkAcquireNextImageKHR_CMockReturnMemThruPtr_pImageIndex(UNITY_LINE_TYPE cmock_line, uint32_t const* pImageIndex, size_t cmock_size) +{ + CMOCK_vkAcquireNextImageKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquireNextImageKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAcquireNextImageKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pImageIndex_Used = 1; + cmock_call_instance->ReturnThruPtr_pImageIndex_Val = pImageIndex; + cmock_call_instance->ReturnThruPtr_pImageIndex_Size = cmock_size; +} + +void vkAcquireNextImageKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkAcquireNextImageKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquireNextImageKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAcquireNextImageKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkAcquireNextImageKHR_CMockIgnoreArg_swapchain(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkAcquireNextImageKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquireNextImageKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAcquireNextImageKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_swapchain = 1; +} + +void vkAcquireNextImageKHR_CMockIgnoreArg_timeout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkAcquireNextImageKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquireNextImageKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAcquireNextImageKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_timeout = 1; +} + +void vkAcquireNextImageKHR_CMockIgnoreArg_semaphore(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkAcquireNextImageKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquireNextImageKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAcquireNextImageKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_semaphore = 1; +} + +void vkAcquireNextImageKHR_CMockIgnoreArg_fence(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkAcquireNextImageKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquireNextImageKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAcquireNextImageKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_fence = 1; +} + +void vkAcquireNextImageKHR_CMockIgnoreArg_pImageIndex(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkAcquireNextImageKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquireNextImageKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAcquireNextImageKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pImageIndex = 1; +} + +VkResult vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkQueuePresentKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkQueuePresentKHR); + cmock_call_instance = (CMOCK_vkQueuePresentKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkQueuePresentKHR_CallInstance); + Mock.vkQueuePresentKHR_CallInstance = CMock_Guts_MemNext(Mock.vkQueuePresentKHR_CallInstance); + if (Mock.vkQueuePresentKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkQueuePresentKHR_FinalReturn; + memcpy((void*)(&Mock.vkQueuePresentKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkQueuePresentKHR_CallbackBool && + Mock.vkQueuePresentKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkQueuePresentKHR_CallbackFunctionPointer(queue, pPresentInfo, Mock.vkQueuePresentKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_queue) + { + UNITY_SET_DETAILS(CMockString_vkQueuePresentKHR,CMockString_queue); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queue), (void*)(&queue), sizeof(VkQueue), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPresentInfo) + { + UNITY_SET_DETAILS(CMockString_vkQueuePresentKHR,CMockString_pPresentInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pPresentInfo), (void*)(pPresentInfo), sizeof(const VkPresentInfoKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkQueuePresentKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkQueuePresentKHR_CallbackFunctionPointer(queue, pPresentInfo, Mock.vkQueuePresentKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkQueuePresentKHR(CMOCK_vkQueuePresentKHR_CALL_INSTANCE* cmock_call_instance, VkQueue queue, const VkPresentInfoKHR* pPresentInfo); +void CMockExpectParameters_vkQueuePresentKHR(CMOCK_vkQueuePresentKHR_CALL_INSTANCE* cmock_call_instance, VkQueue queue, const VkPresentInfoKHR* pPresentInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_queue), (void*)(&queue), + sizeof(VkQueue[sizeof(queue) == sizeof(VkQueue) ? 1 : -1])); /* add VkQueue to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queue = 0; + cmock_call_instance->Expected_pPresentInfo = pPresentInfo; + cmock_call_instance->IgnoreArg_pPresentInfo = 0; +} + +void vkQueuePresentKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkQueuePresentKHR_CALL_INSTANCE)); + CMOCK_vkQueuePresentKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueuePresentKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkQueuePresentKHR_CallInstance = CMock_Guts_MemChain(Mock.vkQueuePresentKHR_CallInstance, cmock_guts_index); + Mock.vkQueuePresentKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkQueuePresentKHR_IgnoreBool = (char)1; +} + +void vkQueuePresentKHR_CMockStopIgnore(void) +{ + if(Mock.vkQueuePresentKHR_IgnoreBool) + Mock.vkQueuePresentKHR_CallInstance = CMock_Guts_MemNext(Mock.vkQueuePresentKHR_CallInstance); + Mock.vkQueuePresentKHR_IgnoreBool = (char)0; +} + +void vkQueuePresentKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkQueuePresentKHR_CALL_INSTANCE)); + CMOCK_vkQueuePresentKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueuePresentKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkQueuePresentKHR_CallInstance = CMock_Guts_MemChain(Mock.vkQueuePresentKHR_CallInstance, cmock_guts_index); + Mock.vkQueuePresentKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkQueuePresentKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkQueue queue, const VkPresentInfoKHR* pPresentInfo, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkQueuePresentKHR_CALL_INSTANCE)); + CMOCK_vkQueuePresentKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueuePresentKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkQueuePresentKHR_CallInstance = CMock_Guts_MemChain(Mock.vkQueuePresentKHR_CallInstance, cmock_guts_index); + Mock.vkQueuePresentKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkQueuePresentKHR(cmock_call_instance, queue, pPresentInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkQueuePresentKHR_AddCallback(CMOCK_vkQueuePresentKHR_CALLBACK Callback) +{ + Mock.vkQueuePresentKHR_IgnoreBool = (char)0; + Mock.vkQueuePresentKHR_CallbackBool = (char)1; + Mock.vkQueuePresentKHR_CallbackFunctionPointer = Callback; +} + +void vkQueuePresentKHR_Stub(CMOCK_vkQueuePresentKHR_CALLBACK Callback) +{ + Mock.vkQueuePresentKHR_IgnoreBool = (char)0; + Mock.vkQueuePresentKHR_CallbackBool = (char)0; + Mock.vkQueuePresentKHR_CallbackFunctionPointer = Callback; +} + +void vkQueuePresentKHR_CMockIgnoreArg_queue(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkQueuePresentKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueuePresentKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkQueuePresentKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queue = 1; +} + +void vkQueuePresentKHR_CMockIgnoreArg_pPresentInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkQueuePresentKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueuePresentKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkQueuePresentKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPresentInfo = 1; +} + +VkResult vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDeviceGroupPresentCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDeviceGroupPresentCapabilitiesKHR); + cmock_call_instance = (CMOCK_vkGetDeviceGroupPresentCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDeviceGroupPresentCapabilitiesKHR_CallInstance); + Mock.vkGetDeviceGroupPresentCapabilitiesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeviceGroupPresentCapabilitiesKHR_CallInstance); + if (Mock.vkGetDeviceGroupPresentCapabilitiesKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetDeviceGroupPresentCapabilitiesKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetDeviceGroupPresentCapabilitiesKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetDeviceGroupPresentCapabilitiesKHR_CallbackBool && + Mock.vkGetDeviceGroupPresentCapabilitiesKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetDeviceGroupPresentCapabilitiesKHR_CallbackFunctionPointer(device, pDeviceGroupPresentCapabilities, Mock.vkGetDeviceGroupPresentCapabilitiesKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceGroupPresentCapabilitiesKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDeviceGroupPresentCapabilities) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceGroupPresentCapabilitiesKHR,CMockString_pDeviceGroupPresentCapabilities); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDeviceGroupPresentCapabilities), (void*)(pDeviceGroupPresentCapabilities), sizeof(VkDeviceGroupPresentCapabilitiesKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDeviceGroupPresentCapabilitiesKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetDeviceGroupPresentCapabilitiesKHR_CallbackFunctionPointer(device, pDeviceGroupPresentCapabilities, Mock.vkGetDeviceGroupPresentCapabilitiesKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pDeviceGroupPresentCapabilities_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pDeviceGroupPresentCapabilities, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pDeviceGroupPresentCapabilities, (const void*)cmock_call_instance->ReturnThruPtr_pDeviceGroupPresentCapabilities_Val, + cmock_call_instance->ReturnThruPtr_pDeviceGroupPresentCapabilities_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetDeviceGroupPresentCapabilitiesKHR(CMOCK_vkGetDeviceGroupPresentCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); +void CMockExpectParameters_vkGetDeviceGroupPresentCapabilitiesKHR(CMOCK_vkGetDeviceGroupPresentCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pDeviceGroupPresentCapabilities = pDeviceGroupPresentCapabilities; + cmock_call_instance->IgnoreArg_pDeviceGroupPresentCapabilities = 0; + cmock_call_instance->ReturnThruPtr_pDeviceGroupPresentCapabilities_Used = 0; +} + +void vkGetDeviceGroupPresentCapabilitiesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceGroupPresentCapabilitiesKHR_CALL_INSTANCE)); + CMOCK_vkGetDeviceGroupPresentCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceGroupPresentCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceGroupPresentCapabilitiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceGroupPresentCapabilitiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetDeviceGroupPresentCapabilitiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetDeviceGroupPresentCapabilitiesKHR_IgnoreBool = (char)1; +} + +void vkGetDeviceGroupPresentCapabilitiesKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetDeviceGroupPresentCapabilitiesKHR_IgnoreBool) + Mock.vkGetDeviceGroupPresentCapabilitiesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeviceGroupPresentCapabilitiesKHR_CallInstance); + Mock.vkGetDeviceGroupPresentCapabilitiesKHR_IgnoreBool = (char)0; +} + +void vkGetDeviceGroupPresentCapabilitiesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceGroupPresentCapabilitiesKHR_CALL_INSTANCE)); + CMOCK_vkGetDeviceGroupPresentCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceGroupPresentCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceGroupPresentCapabilitiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceGroupPresentCapabilitiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetDeviceGroupPresentCapabilitiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDeviceGroupPresentCapabilitiesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceGroupPresentCapabilitiesKHR_CALL_INSTANCE)); + CMOCK_vkGetDeviceGroupPresentCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceGroupPresentCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceGroupPresentCapabilitiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceGroupPresentCapabilitiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetDeviceGroupPresentCapabilitiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDeviceGroupPresentCapabilitiesKHR(cmock_call_instance, device, pDeviceGroupPresentCapabilities); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetDeviceGroupPresentCapabilitiesKHR_AddCallback(CMOCK_vkGetDeviceGroupPresentCapabilitiesKHR_CALLBACK Callback) +{ + Mock.vkGetDeviceGroupPresentCapabilitiesKHR_IgnoreBool = (char)0; + Mock.vkGetDeviceGroupPresentCapabilitiesKHR_CallbackBool = (char)1; + Mock.vkGetDeviceGroupPresentCapabilitiesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceGroupPresentCapabilitiesKHR_Stub(CMOCK_vkGetDeviceGroupPresentCapabilitiesKHR_CALLBACK Callback) +{ + Mock.vkGetDeviceGroupPresentCapabilitiesKHR_IgnoreBool = (char)0; + Mock.vkGetDeviceGroupPresentCapabilitiesKHR_CallbackBool = (char)0; + Mock.vkGetDeviceGroupPresentCapabilitiesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceGroupPresentCapabilitiesKHR_CMockReturnMemThruPtr_pDeviceGroupPresentCapabilities(UNITY_LINE_TYPE cmock_line, VkDeviceGroupPresentCapabilitiesKHR const* pDeviceGroupPresentCapabilities, size_t cmock_size) +{ + CMOCK_vkGetDeviceGroupPresentCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceGroupPresentCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceGroupPresentCapabilitiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pDeviceGroupPresentCapabilities_Used = 1; + cmock_call_instance->ReturnThruPtr_pDeviceGroupPresentCapabilities_Val = pDeviceGroupPresentCapabilities; + cmock_call_instance->ReturnThruPtr_pDeviceGroupPresentCapabilities_Size = cmock_size; +} + +void vkGetDeviceGroupPresentCapabilitiesKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceGroupPresentCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceGroupPresentCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceGroupPresentCapabilitiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetDeviceGroupPresentCapabilitiesKHR_CMockIgnoreArg_pDeviceGroupPresentCapabilities(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceGroupPresentCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceGroupPresentCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceGroupPresentCapabilitiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDeviceGroupPresentCapabilities = 1; +} + +VkResult vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDeviceGroupSurfacePresentModesKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDeviceGroupSurfacePresentModesKHR); + cmock_call_instance = (CMOCK_vkGetDeviceGroupSurfacePresentModesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDeviceGroupSurfacePresentModesKHR_CallInstance); + Mock.vkGetDeviceGroupSurfacePresentModesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeviceGroupSurfacePresentModesKHR_CallInstance); + if (Mock.vkGetDeviceGroupSurfacePresentModesKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetDeviceGroupSurfacePresentModesKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetDeviceGroupSurfacePresentModesKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetDeviceGroupSurfacePresentModesKHR_CallbackBool && + Mock.vkGetDeviceGroupSurfacePresentModesKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetDeviceGroupSurfacePresentModesKHR_CallbackFunctionPointer(device, surface, pModes, Mock.vkGetDeviceGroupSurfacePresentModesKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceGroupSurfacePresentModesKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_surface) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceGroupSurfacePresentModesKHR,CMockString_surface); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_surface), (void*)(&surface), sizeof(VkSurfaceKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pModes) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceGroupSurfacePresentModesKHR,CMockString_pModes); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pModes), (void*)(pModes), sizeof(VkDeviceGroupPresentModeFlagsKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDeviceGroupSurfacePresentModesKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetDeviceGroupSurfacePresentModesKHR_CallbackFunctionPointer(device, surface, pModes, Mock.vkGetDeviceGroupSurfacePresentModesKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pModes_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pModes, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pModes, (const void*)cmock_call_instance->ReturnThruPtr_pModes_Val, + cmock_call_instance->ReturnThruPtr_pModes_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetDeviceGroupSurfacePresentModesKHR(CMOCK_vkGetDeviceGroupSurfacePresentModesKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes); +void CMockExpectParameters_vkGetDeviceGroupSurfacePresentModesKHR(CMOCK_vkGetDeviceGroupSurfacePresentModesKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_surface), (void*)(&surface), + sizeof(VkSurfaceKHR[sizeof(surface) == sizeof(VkSurfaceKHR) ? 1 : -1])); /* add VkSurfaceKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_surface = 0; + cmock_call_instance->Expected_pModes = pModes; + cmock_call_instance->IgnoreArg_pModes = 0; + cmock_call_instance->ReturnThruPtr_pModes_Used = 0; +} + +void vkGetDeviceGroupSurfacePresentModesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceGroupSurfacePresentModesKHR_CALL_INSTANCE)); + CMOCK_vkGetDeviceGroupSurfacePresentModesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceGroupSurfacePresentModesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceGroupSurfacePresentModesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceGroupSurfacePresentModesKHR_CallInstance, cmock_guts_index); + Mock.vkGetDeviceGroupSurfacePresentModesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetDeviceGroupSurfacePresentModesKHR_IgnoreBool = (char)1; +} + +void vkGetDeviceGroupSurfacePresentModesKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetDeviceGroupSurfacePresentModesKHR_IgnoreBool) + Mock.vkGetDeviceGroupSurfacePresentModesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeviceGroupSurfacePresentModesKHR_CallInstance); + Mock.vkGetDeviceGroupSurfacePresentModesKHR_IgnoreBool = (char)0; +} + +void vkGetDeviceGroupSurfacePresentModesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceGroupSurfacePresentModesKHR_CALL_INSTANCE)); + CMOCK_vkGetDeviceGroupSurfacePresentModesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceGroupSurfacePresentModesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceGroupSurfacePresentModesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceGroupSurfacePresentModesKHR_CallInstance, cmock_guts_index); + Mock.vkGetDeviceGroupSurfacePresentModesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDeviceGroupSurfacePresentModesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceGroupSurfacePresentModesKHR_CALL_INSTANCE)); + CMOCK_vkGetDeviceGroupSurfacePresentModesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceGroupSurfacePresentModesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceGroupSurfacePresentModesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceGroupSurfacePresentModesKHR_CallInstance, cmock_guts_index); + Mock.vkGetDeviceGroupSurfacePresentModesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDeviceGroupSurfacePresentModesKHR(cmock_call_instance, device, surface, pModes); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetDeviceGroupSurfacePresentModesKHR_AddCallback(CMOCK_vkGetDeviceGroupSurfacePresentModesKHR_CALLBACK Callback) +{ + Mock.vkGetDeviceGroupSurfacePresentModesKHR_IgnoreBool = (char)0; + Mock.vkGetDeviceGroupSurfacePresentModesKHR_CallbackBool = (char)1; + Mock.vkGetDeviceGroupSurfacePresentModesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceGroupSurfacePresentModesKHR_Stub(CMOCK_vkGetDeviceGroupSurfacePresentModesKHR_CALLBACK Callback) +{ + Mock.vkGetDeviceGroupSurfacePresentModesKHR_IgnoreBool = (char)0; + Mock.vkGetDeviceGroupSurfacePresentModesKHR_CallbackBool = (char)0; + Mock.vkGetDeviceGroupSurfacePresentModesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceGroupSurfacePresentModesKHR_CMockReturnMemThruPtr_pModes(UNITY_LINE_TYPE cmock_line, VkDeviceGroupPresentModeFlagsKHR const* pModes, size_t cmock_size) +{ + CMOCK_vkGetDeviceGroupSurfacePresentModesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceGroupSurfacePresentModesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceGroupSurfacePresentModesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pModes_Used = 1; + cmock_call_instance->ReturnThruPtr_pModes_Val = pModes; + cmock_call_instance->ReturnThruPtr_pModes_Size = cmock_size; +} + +void vkGetDeviceGroupSurfacePresentModesKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceGroupSurfacePresentModesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceGroupSurfacePresentModesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceGroupSurfacePresentModesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetDeviceGroupSurfacePresentModesKHR_CMockIgnoreArg_surface(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceGroupSurfacePresentModesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceGroupSurfacePresentModesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceGroupSurfacePresentModesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_surface = 1; +} + +void vkGetDeviceGroupSurfacePresentModesKHR_CMockIgnoreArg_pModes(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceGroupSurfacePresentModesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceGroupSurfacePresentModesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceGroupSurfacePresentModesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pModes = 1; +} + +VkResult vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDevicePresentRectanglesKHR); + cmock_call_instance = (CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDevicePresentRectanglesKHR_CallInstance); + Mock.vkGetPhysicalDevicePresentRectanglesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDevicePresentRectanglesKHR_CallInstance); + if (Mock.vkGetPhysicalDevicePresentRectanglesKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPhysicalDevicePresentRectanglesKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetPhysicalDevicePresentRectanglesKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPhysicalDevicePresentRectanglesKHR_CallbackBool && + Mock.vkGetPhysicalDevicePresentRectanglesKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPhysicalDevicePresentRectanglesKHR_CallbackFunctionPointer(physicalDevice, surface, pRectCount, pRects, Mock.vkGetPhysicalDevicePresentRectanglesKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDevicePresentRectanglesKHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_surface) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDevicePresentRectanglesKHR,CMockString_surface); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_surface), (void*)(&surface), sizeof(VkSurfaceKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pRectCount) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDevicePresentRectanglesKHR,CMockString_pRectCount); + if (cmock_call_instance->Expected_pRectCount == NULL) + { UNITY_TEST_ASSERT_NULL(pRectCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pRectCount, pRectCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pRects) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDevicePresentRectanglesKHR,CMockString_pRects); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pRects), (void*)(pRects), sizeof(VkRect2D), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDevicePresentRectanglesKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPhysicalDevicePresentRectanglesKHR_CallbackFunctionPointer(physicalDevice, surface, pRectCount, pRects, Mock.vkGetPhysicalDevicePresentRectanglesKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pRectCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pRectCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pRectCount, (const void*)cmock_call_instance->ReturnThruPtr_pRectCount_Val, + cmock_call_instance->ReturnThruPtr_pRectCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pRects_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pRects, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pRects, (const void*)cmock_call_instance->ReturnThruPtr_pRects_Val, + cmock_call_instance->ReturnThruPtr_pRects_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPhysicalDevicePresentRectanglesKHR(CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects); +void CMockExpectParameters_vkGetPhysicalDevicePresentRectanglesKHR(CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + memcpy((void*)(&cmock_call_instance->Expected_surface), (void*)(&surface), + sizeof(VkSurfaceKHR[sizeof(surface) == sizeof(VkSurfaceKHR) ? 1 : -1])); /* add VkSurfaceKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_surface = 0; + cmock_call_instance->Expected_pRectCount = pRectCount; + cmock_call_instance->IgnoreArg_pRectCount = 0; + cmock_call_instance->ReturnThruPtr_pRectCount_Used = 0; + cmock_call_instance->Expected_pRects = pRects; + cmock_call_instance->IgnoreArg_pRects = 0; + cmock_call_instance->ReturnThruPtr_pRects_Used = 0; +} + +void vkGetPhysicalDevicePresentRectanglesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDevicePresentRectanglesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDevicePresentRectanglesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDevicePresentRectanglesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPhysicalDevicePresentRectanglesKHR_IgnoreBool = (char)1; +} + +void vkGetPhysicalDevicePresentRectanglesKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetPhysicalDevicePresentRectanglesKHR_IgnoreBool) + Mock.vkGetPhysicalDevicePresentRectanglesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDevicePresentRectanglesKHR_CallInstance); + Mock.vkGetPhysicalDevicePresentRectanglesKHR_IgnoreBool = (char)0; +} + +void vkGetPhysicalDevicePresentRectanglesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDevicePresentRectanglesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDevicePresentRectanglesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDevicePresentRectanglesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDevicePresentRectanglesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDevicePresentRectanglesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDevicePresentRectanglesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDevicePresentRectanglesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDevicePresentRectanglesKHR(cmock_call_instance, physicalDevice, surface, pRectCount, pRects); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPhysicalDevicePresentRectanglesKHR_AddCallback(CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDevicePresentRectanglesKHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDevicePresentRectanglesKHR_CallbackBool = (char)1; + Mock.vkGetPhysicalDevicePresentRectanglesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDevicePresentRectanglesKHR_Stub(CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDevicePresentRectanglesKHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDevicePresentRectanglesKHR_CallbackBool = (char)0; + Mock.vkGetPhysicalDevicePresentRectanglesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDevicePresentRectanglesKHR_CMockReturnMemThruPtr_pRectCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pRectCount, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDevicePresentRectanglesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pRectCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pRectCount_Val = pRectCount; + cmock_call_instance->ReturnThruPtr_pRectCount_Size = cmock_size; +} + +void vkGetPhysicalDevicePresentRectanglesKHR_CMockReturnMemThruPtr_pRects(UNITY_LINE_TYPE cmock_line, VkRect2D const* pRects, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDevicePresentRectanglesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pRects_Used = 1; + cmock_call_instance->ReturnThruPtr_pRects_Val = pRects; + cmock_call_instance->ReturnThruPtr_pRects_Size = cmock_size; +} + +void vkGetPhysicalDevicePresentRectanglesKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDevicePresentRectanglesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDevicePresentRectanglesKHR_CMockIgnoreArg_surface(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDevicePresentRectanglesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_surface = 1; +} + +void vkGetPhysicalDevicePresentRectanglesKHR_CMockIgnoreArg_pRectCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDevicePresentRectanglesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pRectCount = 1; +} + +void vkGetPhysicalDevicePresentRectanglesKHR_CMockIgnoreArg_pRects(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDevicePresentRectanglesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pRects = 1; +} + +VkResult vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkAcquireNextImage2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkAcquireNextImage2KHR); + cmock_call_instance = (CMOCK_vkAcquireNextImage2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkAcquireNextImage2KHR_CallInstance); + Mock.vkAcquireNextImage2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkAcquireNextImage2KHR_CallInstance); + if (Mock.vkAcquireNextImage2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkAcquireNextImage2KHR_FinalReturn; + memcpy((void*)(&Mock.vkAcquireNextImage2KHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkAcquireNextImage2KHR_CallbackBool && + Mock.vkAcquireNextImage2KHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkAcquireNextImage2KHR_CallbackFunctionPointer(device, pAcquireInfo, pImageIndex, Mock.vkAcquireNextImage2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkAcquireNextImage2KHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAcquireInfo) + { + UNITY_SET_DETAILS(CMockString_vkAcquireNextImage2KHR,CMockString_pAcquireInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAcquireInfo), (void*)(pAcquireInfo), sizeof(const VkAcquireNextImageInfoKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pImageIndex) + { + UNITY_SET_DETAILS(CMockString_vkAcquireNextImage2KHR,CMockString_pImageIndex); + if (cmock_call_instance->Expected_pImageIndex == NULL) + { UNITY_TEST_ASSERT_NULL(pImageIndex, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pImageIndex, pImageIndex, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkAcquireNextImage2KHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkAcquireNextImage2KHR_CallbackFunctionPointer(device, pAcquireInfo, pImageIndex, Mock.vkAcquireNextImage2KHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pImageIndex_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pImageIndex, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pImageIndex, (const void*)cmock_call_instance->ReturnThruPtr_pImageIndex_Val, + cmock_call_instance->ReturnThruPtr_pImageIndex_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkAcquireNextImage2KHR(CMOCK_vkAcquireNextImage2KHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex); +void CMockExpectParameters_vkAcquireNextImage2KHR(CMOCK_vkAcquireNextImage2KHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pAcquireInfo = pAcquireInfo; + cmock_call_instance->IgnoreArg_pAcquireInfo = 0; + cmock_call_instance->Expected_pImageIndex = pImageIndex; + cmock_call_instance->IgnoreArg_pImageIndex = 0; + cmock_call_instance->ReturnThruPtr_pImageIndex_Used = 0; +} + +void vkAcquireNextImage2KHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkAcquireNextImage2KHR_CALL_INSTANCE)); + CMOCK_vkAcquireNextImage2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquireNextImage2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkAcquireNextImage2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkAcquireNextImage2KHR_CallInstance, cmock_guts_index); + Mock.vkAcquireNextImage2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkAcquireNextImage2KHR_IgnoreBool = (char)1; +} + +void vkAcquireNextImage2KHR_CMockStopIgnore(void) +{ + if(Mock.vkAcquireNextImage2KHR_IgnoreBool) + Mock.vkAcquireNextImage2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkAcquireNextImage2KHR_CallInstance); + Mock.vkAcquireNextImage2KHR_IgnoreBool = (char)0; +} + +void vkAcquireNextImage2KHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkAcquireNextImage2KHR_CALL_INSTANCE)); + CMOCK_vkAcquireNextImage2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquireNextImage2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkAcquireNextImage2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkAcquireNextImage2KHR_CallInstance, cmock_guts_index); + Mock.vkAcquireNextImage2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkAcquireNextImage2KHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkAcquireNextImage2KHR_CALL_INSTANCE)); + CMOCK_vkAcquireNextImage2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquireNextImage2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkAcquireNextImage2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkAcquireNextImage2KHR_CallInstance, cmock_guts_index); + Mock.vkAcquireNextImage2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkAcquireNextImage2KHR(cmock_call_instance, device, pAcquireInfo, pImageIndex); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkAcquireNextImage2KHR_AddCallback(CMOCK_vkAcquireNextImage2KHR_CALLBACK Callback) +{ + Mock.vkAcquireNextImage2KHR_IgnoreBool = (char)0; + Mock.vkAcquireNextImage2KHR_CallbackBool = (char)1; + Mock.vkAcquireNextImage2KHR_CallbackFunctionPointer = Callback; +} + +void vkAcquireNextImage2KHR_Stub(CMOCK_vkAcquireNextImage2KHR_CALLBACK Callback) +{ + Mock.vkAcquireNextImage2KHR_IgnoreBool = (char)0; + Mock.vkAcquireNextImage2KHR_CallbackBool = (char)0; + Mock.vkAcquireNextImage2KHR_CallbackFunctionPointer = Callback; +} + +void vkAcquireNextImage2KHR_CMockReturnMemThruPtr_pImageIndex(UNITY_LINE_TYPE cmock_line, uint32_t const* pImageIndex, size_t cmock_size) +{ + CMOCK_vkAcquireNextImage2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquireNextImage2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAcquireNextImage2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pImageIndex_Used = 1; + cmock_call_instance->ReturnThruPtr_pImageIndex_Val = pImageIndex; + cmock_call_instance->ReturnThruPtr_pImageIndex_Size = cmock_size; +} + +void vkAcquireNextImage2KHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkAcquireNextImage2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquireNextImage2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAcquireNextImage2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkAcquireNextImage2KHR_CMockIgnoreArg_pAcquireInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkAcquireNextImage2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquireNextImage2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAcquireNextImage2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAcquireInfo = 1; +} + +void vkAcquireNextImage2KHR_CMockIgnoreArg_pImageIndex(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkAcquireNextImage2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquireNextImage2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAcquireNextImage2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pImageIndex = 1; +} + +VkResult vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceDisplayPropertiesKHR); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_CallInstance); + Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_CallInstance); + if (Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_CallbackBool && + Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_CallbackFunctionPointer(physicalDevice, pPropertyCount, pProperties, Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceDisplayPropertiesKHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPropertyCount) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceDisplayPropertiesKHR,CMockString_pPropertyCount); + if (cmock_call_instance->Expected_pPropertyCount == NULL) + { UNITY_TEST_ASSERT_NULL(pPropertyCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pPropertyCount, pPropertyCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceDisplayPropertiesKHR,CMockString_pProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pProperties), (void*)(pProperties), sizeof(VkDisplayPropertiesKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_CallbackFunctionPointer(physicalDevice, pPropertyCount, pProperties, Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPropertyCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPropertyCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPropertyCount, (const void*)cmock_call_instance->ReturnThruPtr_pPropertyCount_Val, + cmock_call_instance->ReturnThruPtr_pPropertyCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pProperties, (const void*)cmock_call_instance->ReturnThruPtr_pProperties_Val, + cmock_call_instance->ReturnThruPtr_pProperties_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPhysicalDeviceDisplayPropertiesKHR(CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties); +void CMockExpectParameters_vkGetPhysicalDeviceDisplayPropertiesKHR(CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pPropertyCount = pPropertyCount; + cmock_call_instance->IgnoreArg_pPropertyCount = 0; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Used = 0; + cmock_call_instance->Expected_pProperties = pProperties; + cmock_call_instance->IgnoreArg_pProperties = 0; + cmock_call_instance->ReturnThruPtr_pProperties_Used = 0; +} + +void vkGetPhysicalDeviceDisplayPropertiesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceDisplayPropertiesKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_IgnoreBool) + Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_CallInstance); + Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceDisplayPropertiesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceDisplayPropertiesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceDisplayPropertiesKHR(cmock_call_instance, physicalDevice, pPropertyCount, pProperties); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPhysicalDeviceDisplayPropertiesKHR_AddCallback(CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceDisplayPropertiesKHR_Stub(CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceDisplayPropertiesKHR_CMockReturnMemThruPtr_pPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPropertyCount, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPropertyCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Val = pPropertyCount; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Size = cmock_size; +} + +void vkGetPhysicalDeviceDisplayPropertiesKHR_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkDisplayPropertiesKHR const* pProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pProperties_Val = pProperties; + cmock_call_instance->ReturnThruPtr_pProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceDisplayPropertiesKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceDisplayPropertiesKHR_CMockIgnoreArg_pPropertyCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPropertyCount = 1; +} + +void vkGetPhysicalDeviceDisplayPropertiesKHR_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceDisplayPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pProperties = 1; +} + +VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceDisplayPlanePropertiesKHR); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallInstance); + Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallInstance); + if (Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallbackBool && + Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallbackFunctionPointer(physicalDevice, pPropertyCount, pProperties, Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceDisplayPlanePropertiesKHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPropertyCount) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceDisplayPlanePropertiesKHR,CMockString_pPropertyCount); + if (cmock_call_instance->Expected_pPropertyCount == NULL) + { UNITY_TEST_ASSERT_NULL(pPropertyCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pPropertyCount, pPropertyCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceDisplayPlanePropertiesKHR,CMockString_pProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pProperties), (void*)(pProperties), sizeof(VkDisplayPlanePropertiesKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallbackFunctionPointer(physicalDevice, pPropertyCount, pProperties, Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPropertyCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPropertyCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPropertyCount, (const void*)cmock_call_instance->ReturnThruPtr_pPropertyCount_Val, + cmock_call_instance->ReturnThruPtr_pPropertyCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pProperties, (const void*)cmock_call_instance->ReturnThruPtr_pProperties_Val, + cmock_call_instance->ReturnThruPtr_pProperties_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties); +void CMockExpectParameters_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pPropertyCount = pPropertyCount; + cmock_call_instance->IgnoreArg_pPropertyCount = 0; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Used = 0; + cmock_call_instance->Expected_pProperties = pProperties; + cmock_call_instance->IgnoreArg_pProperties = 0; + cmock_call_instance->ReturnThruPtr_pProperties_Used = 0; +} + +void vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_IgnoreBool) + Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallInstance); + Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(cmock_call_instance, physicalDevice, pPropertyCount, pProperties); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPhysicalDeviceDisplayPlanePropertiesKHR_AddCallback(CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceDisplayPlanePropertiesKHR_Stub(CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockReturnMemThruPtr_pPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPropertyCount, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPropertyCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Val = pPropertyCount; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Size = cmock_size; +} + +void vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkDisplayPlanePropertiesKHR const* pProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pProperties_Val = pProperties; + cmock_call_instance->ReturnThruPtr_pProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockIgnoreArg_pPropertyCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPropertyCount = 1; +} + +void vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pProperties = 1; +} + +VkResult vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDisplayPlaneSupportedDisplaysKHR); + cmock_call_instance = (CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDisplayPlaneSupportedDisplaysKHR_CallInstance); + Mock.vkGetDisplayPlaneSupportedDisplaysKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetDisplayPlaneSupportedDisplaysKHR_CallInstance); + if (Mock.vkGetDisplayPlaneSupportedDisplaysKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetDisplayPlaneSupportedDisplaysKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetDisplayPlaneSupportedDisplaysKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetDisplayPlaneSupportedDisplaysKHR_CallbackBool && + Mock.vkGetDisplayPlaneSupportedDisplaysKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetDisplayPlaneSupportedDisplaysKHR_CallbackFunctionPointer(physicalDevice, planeIndex, pDisplayCount, pDisplays, Mock.vkGetDisplayPlaneSupportedDisplaysKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetDisplayPlaneSupportedDisplaysKHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_planeIndex) + { + UNITY_SET_DETAILS(CMockString_vkGetDisplayPlaneSupportedDisplaysKHR,CMockString_planeIndex); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_planeIndex, planeIndex, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDisplayCount) + { + UNITY_SET_DETAILS(CMockString_vkGetDisplayPlaneSupportedDisplaysKHR,CMockString_pDisplayCount); + if (cmock_call_instance->Expected_pDisplayCount == NULL) + { UNITY_TEST_ASSERT_NULL(pDisplayCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pDisplayCount, pDisplayCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pDisplays) + { + UNITY_SET_DETAILS(CMockString_vkGetDisplayPlaneSupportedDisplaysKHR,CMockString_pDisplays); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDisplays), (void*)(pDisplays), sizeof(VkDisplayKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDisplayPlaneSupportedDisplaysKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetDisplayPlaneSupportedDisplaysKHR_CallbackFunctionPointer(physicalDevice, planeIndex, pDisplayCount, pDisplays, Mock.vkGetDisplayPlaneSupportedDisplaysKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pDisplayCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pDisplayCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pDisplayCount, (const void*)cmock_call_instance->ReturnThruPtr_pDisplayCount_Val, + cmock_call_instance->ReturnThruPtr_pDisplayCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pDisplays_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pDisplays, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pDisplays, (const void*)cmock_call_instance->ReturnThruPtr_pDisplays_Val, + cmock_call_instance->ReturnThruPtr_pDisplays_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetDisplayPlaneSupportedDisplaysKHR(CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays); +void CMockExpectParameters_vkGetDisplayPlaneSupportedDisplaysKHR(CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_planeIndex = planeIndex; + cmock_call_instance->IgnoreArg_planeIndex = 0; + cmock_call_instance->Expected_pDisplayCount = pDisplayCount; + cmock_call_instance->IgnoreArg_pDisplayCount = 0; + cmock_call_instance->ReturnThruPtr_pDisplayCount_Used = 0; + cmock_call_instance->Expected_pDisplays = pDisplays; + cmock_call_instance->IgnoreArg_pDisplays = 0; + cmock_call_instance->ReturnThruPtr_pDisplays_Used = 0; +} + +void vkGetDisplayPlaneSupportedDisplaysKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALL_INSTANCE)); + CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDisplayPlaneSupportedDisplaysKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDisplayPlaneSupportedDisplaysKHR_CallInstance, cmock_guts_index); + Mock.vkGetDisplayPlaneSupportedDisplaysKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetDisplayPlaneSupportedDisplaysKHR_IgnoreBool = (char)1; +} + +void vkGetDisplayPlaneSupportedDisplaysKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetDisplayPlaneSupportedDisplaysKHR_IgnoreBool) + Mock.vkGetDisplayPlaneSupportedDisplaysKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetDisplayPlaneSupportedDisplaysKHR_CallInstance); + Mock.vkGetDisplayPlaneSupportedDisplaysKHR_IgnoreBool = (char)0; +} + +void vkGetDisplayPlaneSupportedDisplaysKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALL_INSTANCE)); + CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDisplayPlaneSupportedDisplaysKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDisplayPlaneSupportedDisplaysKHR_CallInstance, cmock_guts_index); + Mock.vkGetDisplayPlaneSupportedDisplaysKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDisplayPlaneSupportedDisplaysKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALL_INSTANCE)); + CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDisplayPlaneSupportedDisplaysKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDisplayPlaneSupportedDisplaysKHR_CallInstance, cmock_guts_index); + Mock.vkGetDisplayPlaneSupportedDisplaysKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDisplayPlaneSupportedDisplaysKHR(cmock_call_instance, physicalDevice, planeIndex, pDisplayCount, pDisplays); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetDisplayPlaneSupportedDisplaysKHR_AddCallback(CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALLBACK Callback) +{ + Mock.vkGetDisplayPlaneSupportedDisplaysKHR_IgnoreBool = (char)0; + Mock.vkGetDisplayPlaneSupportedDisplaysKHR_CallbackBool = (char)1; + Mock.vkGetDisplayPlaneSupportedDisplaysKHR_CallbackFunctionPointer = Callback; +} + +void vkGetDisplayPlaneSupportedDisplaysKHR_Stub(CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALLBACK Callback) +{ + Mock.vkGetDisplayPlaneSupportedDisplaysKHR_IgnoreBool = (char)0; + Mock.vkGetDisplayPlaneSupportedDisplaysKHR_CallbackBool = (char)0; + Mock.vkGetDisplayPlaneSupportedDisplaysKHR_CallbackFunctionPointer = Callback; +} + +void vkGetDisplayPlaneSupportedDisplaysKHR_CMockReturnMemThruPtr_pDisplayCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pDisplayCount, size_t cmock_size) +{ + CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDisplayPlaneSupportedDisplaysKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pDisplayCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pDisplayCount_Val = pDisplayCount; + cmock_call_instance->ReturnThruPtr_pDisplayCount_Size = cmock_size; +} + +void vkGetDisplayPlaneSupportedDisplaysKHR_CMockReturnMemThruPtr_pDisplays(UNITY_LINE_TYPE cmock_line, VkDisplayKHR const* pDisplays, size_t cmock_size) +{ + CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDisplayPlaneSupportedDisplaysKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pDisplays_Used = 1; + cmock_call_instance->ReturnThruPtr_pDisplays_Val = pDisplays; + cmock_call_instance->ReturnThruPtr_pDisplays_Size = cmock_size; +} + +void vkGetDisplayPlaneSupportedDisplaysKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDisplayPlaneSupportedDisplaysKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetDisplayPlaneSupportedDisplaysKHR_CMockIgnoreArg_planeIndex(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDisplayPlaneSupportedDisplaysKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_planeIndex = 1; +} + +void vkGetDisplayPlaneSupportedDisplaysKHR_CMockIgnoreArg_pDisplayCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDisplayPlaneSupportedDisplaysKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDisplayCount = 1; +} + +void vkGetDisplayPlaneSupportedDisplaysKHR_CMockIgnoreArg_pDisplays(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDisplayPlaneSupportedDisplaysKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDisplays = 1; +} + +VkResult vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDisplayModePropertiesKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDisplayModePropertiesKHR); + cmock_call_instance = (CMOCK_vkGetDisplayModePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDisplayModePropertiesKHR_CallInstance); + Mock.vkGetDisplayModePropertiesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetDisplayModePropertiesKHR_CallInstance); + if (Mock.vkGetDisplayModePropertiesKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetDisplayModePropertiesKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetDisplayModePropertiesKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetDisplayModePropertiesKHR_CallbackBool && + Mock.vkGetDisplayModePropertiesKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetDisplayModePropertiesKHR_CallbackFunctionPointer(physicalDevice, display, pPropertyCount, pProperties, Mock.vkGetDisplayModePropertiesKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetDisplayModePropertiesKHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_display) + { + UNITY_SET_DETAILS(CMockString_vkGetDisplayModePropertiesKHR,CMockString_display); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_display), (void*)(&display), sizeof(VkDisplayKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPropertyCount) + { + UNITY_SET_DETAILS(CMockString_vkGetDisplayModePropertiesKHR,CMockString_pPropertyCount); + if (cmock_call_instance->Expected_pPropertyCount == NULL) + { UNITY_TEST_ASSERT_NULL(pPropertyCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pPropertyCount, pPropertyCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetDisplayModePropertiesKHR,CMockString_pProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pProperties), (void*)(pProperties), sizeof(VkDisplayModePropertiesKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDisplayModePropertiesKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetDisplayModePropertiesKHR_CallbackFunctionPointer(physicalDevice, display, pPropertyCount, pProperties, Mock.vkGetDisplayModePropertiesKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPropertyCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPropertyCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPropertyCount, (const void*)cmock_call_instance->ReturnThruPtr_pPropertyCount_Val, + cmock_call_instance->ReturnThruPtr_pPropertyCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pProperties, (const void*)cmock_call_instance->ReturnThruPtr_pProperties_Val, + cmock_call_instance->ReturnThruPtr_pProperties_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetDisplayModePropertiesKHR(CMOCK_vkGetDisplayModePropertiesKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties); +void CMockExpectParameters_vkGetDisplayModePropertiesKHR(CMOCK_vkGetDisplayModePropertiesKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + memcpy((void*)(&cmock_call_instance->Expected_display), (void*)(&display), + sizeof(VkDisplayKHR[sizeof(display) == sizeof(VkDisplayKHR) ? 1 : -1])); /* add VkDisplayKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_display = 0; + cmock_call_instance->Expected_pPropertyCount = pPropertyCount; + cmock_call_instance->IgnoreArg_pPropertyCount = 0; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Used = 0; + cmock_call_instance->Expected_pProperties = pProperties; + cmock_call_instance->IgnoreArg_pProperties = 0; + cmock_call_instance->ReturnThruPtr_pProperties_Used = 0; +} + +void vkGetDisplayModePropertiesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDisplayModePropertiesKHR_CALL_INSTANCE)); + CMOCK_vkGetDisplayModePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayModePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDisplayModePropertiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDisplayModePropertiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetDisplayModePropertiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetDisplayModePropertiesKHR_IgnoreBool = (char)1; +} + +void vkGetDisplayModePropertiesKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetDisplayModePropertiesKHR_IgnoreBool) + Mock.vkGetDisplayModePropertiesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetDisplayModePropertiesKHR_CallInstance); + Mock.vkGetDisplayModePropertiesKHR_IgnoreBool = (char)0; +} + +void vkGetDisplayModePropertiesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDisplayModePropertiesKHR_CALL_INSTANCE)); + CMOCK_vkGetDisplayModePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayModePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDisplayModePropertiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDisplayModePropertiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetDisplayModePropertiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDisplayModePropertiesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDisplayModePropertiesKHR_CALL_INSTANCE)); + CMOCK_vkGetDisplayModePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayModePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDisplayModePropertiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDisplayModePropertiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetDisplayModePropertiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDisplayModePropertiesKHR(cmock_call_instance, physicalDevice, display, pPropertyCount, pProperties); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetDisplayModePropertiesKHR_AddCallback(CMOCK_vkGetDisplayModePropertiesKHR_CALLBACK Callback) +{ + Mock.vkGetDisplayModePropertiesKHR_IgnoreBool = (char)0; + Mock.vkGetDisplayModePropertiesKHR_CallbackBool = (char)1; + Mock.vkGetDisplayModePropertiesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetDisplayModePropertiesKHR_Stub(CMOCK_vkGetDisplayModePropertiesKHR_CALLBACK Callback) +{ + Mock.vkGetDisplayModePropertiesKHR_IgnoreBool = (char)0; + Mock.vkGetDisplayModePropertiesKHR_CallbackBool = (char)0; + Mock.vkGetDisplayModePropertiesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetDisplayModePropertiesKHR_CMockReturnMemThruPtr_pPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPropertyCount, size_t cmock_size) +{ + CMOCK_vkGetDisplayModePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayModePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDisplayModePropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPropertyCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Val = pPropertyCount; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Size = cmock_size; +} + +void vkGetDisplayModePropertiesKHR_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkDisplayModePropertiesKHR const* pProperties, size_t cmock_size) +{ + CMOCK_vkGetDisplayModePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayModePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDisplayModePropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pProperties_Val = pProperties; + cmock_call_instance->ReturnThruPtr_pProperties_Size = cmock_size; +} + +void vkGetDisplayModePropertiesKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDisplayModePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayModePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDisplayModePropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetDisplayModePropertiesKHR_CMockIgnoreArg_display(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDisplayModePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayModePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDisplayModePropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_display = 1; +} + +void vkGetDisplayModePropertiesKHR_CMockIgnoreArg_pPropertyCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDisplayModePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayModePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDisplayModePropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPropertyCount = 1; +} + +void vkGetDisplayModePropertiesKHR_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDisplayModePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayModePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDisplayModePropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pProperties = 1; +} + +VkResult vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateDisplayModeKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateDisplayModeKHR); + cmock_call_instance = (CMOCK_vkCreateDisplayModeKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateDisplayModeKHR_CallInstance); + Mock.vkCreateDisplayModeKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCreateDisplayModeKHR_CallInstance); + if (Mock.vkCreateDisplayModeKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateDisplayModeKHR_FinalReturn; + memcpy((void*)(&Mock.vkCreateDisplayModeKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateDisplayModeKHR_CallbackBool && + Mock.vkCreateDisplayModeKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateDisplayModeKHR_CallbackFunctionPointer(physicalDevice, display, pCreateInfo, pAllocator, pMode, Mock.vkCreateDisplayModeKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkCreateDisplayModeKHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_display) + { + UNITY_SET_DETAILS(CMockString_vkCreateDisplayModeKHR,CMockString_display); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_display), (void*)(&display), sizeof(VkDisplayKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateDisplayModeKHR,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkDisplayModeCreateInfoKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateDisplayModeKHR,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMode) + { + UNITY_SET_DETAILS(CMockString_vkCreateDisplayModeKHR,CMockString_pMode); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMode), (void*)(pMode), sizeof(VkDisplayModeKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateDisplayModeKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateDisplayModeKHR_CallbackFunctionPointer(physicalDevice, display, pCreateInfo, pAllocator, pMode, Mock.vkCreateDisplayModeKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pMode_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pMode, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pMode, (const void*)cmock_call_instance->ReturnThruPtr_pMode_Val, + cmock_call_instance->ReturnThruPtr_pMode_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateDisplayModeKHR(CMOCK_vkCreateDisplayModeKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode); +void CMockExpectParameters_vkCreateDisplayModeKHR(CMOCK_vkCreateDisplayModeKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + memcpy((void*)(&cmock_call_instance->Expected_display), (void*)(&display), + sizeof(VkDisplayKHR[sizeof(display) == sizeof(VkDisplayKHR) ? 1 : -1])); /* add VkDisplayKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_display = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pMode = pMode; + cmock_call_instance->IgnoreArg_pMode = 0; + cmock_call_instance->ReturnThruPtr_pMode_Used = 0; +} + +void vkCreateDisplayModeKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateDisplayModeKHR_CALL_INSTANCE)); + CMOCK_vkCreateDisplayModeKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDisplayModeKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateDisplayModeKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateDisplayModeKHR_CallInstance, cmock_guts_index); + Mock.vkCreateDisplayModeKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateDisplayModeKHR_IgnoreBool = (char)1; +} + +void vkCreateDisplayModeKHR_CMockStopIgnore(void) +{ + if(Mock.vkCreateDisplayModeKHR_IgnoreBool) + Mock.vkCreateDisplayModeKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCreateDisplayModeKHR_CallInstance); + Mock.vkCreateDisplayModeKHR_IgnoreBool = (char)0; +} + +void vkCreateDisplayModeKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateDisplayModeKHR_CALL_INSTANCE)); + CMOCK_vkCreateDisplayModeKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDisplayModeKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateDisplayModeKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateDisplayModeKHR_CallInstance, cmock_guts_index); + Mock.vkCreateDisplayModeKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateDisplayModeKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateDisplayModeKHR_CALL_INSTANCE)); + CMOCK_vkCreateDisplayModeKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDisplayModeKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateDisplayModeKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateDisplayModeKHR_CallInstance, cmock_guts_index); + Mock.vkCreateDisplayModeKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateDisplayModeKHR(cmock_call_instance, physicalDevice, display, pCreateInfo, pAllocator, pMode); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateDisplayModeKHR_AddCallback(CMOCK_vkCreateDisplayModeKHR_CALLBACK Callback) +{ + Mock.vkCreateDisplayModeKHR_IgnoreBool = (char)0; + Mock.vkCreateDisplayModeKHR_CallbackBool = (char)1; + Mock.vkCreateDisplayModeKHR_CallbackFunctionPointer = Callback; +} + +void vkCreateDisplayModeKHR_Stub(CMOCK_vkCreateDisplayModeKHR_CALLBACK Callback) +{ + Mock.vkCreateDisplayModeKHR_IgnoreBool = (char)0; + Mock.vkCreateDisplayModeKHR_CallbackBool = (char)0; + Mock.vkCreateDisplayModeKHR_CallbackFunctionPointer = Callback; +} + +void vkCreateDisplayModeKHR_CMockReturnMemThruPtr_pMode(UNITY_LINE_TYPE cmock_line, VkDisplayModeKHR const* pMode, size_t cmock_size) +{ + CMOCK_vkCreateDisplayModeKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDisplayModeKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDisplayModeKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pMode_Used = 1; + cmock_call_instance->ReturnThruPtr_pMode_Val = pMode; + cmock_call_instance->ReturnThruPtr_pMode_Size = cmock_size; +} + +void vkCreateDisplayModeKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDisplayModeKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDisplayModeKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDisplayModeKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkCreateDisplayModeKHR_CMockIgnoreArg_display(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDisplayModeKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDisplayModeKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDisplayModeKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_display = 1; +} + +void vkCreateDisplayModeKHR_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDisplayModeKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDisplayModeKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDisplayModeKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateDisplayModeKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDisplayModeKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDisplayModeKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDisplayModeKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateDisplayModeKHR_CMockIgnoreArg_pMode(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDisplayModeKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDisplayModeKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDisplayModeKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMode = 1; +} + +VkResult vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDisplayPlaneCapabilitiesKHR); + cmock_call_instance = (CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDisplayPlaneCapabilitiesKHR_CallInstance); + Mock.vkGetDisplayPlaneCapabilitiesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetDisplayPlaneCapabilitiesKHR_CallInstance); + if (Mock.vkGetDisplayPlaneCapabilitiesKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetDisplayPlaneCapabilitiesKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetDisplayPlaneCapabilitiesKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetDisplayPlaneCapabilitiesKHR_CallbackBool && + Mock.vkGetDisplayPlaneCapabilitiesKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetDisplayPlaneCapabilitiesKHR_CallbackFunctionPointer(physicalDevice, mode, planeIndex, pCapabilities, Mock.vkGetDisplayPlaneCapabilitiesKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetDisplayPlaneCapabilitiesKHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_mode) + { + UNITY_SET_DETAILS(CMockString_vkGetDisplayPlaneCapabilitiesKHR,CMockString_mode); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_mode), (void*)(&mode), sizeof(VkDisplayModeKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_planeIndex) + { + UNITY_SET_DETAILS(CMockString_vkGetDisplayPlaneCapabilitiesKHR,CMockString_planeIndex); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_planeIndex, planeIndex, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCapabilities) + { + UNITY_SET_DETAILS(CMockString_vkGetDisplayPlaneCapabilitiesKHR,CMockString_pCapabilities); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCapabilities), (void*)(pCapabilities), sizeof(VkDisplayPlaneCapabilitiesKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDisplayPlaneCapabilitiesKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetDisplayPlaneCapabilitiesKHR_CallbackFunctionPointer(physicalDevice, mode, planeIndex, pCapabilities, Mock.vkGetDisplayPlaneCapabilitiesKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pCapabilities_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pCapabilities, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pCapabilities, (const void*)cmock_call_instance->ReturnThruPtr_pCapabilities_Val, + cmock_call_instance->ReturnThruPtr_pCapabilities_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetDisplayPlaneCapabilitiesKHR(CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities); +void CMockExpectParameters_vkGetDisplayPlaneCapabilitiesKHR(CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + memcpy((void*)(&cmock_call_instance->Expected_mode), (void*)(&mode), + sizeof(VkDisplayModeKHR[sizeof(mode) == sizeof(VkDisplayModeKHR) ? 1 : -1])); /* add VkDisplayModeKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_mode = 0; + cmock_call_instance->Expected_planeIndex = planeIndex; + cmock_call_instance->IgnoreArg_planeIndex = 0; + cmock_call_instance->Expected_pCapabilities = pCapabilities; + cmock_call_instance->IgnoreArg_pCapabilities = 0; + cmock_call_instance->ReturnThruPtr_pCapabilities_Used = 0; +} + +void vkGetDisplayPlaneCapabilitiesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALL_INSTANCE)); + CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDisplayPlaneCapabilitiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDisplayPlaneCapabilitiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetDisplayPlaneCapabilitiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetDisplayPlaneCapabilitiesKHR_IgnoreBool = (char)1; +} + +void vkGetDisplayPlaneCapabilitiesKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetDisplayPlaneCapabilitiesKHR_IgnoreBool) + Mock.vkGetDisplayPlaneCapabilitiesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetDisplayPlaneCapabilitiesKHR_CallInstance); + Mock.vkGetDisplayPlaneCapabilitiesKHR_IgnoreBool = (char)0; +} + +void vkGetDisplayPlaneCapabilitiesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALL_INSTANCE)); + CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDisplayPlaneCapabilitiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDisplayPlaneCapabilitiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetDisplayPlaneCapabilitiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDisplayPlaneCapabilitiesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALL_INSTANCE)); + CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDisplayPlaneCapabilitiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDisplayPlaneCapabilitiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetDisplayPlaneCapabilitiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDisplayPlaneCapabilitiesKHR(cmock_call_instance, physicalDevice, mode, planeIndex, pCapabilities); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetDisplayPlaneCapabilitiesKHR_AddCallback(CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALLBACK Callback) +{ + Mock.vkGetDisplayPlaneCapabilitiesKHR_IgnoreBool = (char)0; + Mock.vkGetDisplayPlaneCapabilitiesKHR_CallbackBool = (char)1; + Mock.vkGetDisplayPlaneCapabilitiesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetDisplayPlaneCapabilitiesKHR_Stub(CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALLBACK Callback) +{ + Mock.vkGetDisplayPlaneCapabilitiesKHR_IgnoreBool = (char)0; + Mock.vkGetDisplayPlaneCapabilitiesKHR_CallbackBool = (char)0; + Mock.vkGetDisplayPlaneCapabilitiesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetDisplayPlaneCapabilitiesKHR_CMockReturnMemThruPtr_pCapabilities(UNITY_LINE_TYPE cmock_line, VkDisplayPlaneCapabilitiesKHR const* pCapabilities, size_t cmock_size) +{ + CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDisplayPlaneCapabilitiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pCapabilities_Used = 1; + cmock_call_instance->ReturnThruPtr_pCapabilities_Val = pCapabilities; + cmock_call_instance->ReturnThruPtr_pCapabilities_Size = cmock_size; +} + +void vkGetDisplayPlaneCapabilitiesKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDisplayPlaneCapabilitiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetDisplayPlaneCapabilitiesKHR_CMockIgnoreArg_mode(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDisplayPlaneCapabilitiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_mode = 1; +} + +void vkGetDisplayPlaneCapabilitiesKHR_CMockIgnoreArg_planeIndex(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDisplayPlaneCapabilitiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_planeIndex = 1; +} + +void vkGetDisplayPlaneCapabilitiesKHR_CMockIgnoreArg_pCapabilities(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDisplayPlaneCapabilitiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCapabilities = 1; +} + +VkResult vkCreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateDisplayPlaneSurfaceKHR); + cmock_call_instance = (CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateDisplayPlaneSurfaceKHR_CallInstance); + Mock.vkCreateDisplayPlaneSurfaceKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCreateDisplayPlaneSurfaceKHR_CallInstance); + if (Mock.vkCreateDisplayPlaneSurfaceKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateDisplayPlaneSurfaceKHR_FinalReturn; + memcpy((void*)(&Mock.vkCreateDisplayPlaneSurfaceKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateDisplayPlaneSurfaceKHR_CallbackBool && + Mock.vkCreateDisplayPlaneSurfaceKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateDisplayPlaneSurfaceKHR_CallbackFunctionPointer(instance, pCreateInfo, pAllocator, pSurface, Mock.vkCreateDisplayPlaneSurfaceKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_instance) + { + UNITY_SET_DETAILS(CMockString_vkCreateDisplayPlaneSurfaceKHR,CMockString_instance); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), sizeof(VkInstance), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateDisplayPlaneSurfaceKHR,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkDisplaySurfaceCreateInfoKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateDisplayPlaneSurfaceKHR,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSurface) + { + UNITY_SET_DETAILS(CMockString_vkCreateDisplayPlaneSurfaceKHR,CMockString_pSurface); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSurface), (void*)(pSurface), sizeof(VkSurfaceKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateDisplayPlaneSurfaceKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateDisplayPlaneSurfaceKHR_CallbackFunctionPointer(instance, pCreateInfo, pAllocator, pSurface, Mock.vkCreateDisplayPlaneSurfaceKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pSurface_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSurface, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSurface, (const void*)cmock_call_instance->ReturnThruPtr_pSurface_Val, + cmock_call_instance->ReturnThruPtr_pSurface_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateDisplayPlaneSurfaceKHR(CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALL_INSTANCE* cmock_call_instance, VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +void CMockExpectParameters_vkCreateDisplayPlaneSurfaceKHR(CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALL_INSTANCE* cmock_call_instance, VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) +{ + memcpy((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), + sizeof(VkInstance[sizeof(instance) == sizeof(VkInstance) ? 1 : -1])); /* add VkInstance to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_instance = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pSurface = pSurface; + cmock_call_instance->IgnoreArg_pSurface = 0; + cmock_call_instance->ReturnThruPtr_pSurface_Used = 0; +} + +void vkCreateDisplayPlaneSurfaceKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALL_INSTANCE)); + CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateDisplayPlaneSurfaceKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateDisplayPlaneSurfaceKHR_CallInstance, cmock_guts_index); + Mock.vkCreateDisplayPlaneSurfaceKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateDisplayPlaneSurfaceKHR_IgnoreBool = (char)1; +} + +void vkCreateDisplayPlaneSurfaceKHR_CMockStopIgnore(void) +{ + if(Mock.vkCreateDisplayPlaneSurfaceKHR_IgnoreBool) + Mock.vkCreateDisplayPlaneSurfaceKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCreateDisplayPlaneSurfaceKHR_CallInstance); + Mock.vkCreateDisplayPlaneSurfaceKHR_IgnoreBool = (char)0; +} + +void vkCreateDisplayPlaneSurfaceKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALL_INSTANCE)); + CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateDisplayPlaneSurfaceKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateDisplayPlaneSurfaceKHR_CallInstance, cmock_guts_index); + Mock.vkCreateDisplayPlaneSurfaceKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateDisplayPlaneSurfaceKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALL_INSTANCE)); + CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateDisplayPlaneSurfaceKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateDisplayPlaneSurfaceKHR_CallInstance, cmock_guts_index); + Mock.vkCreateDisplayPlaneSurfaceKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateDisplayPlaneSurfaceKHR(cmock_call_instance, instance, pCreateInfo, pAllocator, pSurface); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateDisplayPlaneSurfaceKHR_AddCallback(CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALLBACK Callback) +{ + Mock.vkCreateDisplayPlaneSurfaceKHR_IgnoreBool = (char)0; + Mock.vkCreateDisplayPlaneSurfaceKHR_CallbackBool = (char)1; + Mock.vkCreateDisplayPlaneSurfaceKHR_CallbackFunctionPointer = Callback; +} + +void vkCreateDisplayPlaneSurfaceKHR_Stub(CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALLBACK Callback) +{ + Mock.vkCreateDisplayPlaneSurfaceKHR_IgnoreBool = (char)0; + Mock.vkCreateDisplayPlaneSurfaceKHR_CallbackBool = (char)0; + Mock.vkCreateDisplayPlaneSurfaceKHR_CallbackFunctionPointer = Callback; +} + +void vkCreateDisplayPlaneSurfaceKHR_CMockReturnMemThruPtr_pSurface(UNITY_LINE_TYPE cmock_line, VkSurfaceKHR const* pSurface, size_t cmock_size) +{ + CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDisplayPlaneSurfaceKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSurface_Used = 1; + cmock_call_instance->ReturnThruPtr_pSurface_Val = pSurface; + cmock_call_instance->ReturnThruPtr_pSurface_Size = cmock_size; +} + +void vkCreateDisplayPlaneSurfaceKHR_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDisplayPlaneSurfaceKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_instance = 1; +} + +void vkCreateDisplayPlaneSurfaceKHR_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDisplayPlaneSurfaceKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateDisplayPlaneSurfaceKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDisplayPlaneSurfaceKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateDisplayPlaneSurfaceKHR_CMockIgnoreArg_pSurface(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDisplayPlaneSurfaceKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSurface = 1; +} + +VkResult vkCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateSharedSwapchainsKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateSharedSwapchainsKHR); + cmock_call_instance = (CMOCK_vkCreateSharedSwapchainsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateSharedSwapchainsKHR_CallInstance); + Mock.vkCreateSharedSwapchainsKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCreateSharedSwapchainsKHR_CallInstance); + if (Mock.vkCreateSharedSwapchainsKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateSharedSwapchainsKHR_FinalReturn; + memcpy((void*)(&Mock.vkCreateSharedSwapchainsKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateSharedSwapchainsKHR_CallbackBool && + Mock.vkCreateSharedSwapchainsKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateSharedSwapchainsKHR_CallbackFunctionPointer(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains, Mock.vkCreateSharedSwapchainsKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateSharedSwapchainsKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_swapchainCount) + { + UNITY_SET_DETAILS(CMockString_vkCreateSharedSwapchainsKHR,CMockString_swapchainCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_swapchainCount, swapchainCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfos) + { + UNITY_SET_DETAILS(CMockString_vkCreateSharedSwapchainsKHR,CMockString_pCreateInfos); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfos), (void*)(pCreateInfos), sizeof(const VkSwapchainCreateInfoKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateSharedSwapchainsKHR,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSwapchains) + { + UNITY_SET_DETAILS(CMockString_vkCreateSharedSwapchainsKHR,CMockString_pSwapchains); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSwapchains), (void*)(pSwapchains), sizeof(VkSwapchainKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateSharedSwapchainsKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateSharedSwapchainsKHR_CallbackFunctionPointer(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains, Mock.vkCreateSharedSwapchainsKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pSwapchains_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSwapchains, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSwapchains, (const void*)cmock_call_instance->ReturnThruPtr_pSwapchains_Val, + cmock_call_instance->ReturnThruPtr_pSwapchains_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateSharedSwapchainsKHR(CMOCK_vkCreateSharedSwapchainsKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains); +void CMockExpectParameters_vkCreateSharedSwapchainsKHR(CMOCK_vkCreateSharedSwapchainsKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_swapchainCount = swapchainCount; + cmock_call_instance->IgnoreArg_swapchainCount = 0; + cmock_call_instance->Expected_pCreateInfos = pCreateInfos; + cmock_call_instance->IgnoreArg_pCreateInfos = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pSwapchains = pSwapchains; + cmock_call_instance->IgnoreArg_pSwapchains = 0; + cmock_call_instance->ReturnThruPtr_pSwapchains_Used = 0; +} + +void vkCreateSharedSwapchainsKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateSharedSwapchainsKHR_CALL_INSTANCE)); + CMOCK_vkCreateSharedSwapchainsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSharedSwapchainsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateSharedSwapchainsKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateSharedSwapchainsKHR_CallInstance, cmock_guts_index); + Mock.vkCreateSharedSwapchainsKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateSharedSwapchainsKHR_IgnoreBool = (char)1; +} + +void vkCreateSharedSwapchainsKHR_CMockStopIgnore(void) +{ + if(Mock.vkCreateSharedSwapchainsKHR_IgnoreBool) + Mock.vkCreateSharedSwapchainsKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCreateSharedSwapchainsKHR_CallInstance); + Mock.vkCreateSharedSwapchainsKHR_IgnoreBool = (char)0; +} + +void vkCreateSharedSwapchainsKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateSharedSwapchainsKHR_CALL_INSTANCE)); + CMOCK_vkCreateSharedSwapchainsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSharedSwapchainsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateSharedSwapchainsKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateSharedSwapchainsKHR_CallInstance, cmock_guts_index); + Mock.vkCreateSharedSwapchainsKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateSharedSwapchainsKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateSharedSwapchainsKHR_CALL_INSTANCE)); + CMOCK_vkCreateSharedSwapchainsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSharedSwapchainsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateSharedSwapchainsKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateSharedSwapchainsKHR_CallInstance, cmock_guts_index); + Mock.vkCreateSharedSwapchainsKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateSharedSwapchainsKHR(cmock_call_instance, device, swapchainCount, pCreateInfos, pAllocator, pSwapchains); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateSharedSwapchainsKHR_AddCallback(CMOCK_vkCreateSharedSwapchainsKHR_CALLBACK Callback) +{ + Mock.vkCreateSharedSwapchainsKHR_IgnoreBool = (char)0; + Mock.vkCreateSharedSwapchainsKHR_CallbackBool = (char)1; + Mock.vkCreateSharedSwapchainsKHR_CallbackFunctionPointer = Callback; +} + +void vkCreateSharedSwapchainsKHR_Stub(CMOCK_vkCreateSharedSwapchainsKHR_CALLBACK Callback) +{ + Mock.vkCreateSharedSwapchainsKHR_IgnoreBool = (char)0; + Mock.vkCreateSharedSwapchainsKHR_CallbackBool = (char)0; + Mock.vkCreateSharedSwapchainsKHR_CallbackFunctionPointer = Callback; +} + +void vkCreateSharedSwapchainsKHR_CMockReturnMemThruPtr_pSwapchains(UNITY_LINE_TYPE cmock_line, VkSwapchainKHR const* pSwapchains, size_t cmock_size) +{ + CMOCK_vkCreateSharedSwapchainsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSharedSwapchainsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSharedSwapchainsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSwapchains_Used = 1; + cmock_call_instance->ReturnThruPtr_pSwapchains_Val = pSwapchains; + cmock_call_instance->ReturnThruPtr_pSwapchains_Size = cmock_size; +} + +void vkCreateSharedSwapchainsKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateSharedSwapchainsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSharedSwapchainsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSharedSwapchainsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateSharedSwapchainsKHR_CMockIgnoreArg_swapchainCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateSharedSwapchainsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSharedSwapchainsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSharedSwapchainsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_swapchainCount = 1; +} + +void vkCreateSharedSwapchainsKHR_CMockIgnoreArg_pCreateInfos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateSharedSwapchainsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSharedSwapchainsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSharedSwapchainsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfos = 1; +} + +void vkCreateSharedSwapchainsKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateSharedSwapchainsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSharedSwapchainsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSharedSwapchainsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateSharedSwapchainsKHR_CMockIgnoreArg_pSwapchains(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateSharedSwapchainsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSharedSwapchainsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSharedSwapchainsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSwapchains = 1; +} + +VkResult vkGetPhysicalDeviceVideoCapabilitiesKHR(VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceVideoCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceVideoCapabilitiesKHR); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceVideoCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_CallInstance); + Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_CallInstance); + if (Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_CallbackBool && + Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_CallbackFunctionPointer(physicalDevice, pVideoProfile, pCapabilities, Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceVideoCapabilitiesKHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pVideoProfile) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceVideoCapabilitiesKHR,CMockString_pVideoProfile); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pVideoProfile), (void*)(pVideoProfile), sizeof(const VkVideoProfileInfoKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCapabilities) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceVideoCapabilitiesKHR,CMockString_pCapabilities); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCapabilities), (void*)(pCapabilities), sizeof(VkVideoCapabilitiesKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_CallbackFunctionPointer(physicalDevice, pVideoProfile, pCapabilities, Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pCapabilities_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pCapabilities, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pCapabilities, (const void*)cmock_call_instance->ReturnThruPtr_pCapabilities_Val, + cmock_call_instance->ReturnThruPtr_pCapabilities_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPhysicalDeviceVideoCapabilitiesKHR(CMOCK_vkGetPhysicalDeviceVideoCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities); +void CMockExpectParameters_vkGetPhysicalDeviceVideoCapabilitiesKHR(CMOCK_vkGetPhysicalDeviceVideoCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pVideoProfile = pVideoProfile; + cmock_call_instance->IgnoreArg_pVideoProfile = 0; + cmock_call_instance->Expected_pCapabilities = pCapabilities; + cmock_call_instance->IgnoreArg_pCapabilities = 0; + cmock_call_instance->ReturnThruPtr_pCapabilities_Used = 0; +} + +void vkGetPhysicalDeviceVideoCapabilitiesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceVideoCapabilitiesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceVideoCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceVideoCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceVideoCapabilitiesKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_IgnoreBool) + Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_CallInstance); + Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceVideoCapabilitiesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceVideoCapabilitiesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceVideoCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceVideoCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceVideoCapabilitiesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceVideoCapabilitiesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceVideoCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceVideoCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceVideoCapabilitiesKHR(cmock_call_instance, physicalDevice, pVideoProfile, pCapabilities); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPhysicalDeviceVideoCapabilitiesKHR_AddCallback(CMOCK_vkGetPhysicalDeviceVideoCapabilitiesKHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceVideoCapabilitiesKHR_Stub(CMOCK_vkGetPhysicalDeviceVideoCapabilitiesKHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceVideoCapabilitiesKHR_CMockReturnMemThruPtr_pCapabilities(UNITY_LINE_TYPE cmock_line, VkVideoCapabilitiesKHR const* pCapabilities, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceVideoCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceVideoCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pCapabilities_Used = 1; + cmock_call_instance->ReturnThruPtr_pCapabilities_Val = pCapabilities; + cmock_call_instance->ReturnThruPtr_pCapabilities_Size = cmock_size; +} + +void vkGetPhysicalDeviceVideoCapabilitiesKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceVideoCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceVideoCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceVideoCapabilitiesKHR_CMockIgnoreArg_pVideoProfile(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceVideoCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceVideoCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pVideoProfile = 1; +} + +void vkGetPhysicalDeviceVideoCapabilitiesKHR_CMockIgnoreArg_pCapabilities(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceVideoCapabilitiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceVideoCapabilitiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceVideoCapabilitiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCapabilities = 1; +} + +VkResult vkGetPhysicalDeviceVideoFormatPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceVideoFormatPropertiesKHR); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallInstance); + Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallInstance); + if (Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallbackBool && + Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallbackFunctionPointer(physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties, Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceVideoFormatPropertiesKHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pVideoFormatInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceVideoFormatPropertiesKHR,CMockString_pVideoFormatInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pVideoFormatInfo), (void*)(pVideoFormatInfo), sizeof(const VkPhysicalDeviceVideoFormatInfoKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pVideoFormatPropertyCount) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceVideoFormatPropertiesKHR,CMockString_pVideoFormatPropertyCount); + if (cmock_call_instance->Expected_pVideoFormatPropertyCount == NULL) + { UNITY_TEST_ASSERT_NULL(pVideoFormatPropertyCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pVideoFormatPropertyCount, pVideoFormatPropertyCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pVideoFormatProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceVideoFormatPropertiesKHR,CMockString_pVideoFormatProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pVideoFormatProperties), (void*)(pVideoFormatProperties), sizeof(VkVideoFormatPropertiesKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallbackFunctionPointer(physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties, Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pVideoFormatPropertyCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pVideoFormatPropertyCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pVideoFormatPropertyCount, (const void*)cmock_call_instance->ReturnThruPtr_pVideoFormatPropertyCount_Val, + cmock_call_instance->ReturnThruPtr_pVideoFormatPropertyCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pVideoFormatProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pVideoFormatProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pVideoFormatProperties, (const void*)cmock_call_instance->ReturnThruPtr_pVideoFormatProperties_Val, + cmock_call_instance->ReturnThruPtr_pVideoFormatProperties_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPhysicalDeviceVideoFormatPropertiesKHR(CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties); +void CMockExpectParameters_vkGetPhysicalDeviceVideoFormatPropertiesKHR(CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pVideoFormatInfo = pVideoFormatInfo; + cmock_call_instance->IgnoreArg_pVideoFormatInfo = 0; + cmock_call_instance->Expected_pVideoFormatPropertyCount = pVideoFormatPropertyCount; + cmock_call_instance->IgnoreArg_pVideoFormatPropertyCount = 0; + cmock_call_instance->ReturnThruPtr_pVideoFormatPropertyCount_Used = 0; + cmock_call_instance->Expected_pVideoFormatProperties = pVideoFormatProperties; + cmock_call_instance->IgnoreArg_pVideoFormatProperties = 0; + cmock_call_instance->ReturnThruPtr_pVideoFormatProperties_Used = 0; +} + +void vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_IgnoreBool) + Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallInstance); + Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceVideoFormatPropertiesKHR(cmock_call_instance, physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPhysicalDeviceVideoFormatPropertiesKHR_AddCallback(CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceVideoFormatPropertiesKHR_Stub(CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockReturnMemThruPtr_pVideoFormatPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pVideoFormatPropertyCount, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pVideoFormatPropertyCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pVideoFormatPropertyCount_Val = pVideoFormatPropertyCount; + cmock_call_instance->ReturnThruPtr_pVideoFormatPropertyCount_Size = cmock_size; +} + +void vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockReturnMemThruPtr_pVideoFormatProperties(UNITY_LINE_TYPE cmock_line, VkVideoFormatPropertiesKHR const* pVideoFormatProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pVideoFormatProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pVideoFormatProperties_Val = pVideoFormatProperties; + cmock_call_instance->ReturnThruPtr_pVideoFormatProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockIgnoreArg_pVideoFormatInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pVideoFormatInfo = 1; +} + +void vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockIgnoreArg_pVideoFormatPropertyCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pVideoFormatPropertyCount = 1; +} + +void vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockIgnoreArg_pVideoFormatProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceVideoFormatPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pVideoFormatProperties = 1; +} + +VkResult vkCreateVideoSessionKHR(VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateVideoSessionKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateVideoSessionKHR); + cmock_call_instance = (CMOCK_vkCreateVideoSessionKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateVideoSessionKHR_CallInstance); + Mock.vkCreateVideoSessionKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCreateVideoSessionKHR_CallInstance); + if (Mock.vkCreateVideoSessionKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateVideoSessionKHR_FinalReturn; + memcpy((void*)(&Mock.vkCreateVideoSessionKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateVideoSessionKHR_CallbackBool && + Mock.vkCreateVideoSessionKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateVideoSessionKHR_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pVideoSession, Mock.vkCreateVideoSessionKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateVideoSessionKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateVideoSessionKHR,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkVideoSessionCreateInfoKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateVideoSessionKHR,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pVideoSession) + { + UNITY_SET_DETAILS(CMockString_vkCreateVideoSessionKHR,CMockString_pVideoSession); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pVideoSession), (void*)(pVideoSession), sizeof(VkVideoSessionKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateVideoSessionKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateVideoSessionKHR_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pVideoSession, Mock.vkCreateVideoSessionKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pVideoSession_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pVideoSession, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pVideoSession, (const void*)cmock_call_instance->ReturnThruPtr_pVideoSession_Val, + cmock_call_instance->ReturnThruPtr_pVideoSession_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateVideoSessionKHR(CMOCK_vkCreateVideoSessionKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession); +void CMockExpectParameters_vkCreateVideoSessionKHR(CMOCK_vkCreateVideoSessionKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pVideoSession = pVideoSession; + cmock_call_instance->IgnoreArg_pVideoSession = 0; + cmock_call_instance->ReturnThruPtr_pVideoSession_Used = 0; +} + +void vkCreateVideoSessionKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateVideoSessionKHR_CALL_INSTANCE)); + CMOCK_vkCreateVideoSessionKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateVideoSessionKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateVideoSessionKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateVideoSessionKHR_CallInstance, cmock_guts_index); + Mock.vkCreateVideoSessionKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateVideoSessionKHR_IgnoreBool = (char)1; +} + +void vkCreateVideoSessionKHR_CMockStopIgnore(void) +{ + if(Mock.vkCreateVideoSessionKHR_IgnoreBool) + Mock.vkCreateVideoSessionKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCreateVideoSessionKHR_CallInstance); + Mock.vkCreateVideoSessionKHR_IgnoreBool = (char)0; +} + +void vkCreateVideoSessionKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateVideoSessionKHR_CALL_INSTANCE)); + CMOCK_vkCreateVideoSessionKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateVideoSessionKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateVideoSessionKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateVideoSessionKHR_CallInstance, cmock_guts_index); + Mock.vkCreateVideoSessionKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateVideoSessionKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateVideoSessionKHR_CALL_INSTANCE)); + CMOCK_vkCreateVideoSessionKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateVideoSessionKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateVideoSessionKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateVideoSessionKHR_CallInstance, cmock_guts_index); + Mock.vkCreateVideoSessionKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateVideoSessionKHR(cmock_call_instance, device, pCreateInfo, pAllocator, pVideoSession); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateVideoSessionKHR_AddCallback(CMOCK_vkCreateVideoSessionKHR_CALLBACK Callback) +{ + Mock.vkCreateVideoSessionKHR_IgnoreBool = (char)0; + Mock.vkCreateVideoSessionKHR_CallbackBool = (char)1; + Mock.vkCreateVideoSessionKHR_CallbackFunctionPointer = Callback; +} + +void vkCreateVideoSessionKHR_Stub(CMOCK_vkCreateVideoSessionKHR_CALLBACK Callback) +{ + Mock.vkCreateVideoSessionKHR_IgnoreBool = (char)0; + Mock.vkCreateVideoSessionKHR_CallbackBool = (char)0; + Mock.vkCreateVideoSessionKHR_CallbackFunctionPointer = Callback; +} + +void vkCreateVideoSessionKHR_CMockReturnMemThruPtr_pVideoSession(UNITY_LINE_TYPE cmock_line, VkVideoSessionKHR const* pVideoSession, size_t cmock_size) +{ + CMOCK_vkCreateVideoSessionKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateVideoSessionKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateVideoSessionKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pVideoSession_Used = 1; + cmock_call_instance->ReturnThruPtr_pVideoSession_Val = pVideoSession; + cmock_call_instance->ReturnThruPtr_pVideoSession_Size = cmock_size; +} + +void vkCreateVideoSessionKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateVideoSessionKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateVideoSessionKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateVideoSessionKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateVideoSessionKHR_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateVideoSessionKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateVideoSessionKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateVideoSessionKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateVideoSessionKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateVideoSessionKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateVideoSessionKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateVideoSessionKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateVideoSessionKHR_CMockIgnoreArg_pVideoSession(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateVideoSessionKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateVideoSessionKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateVideoSessionKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pVideoSession = 1; +} + +void vkDestroyVideoSessionKHR(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyVideoSessionKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyVideoSessionKHR); + cmock_call_instance = (CMOCK_vkDestroyVideoSessionKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyVideoSessionKHR_CallInstance); + Mock.vkDestroyVideoSessionKHR_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyVideoSessionKHR_CallInstance); + if (Mock.vkDestroyVideoSessionKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyVideoSessionKHR_CallbackBool && + Mock.vkDestroyVideoSessionKHR_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyVideoSessionKHR_CallbackFunctionPointer(device, videoSession, pAllocator, Mock.vkDestroyVideoSessionKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyVideoSessionKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_videoSession) + { + UNITY_SET_DETAILS(CMockString_vkDestroyVideoSessionKHR,CMockString_videoSession); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_videoSession), (void*)(&videoSession), sizeof(VkVideoSessionKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyVideoSessionKHR,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyVideoSessionKHR_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyVideoSessionKHR_CallbackFunctionPointer(device, videoSession, pAllocator, Mock.vkDestroyVideoSessionKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyVideoSessionKHR(CMOCK_vkDestroyVideoSessionKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyVideoSessionKHR(CMOCK_vkDestroyVideoSessionKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_videoSession), (void*)(&videoSession), + sizeof(VkVideoSessionKHR[sizeof(videoSession) == sizeof(VkVideoSessionKHR) ? 1 : -1])); /* add VkVideoSessionKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_videoSession = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyVideoSessionKHR_CMockIgnore(void) +{ + Mock.vkDestroyVideoSessionKHR_IgnoreBool = (char)1; +} + +void vkDestroyVideoSessionKHR_CMockStopIgnore(void) +{ + Mock.vkDestroyVideoSessionKHR_IgnoreBool = (char)0; +} + +void vkDestroyVideoSessionKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyVideoSessionKHR_CALL_INSTANCE)); + CMOCK_vkDestroyVideoSessionKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyVideoSessionKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyVideoSessionKHR_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyVideoSessionKHR_CallInstance, cmock_guts_index); + Mock.vkDestroyVideoSessionKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyVideoSessionKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyVideoSessionKHR_CALL_INSTANCE)); + CMOCK_vkDestroyVideoSessionKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyVideoSessionKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyVideoSessionKHR_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyVideoSessionKHR_CallInstance, cmock_guts_index); + Mock.vkDestroyVideoSessionKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyVideoSessionKHR(cmock_call_instance, device, videoSession, pAllocator); +} + +void vkDestroyVideoSessionKHR_AddCallback(CMOCK_vkDestroyVideoSessionKHR_CALLBACK Callback) +{ + Mock.vkDestroyVideoSessionKHR_IgnoreBool = (char)0; + Mock.vkDestroyVideoSessionKHR_CallbackBool = (char)1; + Mock.vkDestroyVideoSessionKHR_CallbackFunctionPointer = Callback; +} + +void vkDestroyVideoSessionKHR_Stub(CMOCK_vkDestroyVideoSessionKHR_CALLBACK Callback) +{ + Mock.vkDestroyVideoSessionKHR_IgnoreBool = (char)0; + Mock.vkDestroyVideoSessionKHR_CallbackBool = (char)0; + Mock.vkDestroyVideoSessionKHR_CallbackFunctionPointer = Callback; +} + +void vkDestroyVideoSessionKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyVideoSessionKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyVideoSessionKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyVideoSessionKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyVideoSessionKHR_CMockIgnoreArg_videoSession(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyVideoSessionKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyVideoSessionKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyVideoSessionKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_videoSession = 1; +} + +void vkDestroyVideoSessionKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyVideoSessionKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyVideoSessionKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyVideoSessionKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +VkResult vkGetVideoSessionMemoryRequirementsKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetVideoSessionMemoryRequirementsKHR); + cmock_call_instance = (CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetVideoSessionMemoryRequirementsKHR_CallInstance); + Mock.vkGetVideoSessionMemoryRequirementsKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetVideoSessionMemoryRequirementsKHR_CallInstance); + if (Mock.vkGetVideoSessionMemoryRequirementsKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetVideoSessionMemoryRequirementsKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetVideoSessionMemoryRequirementsKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetVideoSessionMemoryRequirementsKHR_CallbackBool && + Mock.vkGetVideoSessionMemoryRequirementsKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetVideoSessionMemoryRequirementsKHR_CallbackFunctionPointer(device, videoSession, pMemoryRequirementsCount, pMemoryRequirements, Mock.vkGetVideoSessionMemoryRequirementsKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetVideoSessionMemoryRequirementsKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_videoSession) + { + UNITY_SET_DETAILS(CMockString_vkGetVideoSessionMemoryRequirementsKHR,CMockString_videoSession); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_videoSession), (void*)(&videoSession), sizeof(VkVideoSessionKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMemoryRequirementsCount) + { + UNITY_SET_DETAILS(CMockString_vkGetVideoSessionMemoryRequirementsKHR,CMockString_pMemoryRequirementsCount); + if (cmock_call_instance->Expected_pMemoryRequirementsCount == NULL) + { UNITY_TEST_ASSERT_NULL(pMemoryRequirementsCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pMemoryRequirementsCount, pMemoryRequirementsCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pMemoryRequirements) + { + UNITY_SET_DETAILS(CMockString_vkGetVideoSessionMemoryRequirementsKHR,CMockString_pMemoryRequirements); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMemoryRequirements), (void*)(pMemoryRequirements), sizeof(VkVideoSessionMemoryRequirementsKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetVideoSessionMemoryRequirementsKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetVideoSessionMemoryRequirementsKHR_CallbackFunctionPointer(device, videoSession, pMemoryRequirementsCount, pMemoryRequirements, Mock.vkGetVideoSessionMemoryRequirementsKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pMemoryRequirementsCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pMemoryRequirementsCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pMemoryRequirementsCount, (const void*)cmock_call_instance->ReturnThruPtr_pMemoryRequirementsCount_Val, + cmock_call_instance->ReturnThruPtr_pMemoryRequirementsCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pMemoryRequirements, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pMemoryRequirements, (const void*)cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Val, + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetVideoSessionMemoryRequirementsKHR(CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements); +void CMockExpectParameters_vkGetVideoSessionMemoryRequirementsKHR(CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_videoSession), (void*)(&videoSession), + sizeof(VkVideoSessionKHR[sizeof(videoSession) == sizeof(VkVideoSessionKHR) ? 1 : -1])); /* add VkVideoSessionKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_videoSession = 0; + cmock_call_instance->Expected_pMemoryRequirementsCount = pMemoryRequirementsCount; + cmock_call_instance->IgnoreArg_pMemoryRequirementsCount = 0; + cmock_call_instance->ReturnThruPtr_pMemoryRequirementsCount_Used = 0; + cmock_call_instance->Expected_pMemoryRequirements = pMemoryRequirements; + cmock_call_instance->IgnoreArg_pMemoryRequirements = 0; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used = 0; +} + +void vkGetVideoSessionMemoryRequirementsKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALL_INSTANCE)); + CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetVideoSessionMemoryRequirementsKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetVideoSessionMemoryRequirementsKHR_CallInstance, cmock_guts_index); + Mock.vkGetVideoSessionMemoryRequirementsKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetVideoSessionMemoryRequirementsKHR_IgnoreBool = (char)1; +} + +void vkGetVideoSessionMemoryRequirementsKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetVideoSessionMemoryRequirementsKHR_IgnoreBool) + Mock.vkGetVideoSessionMemoryRequirementsKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetVideoSessionMemoryRequirementsKHR_CallInstance); + Mock.vkGetVideoSessionMemoryRequirementsKHR_IgnoreBool = (char)0; +} + +void vkGetVideoSessionMemoryRequirementsKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALL_INSTANCE)); + CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetVideoSessionMemoryRequirementsKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetVideoSessionMemoryRequirementsKHR_CallInstance, cmock_guts_index); + Mock.vkGetVideoSessionMemoryRequirementsKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetVideoSessionMemoryRequirementsKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALL_INSTANCE)); + CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetVideoSessionMemoryRequirementsKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetVideoSessionMemoryRequirementsKHR_CallInstance, cmock_guts_index); + Mock.vkGetVideoSessionMemoryRequirementsKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetVideoSessionMemoryRequirementsKHR(cmock_call_instance, device, videoSession, pMemoryRequirementsCount, pMemoryRequirements); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetVideoSessionMemoryRequirementsKHR_AddCallback(CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALLBACK Callback) +{ + Mock.vkGetVideoSessionMemoryRequirementsKHR_IgnoreBool = (char)0; + Mock.vkGetVideoSessionMemoryRequirementsKHR_CallbackBool = (char)1; + Mock.vkGetVideoSessionMemoryRequirementsKHR_CallbackFunctionPointer = Callback; +} + +void vkGetVideoSessionMemoryRequirementsKHR_Stub(CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALLBACK Callback) +{ + Mock.vkGetVideoSessionMemoryRequirementsKHR_IgnoreBool = (char)0; + Mock.vkGetVideoSessionMemoryRequirementsKHR_CallbackBool = (char)0; + Mock.vkGetVideoSessionMemoryRequirementsKHR_CallbackFunctionPointer = Callback; +} + +void vkGetVideoSessionMemoryRequirementsKHR_CMockReturnMemThruPtr_pMemoryRequirementsCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pMemoryRequirementsCount, size_t cmock_size) +{ + CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetVideoSessionMemoryRequirementsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pMemoryRequirementsCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pMemoryRequirementsCount_Val = pMemoryRequirementsCount; + cmock_call_instance->ReturnThruPtr_pMemoryRequirementsCount_Size = cmock_size; +} + +void vkGetVideoSessionMemoryRequirementsKHR_CMockReturnMemThruPtr_pMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkVideoSessionMemoryRequirementsKHR const* pMemoryRequirements, size_t cmock_size) +{ + CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetVideoSessionMemoryRequirementsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used = 1; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Val = pMemoryRequirements; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Size = cmock_size; +} + +void vkGetVideoSessionMemoryRequirementsKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetVideoSessionMemoryRequirementsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetVideoSessionMemoryRequirementsKHR_CMockIgnoreArg_videoSession(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetVideoSessionMemoryRequirementsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_videoSession = 1; +} + +void vkGetVideoSessionMemoryRequirementsKHR_CMockIgnoreArg_pMemoryRequirementsCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetVideoSessionMemoryRequirementsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMemoryRequirementsCount = 1; +} + +void vkGetVideoSessionMemoryRequirementsKHR_CMockIgnoreArg_pMemoryRequirements(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetVideoSessionMemoryRequirementsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMemoryRequirements = 1; +} + +VkResult vkBindVideoSessionMemoryKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkBindVideoSessionMemoryKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkBindVideoSessionMemoryKHR); + cmock_call_instance = (CMOCK_vkBindVideoSessionMemoryKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkBindVideoSessionMemoryKHR_CallInstance); + Mock.vkBindVideoSessionMemoryKHR_CallInstance = CMock_Guts_MemNext(Mock.vkBindVideoSessionMemoryKHR_CallInstance); + if (Mock.vkBindVideoSessionMemoryKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkBindVideoSessionMemoryKHR_FinalReturn; + memcpy((void*)(&Mock.vkBindVideoSessionMemoryKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkBindVideoSessionMemoryKHR_CallbackBool && + Mock.vkBindVideoSessionMemoryKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkBindVideoSessionMemoryKHR_CallbackFunctionPointer(device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos, Mock.vkBindVideoSessionMemoryKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkBindVideoSessionMemoryKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_videoSession) + { + UNITY_SET_DETAILS(CMockString_vkBindVideoSessionMemoryKHR,CMockString_videoSession); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_videoSession), (void*)(&videoSession), sizeof(VkVideoSessionKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_bindSessionMemoryInfoCount) + { + UNITY_SET_DETAILS(CMockString_vkBindVideoSessionMemoryKHR,CMockString_bindSessionMemoryInfoCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_bindSessionMemoryInfoCount, bindSessionMemoryInfoCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pBindSessionMemoryInfos) + { + UNITY_SET_DETAILS(CMockString_vkBindVideoSessionMemoryKHR,CMockString_pBindSessionMemoryInfos); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pBindSessionMemoryInfos), (void*)(pBindSessionMemoryInfos), sizeof(const VkBindVideoSessionMemoryInfoKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkBindVideoSessionMemoryKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkBindVideoSessionMemoryKHR_CallbackFunctionPointer(device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos, Mock.vkBindVideoSessionMemoryKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkBindVideoSessionMemoryKHR(CMOCK_vkBindVideoSessionMemoryKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos); +void CMockExpectParameters_vkBindVideoSessionMemoryKHR(CMOCK_vkBindVideoSessionMemoryKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_videoSession), (void*)(&videoSession), + sizeof(VkVideoSessionKHR[sizeof(videoSession) == sizeof(VkVideoSessionKHR) ? 1 : -1])); /* add VkVideoSessionKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_videoSession = 0; + cmock_call_instance->Expected_bindSessionMemoryInfoCount = bindSessionMemoryInfoCount; + cmock_call_instance->IgnoreArg_bindSessionMemoryInfoCount = 0; + cmock_call_instance->Expected_pBindSessionMemoryInfos = pBindSessionMemoryInfos; + cmock_call_instance->IgnoreArg_pBindSessionMemoryInfos = 0; +} + +void vkBindVideoSessionMemoryKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBindVideoSessionMemoryKHR_CALL_INSTANCE)); + CMOCK_vkBindVideoSessionMemoryKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindVideoSessionMemoryKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBindVideoSessionMemoryKHR_CallInstance = CMock_Guts_MemChain(Mock.vkBindVideoSessionMemoryKHR_CallInstance, cmock_guts_index); + Mock.vkBindVideoSessionMemoryKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkBindVideoSessionMemoryKHR_IgnoreBool = (char)1; +} + +void vkBindVideoSessionMemoryKHR_CMockStopIgnore(void) +{ + if(Mock.vkBindVideoSessionMemoryKHR_IgnoreBool) + Mock.vkBindVideoSessionMemoryKHR_CallInstance = CMock_Guts_MemNext(Mock.vkBindVideoSessionMemoryKHR_CallInstance); + Mock.vkBindVideoSessionMemoryKHR_IgnoreBool = (char)0; +} + +void vkBindVideoSessionMemoryKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBindVideoSessionMemoryKHR_CALL_INSTANCE)); + CMOCK_vkBindVideoSessionMemoryKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindVideoSessionMemoryKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBindVideoSessionMemoryKHR_CallInstance = CMock_Guts_MemChain(Mock.vkBindVideoSessionMemoryKHR_CallInstance, cmock_guts_index); + Mock.vkBindVideoSessionMemoryKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkBindVideoSessionMemoryKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBindVideoSessionMemoryKHR_CALL_INSTANCE)); + CMOCK_vkBindVideoSessionMemoryKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindVideoSessionMemoryKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBindVideoSessionMemoryKHR_CallInstance = CMock_Guts_MemChain(Mock.vkBindVideoSessionMemoryKHR_CallInstance, cmock_guts_index); + Mock.vkBindVideoSessionMemoryKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkBindVideoSessionMemoryKHR(cmock_call_instance, device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkBindVideoSessionMemoryKHR_AddCallback(CMOCK_vkBindVideoSessionMemoryKHR_CALLBACK Callback) +{ + Mock.vkBindVideoSessionMemoryKHR_IgnoreBool = (char)0; + Mock.vkBindVideoSessionMemoryKHR_CallbackBool = (char)1; + Mock.vkBindVideoSessionMemoryKHR_CallbackFunctionPointer = Callback; +} + +void vkBindVideoSessionMemoryKHR_Stub(CMOCK_vkBindVideoSessionMemoryKHR_CALLBACK Callback) +{ + Mock.vkBindVideoSessionMemoryKHR_IgnoreBool = (char)0; + Mock.vkBindVideoSessionMemoryKHR_CallbackBool = (char)0; + Mock.vkBindVideoSessionMemoryKHR_CallbackFunctionPointer = Callback; +} + +void vkBindVideoSessionMemoryKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindVideoSessionMemoryKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindVideoSessionMemoryKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindVideoSessionMemoryKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkBindVideoSessionMemoryKHR_CMockIgnoreArg_videoSession(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindVideoSessionMemoryKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindVideoSessionMemoryKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindVideoSessionMemoryKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_videoSession = 1; +} + +void vkBindVideoSessionMemoryKHR_CMockIgnoreArg_bindSessionMemoryInfoCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindVideoSessionMemoryKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindVideoSessionMemoryKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindVideoSessionMemoryKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_bindSessionMemoryInfoCount = 1; +} + +void vkBindVideoSessionMemoryKHR_CMockIgnoreArg_pBindSessionMemoryInfos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindVideoSessionMemoryKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindVideoSessionMemoryKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindVideoSessionMemoryKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pBindSessionMemoryInfos = 1; +} + +VkResult vkCreateVideoSessionParametersKHR(VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateVideoSessionParametersKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateVideoSessionParametersKHR); + cmock_call_instance = (CMOCK_vkCreateVideoSessionParametersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateVideoSessionParametersKHR_CallInstance); + Mock.vkCreateVideoSessionParametersKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCreateVideoSessionParametersKHR_CallInstance); + if (Mock.vkCreateVideoSessionParametersKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateVideoSessionParametersKHR_FinalReturn; + memcpy((void*)(&Mock.vkCreateVideoSessionParametersKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateVideoSessionParametersKHR_CallbackBool && + Mock.vkCreateVideoSessionParametersKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateVideoSessionParametersKHR_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pVideoSessionParameters, Mock.vkCreateVideoSessionParametersKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateVideoSessionParametersKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateVideoSessionParametersKHR,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkVideoSessionParametersCreateInfoKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateVideoSessionParametersKHR,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pVideoSessionParameters) + { + UNITY_SET_DETAILS(CMockString_vkCreateVideoSessionParametersKHR,CMockString_pVideoSessionParameters); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pVideoSessionParameters), (void*)(pVideoSessionParameters), sizeof(VkVideoSessionParametersKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateVideoSessionParametersKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateVideoSessionParametersKHR_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pVideoSessionParameters, Mock.vkCreateVideoSessionParametersKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pVideoSessionParameters_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pVideoSessionParameters, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pVideoSessionParameters, (const void*)cmock_call_instance->ReturnThruPtr_pVideoSessionParameters_Val, + cmock_call_instance->ReturnThruPtr_pVideoSessionParameters_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateVideoSessionParametersKHR(CMOCK_vkCreateVideoSessionParametersKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters); +void CMockExpectParameters_vkCreateVideoSessionParametersKHR(CMOCK_vkCreateVideoSessionParametersKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pVideoSessionParameters = pVideoSessionParameters; + cmock_call_instance->IgnoreArg_pVideoSessionParameters = 0; + cmock_call_instance->ReturnThruPtr_pVideoSessionParameters_Used = 0; +} + +void vkCreateVideoSessionParametersKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateVideoSessionParametersKHR_CALL_INSTANCE)); + CMOCK_vkCreateVideoSessionParametersKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateVideoSessionParametersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateVideoSessionParametersKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateVideoSessionParametersKHR_CallInstance, cmock_guts_index); + Mock.vkCreateVideoSessionParametersKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateVideoSessionParametersKHR_IgnoreBool = (char)1; +} + +void vkCreateVideoSessionParametersKHR_CMockStopIgnore(void) +{ + if(Mock.vkCreateVideoSessionParametersKHR_IgnoreBool) + Mock.vkCreateVideoSessionParametersKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCreateVideoSessionParametersKHR_CallInstance); + Mock.vkCreateVideoSessionParametersKHR_IgnoreBool = (char)0; +} + +void vkCreateVideoSessionParametersKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateVideoSessionParametersKHR_CALL_INSTANCE)); + CMOCK_vkCreateVideoSessionParametersKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateVideoSessionParametersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateVideoSessionParametersKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateVideoSessionParametersKHR_CallInstance, cmock_guts_index); + Mock.vkCreateVideoSessionParametersKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateVideoSessionParametersKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateVideoSessionParametersKHR_CALL_INSTANCE)); + CMOCK_vkCreateVideoSessionParametersKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateVideoSessionParametersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateVideoSessionParametersKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateVideoSessionParametersKHR_CallInstance, cmock_guts_index); + Mock.vkCreateVideoSessionParametersKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateVideoSessionParametersKHR(cmock_call_instance, device, pCreateInfo, pAllocator, pVideoSessionParameters); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateVideoSessionParametersKHR_AddCallback(CMOCK_vkCreateVideoSessionParametersKHR_CALLBACK Callback) +{ + Mock.vkCreateVideoSessionParametersKHR_IgnoreBool = (char)0; + Mock.vkCreateVideoSessionParametersKHR_CallbackBool = (char)1; + Mock.vkCreateVideoSessionParametersKHR_CallbackFunctionPointer = Callback; +} + +void vkCreateVideoSessionParametersKHR_Stub(CMOCK_vkCreateVideoSessionParametersKHR_CALLBACK Callback) +{ + Mock.vkCreateVideoSessionParametersKHR_IgnoreBool = (char)0; + Mock.vkCreateVideoSessionParametersKHR_CallbackBool = (char)0; + Mock.vkCreateVideoSessionParametersKHR_CallbackFunctionPointer = Callback; +} + +void vkCreateVideoSessionParametersKHR_CMockReturnMemThruPtr_pVideoSessionParameters(UNITY_LINE_TYPE cmock_line, VkVideoSessionParametersKHR const* pVideoSessionParameters, size_t cmock_size) +{ + CMOCK_vkCreateVideoSessionParametersKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateVideoSessionParametersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateVideoSessionParametersKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pVideoSessionParameters_Used = 1; + cmock_call_instance->ReturnThruPtr_pVideoSessionParameters_Val = pVideoSessionParameters; + cmock_call_instance->ReturnThruPtr_pVideoSessionParameters_Size = cmock_size; +} + +void vkCreateVideoSessionParametersKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateVideoSessionParametersKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateVideoSessionParametersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateVideoSessionParametersKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateVideoSessionParametersKHR_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateVideoSessionParametersKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateVideoSessionParametersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateVideoSessionParametersKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateVideoSessionParametersKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateVideoSessionParametersKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateVideoSessionParametersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateVideoSessionParametersKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateVideoSessionParametersKHR_CMockIgnoreArg_pVideoSessionParameters(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateVideoSessionParametersKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateVideoSessionParametersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateVideoSessionParametersKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pVideoSessionParameters = 1; +} + +VkResult vkUpdateVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkUpdateVideoSessionParametersKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkUpdateVideoSessionParametersKHR); + cmock_call_instance = (CMOCK_vkUpdateVideoSessionParametersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkUpdateVideoSessionParametersKHR_CallInstance); + Mock.vkUpdateVideoSessionParametersKHR_CallInstance = CMock_Guts_MemNext(Mock.vkUpdateVideoSessionParametersKHR_CallInstance); + if (Mock.vkUpdateVideoSessionParametersKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkUpdateVideoSessionParametersKHR_FinalReturn; + memcpy((void*)(&Mock.vkUpdateVideoSessionParametersKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkUpdateVideoSessionParametersKHR_CallbackBool && + Mock.vkUpdateVideoSessionParametersKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkUpdateVideoSessionParametersKHR_CallbackFunctionPointer(device, videoSessionParameters, pUpdateInfo, Mock.vkUpdateVideoSessionParametersKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkUpdateVideoSessionParametersKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_videoSessionParameters) + { + UNITY_SET_DETAILS(CMockString_vkUpdateVideoSessionParametersKHR,CMockString_videoSessionParameters); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_videoSessionParameters), (void*)(&videoSessionParameters), sizeof(VkVideoSessionParametersKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pUpdateInfo) + { + UNITY_SET_DETAILS(CMockString_vkUpdateVideoSessionParametersKHR,CMockString_pUpdateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pUpdateInfo), (void*)(pUpdateInfo), sizeof(const VkVideoSessionParametersUpdateInfoKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkUpdateVideoSessionParametersKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkUpdateVideoSessionParametersKHR_CallbackFunctionPointer(device, videoSessionParameters, pUpdateInfo, Mock.vkUpdateVideoSessionParametersKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkUpdateVideoSessionParametersKHR(CMOCK_vkUpdateVideoSessionParametersKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo); +void CMockExpectParameters_vkUpdateVideoSessionParametersKHR(CMOCK_vkUpdateVideoSessionParametersKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_videoSessionParameters), (void*)(&videoSessionParameters), + sizeof(VkVideoSessionParametersKHR[sizeof(videoSessionParameters) == sizeof(VkVideoSessionParametersKHR) ? 1 : -1])); /* add VkVideoSessionParametersKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_videoSessionParameters = 0; + cmock_call_instance->Expected_pUpdateInfo = pUpdateInfo; + cmock_call_instance->IgnoreArg_pUpdateInfo = 0; +} + +void vkUpdateVideoSessionParametersKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkUpdateVideoSessionParametersKHR_CALL_INSTANCE)); + CMOCK_vkUpdateVideoSessionParametersKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUpdateVideoSessionParametersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkUpdateVideoSessionParametersKHR_CallInstance = CMock_Guts_MemChain(Mock.vkUpdateVideoSessionParametersKHR_CallInstance, cmock_guts_index); + Mock.vkUpdateVideoSessionParametersKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkUpdateVideoSessionParametersKHR_IgnoreBool = (char)1; +} + +void vkUpdateVideoSessionParametersKHR_CMockStopIgnore(void) +{ + if(Mock.vkUpdateVideoSessionParametersKHR_IgnoreBool) + Mock.vkUpdateVideoSessionParametersKHR_CallInstance = CMock_Guts_MemNext(Mock.vkUpdateVideoSessionParametersKHR_CallInstance); + Mock.vkUpdateVideoSessionParametersKHR_IgnoreBool = (char)0; +} + +void vkUpdateVideoSessionParametersKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkUpdateVideoSessionParametersKHR_CALL_INSTANCE)); + CMOCK_vkUpdateVideoSessionParametersKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUpdateVideoSessionParametersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkUpdateVideoSessionParametersKHR_CallInstance = CMock_Guts_MemChain(Mock.vkUpdateVideoSessionParametersKHR_CallInstance, cmock_guts_index); + Mock.vkUpdateVideoSessionParametersKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkUpdateVideoSessionParametersKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkUpdateVideoSessionParametersKHR_CALL_INSTANCE)); + CMOCK_vkUpdateVideoSessionParametersKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUpdateVideoSessionParametersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkUpdateVideoSessionParametersKHR_CallInstance = CMock_Guts_MemChain(Mock.vkUpdateVideoSessionParametersKHR_CallInstance, cmock_guts_index); + Mock.vkUpdateVideoSessionParametersKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkUpdateVideoSessionParametersKHR(cmock_call_instance, device, videoSessionParameters, pUpdateInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkUpdateVideoSessionParametersKHR_AddCallback(CMOCK_vkUpdateVideoSessionParametersKHR_CALLBACK Callback) +{ + Mock.vkUpdateVideoSessionParametersKHR_IgnoreBool = (char)0; + Mock.vkUpdateVideoSessionParametersKHR_CallbackBool = (char)1; + Mock.vkUpdateVideoSessionParametersKHR_CallbackFunctionPointer = Callback; +} + +void vkUpdateVideoSessionParametersKHR_Stub(CMOCK_vkUpdateVideoSessionParametersKHR_CALLBACK Callback) +{ + Mock.vkUpdateVideoSessionParametersKHR_IgnoreBool = (char)0; + Mock.vkUpdateVideoSessionParametersKHR_CallbackBool = (char)0; + Mock.vkUpdateVideoSessionParametersKHR_CallbackFunctionPointer = Callback; +} + +void vkUpdateVideoSessionParametersKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkUpdateVideoSessionParametersKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUpdateVideoSessionParametersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkUpdateVideoSessionParametersKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkUpdateVideoSessionParametersKHR_CMockIgnoreArg_videoSessionParameters(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkUpdateVideoSessionParametersKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUpdateVideoSessionParametersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkUpdateVideoSessionParametersKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_videoSessionParameters = 1; +} + +void vkUpdateVideoSessionParametersKHR_CMockIgnoreArg_pUpdateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkUpdateVideoSessionParametersKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUpdateVideoSessionParametersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkUpdateVideoSessionParametersKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pUpdateInfo = 1; +} + +void vkDestroyVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyVideoSessionParametersKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyVideoSessionParametersKHR); + cmock_call_instance = (CMOCK_vkDestroyVideoSessionParametersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyVideoSessionParametersKHR_CallInstance); + Mock.vkDestroyVideoSessionParametersKHR_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyVideoSessionParametersKHR_CallInstance); + if (Mock.vkDestroyVideoSessionParametersKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyVideoSessionParametersKHR_CallbackBool && + Mock.vkDestroyVideoSessionParametersKHR_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyVideoSessionParametersKHR_CallbackFunctionPointer(device, videoSessionParameters, pAllocator, Mock.vkDestroyVideoSessionParametersKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyVideoSessionParametersKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_videoSessionParameters) + { + UNITY_SET_DETAILS(CMockString_vkDestroyVideoSessionParametersKHR,CMockString_videoSessionParameters); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_videoSessionParameters), (void*)(&videoSessionParameters), sizeof(VkVideoSessionParametersKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyVideoSessionParametersKHR,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyVideoSessionParametersKHR_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyVideoSessionParametersKHR_CallbackFunctionPointer(device, videoSessionParameters, pAllocator, Mock.vkDestroyVideoSessionParametersKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyVideoSessionParametersKHR(CMOCK_vkDestroyVideoSessionParametersKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyVideoSessionParametersKHR(CMOCK_vkDestroyVideoSessionParametersKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_videoSessionParameters), (void*)(&videoSessionParameters), + sizeof(VkVideoSessionParametersKHR[sizeof(videoSessionParameters) == sizeof(VkVideoSessionParametersKHR) ? 1 : -1])); /* add VkVideoSessionParametersKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_videoSessionParameters = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyVideoSessionParametersKHR_CMockIgnore(void) +{ + Mock.vkDestroyVideoSessionParametersKHR_IgnoreBool = (char)1; +} + +void vkDestroyVideoSessionParametersKHR_CMockStopIgnore(void) +{ + Mock.vkDestroyVideoSessionParametersKHR_IgnoreBool = (char)0; +} + +void vkDestroyVideoSessionParametersKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyVideoSessionParametersKHR_CALL_INSTANCE)); + CMOCK_vkDestroyVideoSessionParametersKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyVideoSessionParametersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyVideoSessionParametersKHR_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyVideoSessionParametersKHR_CallInstance, cmock_guts_index); + Mock.vkDestroyVideoSessionParametersKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyVideoSessionParametersKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyVideoSessionParametersKHR_CALL_INSTANCE)); + CMOCK_vkDestroyVideoSessionParametersKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyVideoSessionParametersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyVideoSessionParametersKHR_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyVideoSessionParametersKHR_CallInstance, cmock_guts_index); + Mock.vkDestroyVideoSessionParametersKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyVideoSessionParametersKHR(cmock_call_instance, device, videoSessionParameters, pAllocator); +} + +void vkDestroyVideoSessionParametersKHR_AddCallback(CMOCK_vkDestroyVideoSessionParametersKHR_CALLBACK Callback) +{ + Mock.vkDestroyVideoSessionParametersKHR_IgnoreBool = (char)0; + Mock.vkDestroyVideoSessionParametersKHR_CallbackBool = (char)1; + Mock.vkDestroyVideoSessionParametersKHR_CallbackFunctionPointer = Callback; +} + +void vkDestroyVideoSessionParametersKHR_Stub(CMOCK_vkDestroyVideoSessionParametersKHR_CALLBACK Callback) +{ + Mock.vkDestroyVideoSessionParametersKHR_IgnoreBool = (char)0; + Mock.vkDestroyVideoSessionParametersKHR_CallbackBool = (char)0; + Mock.vkDestroyVideoSessionParametersKHR_CallbackFunctionPointer = Callback; +} + +void vkDestroyVideoSessionParametersKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyVideoSessionParametersKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyVideoSessionParametersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyVideoSessionParametersKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyVideoSessionParametersKHR_CMockIgnoreArg_videoSessionParameters(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyVideoSessionParametersKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyVideoSessionParametersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyVideoSessionParametersKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_videoSessionParameters = 1; +} + +void vkDestroyVideoSessionParametersKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyVideoSessionParametersKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyVideoSessionParametersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyVideoSessionParametersKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBeginVideoCodingKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBeginVideoCodingKHR); + cmock_call_instance = (CMOCK_vkCmdBeginVideoCodingKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBeginVideoCodingKHR_CallInstance); + Mock.vkCmdBeginVideoCodingKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBeginVideoCodingKHR_CallInstance); + if (Mock.vkCmdBeginVideoCodingKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBeginVideoCodingKHR_CallbackBool && + Mock.vkCmdBeginVideoCodingKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBeginVideoCodingKHR_CallbackFunctionPointer(commandBuffer, pBeginInfo, Mock.vkCmdBeginVideoCodingKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginVideoCodingKHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pBeginInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginVideoCodingKHR,CMockString_pBeginInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pBeginInfo), (void*)(pBeginInfo), sizeof(const VkVideoBeginCodingInfoKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdBeginVideoCodingKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBeginVideoCodingKHR_CallbackFunctionPointer(commandBuffer, pBeginInfo, Mock.vkCmdBeginVideoCodingKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBeginVideoCodingKHR(CMOCK_vkCmdBeginVideoCodingKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo); +void CMockExpectParameters_vkCmdBeginVideoCodingKHR(CMOCK_vkCmdBeginVideoCodingKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pBeginInfo = pBeginInfo; + cmock_call_instance->IgnoreArg_pBeginInfo = 0; +} + +void vkCmdBeginVideoCodingKHR_CMockIgnore(void) +{ + Mock.vkCmdBeginVideoCodingKHR_IgnoreBool = (char)1; +} + +void vkCmdBeginVideoCodingKHR_CMockStopIgnore(void) +{ + Mock.vkCmdBeginVideoCodingKHR_IgnoreBool = (char)0; +} + +void vkCmdBeginVideoCodingKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBeginVideoCodingKHR_CALL_INSTANCE)); + CMOCK_vkCmdBeginVideoCodingKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginVideoCodingKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBeginVideoCodingKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBeginVideoCodingKHR_CallInstance, cmock_guts_index); + Mock.vkCmdBeginVideoCodingKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBeginVideoCodingKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBeginVideoCodingKHR_CALL_INSTANCE)); + CMOCK_vkCmdBeginVideoCodingKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginVideoCodingKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBeginVideoCodingKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBeginVideoCodingKHR_CallInstance, cmock_guts_index); + Mock.vkCmdBeginVideoCodingKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBeginVideoCodingKHR(cmock_call_instance, commandBuffer, pBeginInfo); +} + +void vkCmdBeginVideoCodingKHR_AddCallback(CMOCK_vkCmdBeginVideoCodingKHR_CALLBACK Callback) +{ + Mock.vkCmdBeginVideoCodingKHR_IgnoreBool = (char)0; + Mock.vkCmdBeginVideoCodingKHR_CallbackBool = (char)1; + Mock.vkCmdBeginVideoCodingKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdBeginVideoCodingKHR_Stub(CMOCK_vkCmdBeginVideoCodingKHR_CALLBACK Callback) +{ + Mock.vkCmdBeginVideoCodingKHR_IgnoreBool = (char)0; + Mock.vkCmdBeginVideoCodingKHR_CallbackBool = (char)0; + Mock.vkCmdBeginVideoCodingKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdBeginVideoCodingKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginVideoCodingKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginVideoCodingKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginVideoCodingKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBeginVideoCodingKHR_CMockIgnoreArg_pBeginInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginVideoCodingKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginVideoCodingKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginVideoCodingKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pBeginInfo = 1; +} + +void vkCmdEndVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdEndVideoCodingKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdEndVideoCodingKHR); + cmock_call_instance = (CMOCK_vkCmdEndVideoCodingKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdEndVideoCodingKHR_CallInstance); + Mock.vkCmdEndVideoCodingKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdEndVideoCodingKHR_CallInstance); + if (Mock.vkCmdEndVideoCodingKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdEndVideoCodingKHR_CallbackBool && + Mock.vkCmdEndVideoCodingKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdEndVideoCodingKHR_CallbackFunctionPointer(commandBuffer, pEndCodingInfo, Mock.vkCmdEndVideoCodingKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdEndVideoCodingKHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pEndCodingInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdEndVideoCodingKHR,CMockString_pEndCodingInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pEndCodingInfo), (void*)(pEndCodingInfo), sizeof(const VkVideoEndCodingInfoKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdEndVideoCodingKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdEndVideoCodingKHR_CallbackFunctionPointer(commandBuffer, pEndCodingInfo, Mock.vkCmdEndVideoCodingKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdEndVideoCodingKHR(CMOCK_vkCmdEndVideoCodingKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo); +void CMockExpectParameters_vkCmdEndVideoCodingKHR(CMOCK_vkCmdEndVideoCodingKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pEndCodingInfo = pEndCodingInfo; + cmock_call_instance->IgnoreArg_pEndCodingInfo = 0; +} + +void vkCmdEndVideoCodingKHR_CMockIgnore(void) +{ + Mock.vkCmdEndVideoCodingKHR_IgnoreBool = (char)1; +} + +void vkCmdEndVideoCodingKHR_CMockStopIgnore(void) +{ + Mock.vkCmdEndVideoCodingKHR_IgnoreBool = (char)0; +} + +void vkCmdEndVideoCodingKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdEndVideoCodingKHR_CALL_INSTANCE)); + CMOCK_vkCmdEndVideoCodingKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndVideoCodingKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdEndVideoCodingKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdEndVideoCodingKHR_CallInstance, cmock_guts_index); + Mock.vkCmdEndVideoCodingKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdEndVideoCodingKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdEndVideoCodingKHR_CALL_INSTANCE)); + CMOCK_vkCmdEndVideoCodingKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndVideoCodingKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdEndVideoCodingKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdEndVideoCodingKHR_CallInstance, cmock_guts_index); + Mock.vkCmdEndVideoCodingKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdEndVideoCodingKHR(cmock_call_instance, commandBuffer, pEndCodingInfo); +} + +void vkCmdEndVideoCodingKHR_AddCallback(CMOCK_vkCmdEndVideoCodingKHR_CALLBACK Callback) +{ + Mock.vkCmdEndVideoCodingKHR_IgnoreBool = (char)0; + Mock.vkCmdEndVideoCodingKHR_CallbackBool = (char)1; + Mock.vkCmdEndVideoCodingKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdEndVideoCodingKHR_Stub(CMOCK_vkCmdEndVideoCodingKHR_CALLBACK Callback) +{ + Mock.vkCmdEndVideoCodingKHR_IgnoreBool = (char)0; + Mock.vkCmdEndVideoCodingKHR_CallbackBool = (char)0; + Mock.vkCmdEndVideoCodingKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdEndVideoCodingKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdEndVideoCodingKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndVideoCodingKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdEndVideoCodingKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdEndVideoCodingKHR_CMockIgnoreArg_pEndCodingInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdEndVideoCodingKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndVideoCodingKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdEndVideoCodingKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pEndCodingInfo = 1; +} + +void vkCmdControlVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdControlVideoCodingKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdControlVideoCodingKHR); + cmock_call_instance = (CMOCK_vkCmdControlVideoCodingKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdControlVideoCodingKHR_CallInstance); + Mock.vkCmdControlVideoCodingKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdControlVideoCodingKHR_CallInstance); + if (Mock.vkCmdControlVideoCodingKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdControlVideoCodingKHR_CallbackBool && + Mock.vkCmdControlVideoCodingKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdControlVideoCodingKHR_CallbackFunctionPointer(commandBuffer, pCodingControlInfo, Mock.vkCmdControlVideoCodingKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdControlVideoCodingKHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCodingControlInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdControlVideoCodingKHR,CMockString_pCodingControlInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCodingControlInfo), (void*)(pCodingControlInfo), sizeof(const VkVideoCodingControlInfoKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdControlVideoCodingKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdControlVideoCodingKHR_CallbackFunctionPointer(commandBuffer, pCodingControlInfo, Mock.vkCmdControlVideoCodingKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdControlVideoCodingKHR(CMOCK_vkCmdControlVideoCodingKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo); +void CMockExpectParameters_vkCmdControlVideoCodingKHR(CMOCK_vkCmdControlVideoCodingKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pCodingControlInfo = pCodingControlInfo; + cmock_call_instance->IgnoreArg_pCodingControlInfo = 0; +} + +void vkCmdControlVideoCodingKHR_CMockIgnore(void) +{ + Mock.vkCmdControlVideoCodingKHR_IgnoreBool = (char)1; +} + +void vkCmdControlVideoCodingKHR_CMockStopIgnore(void) +{ + Mock.vkCmdControlVideoCodingKHR_IgnoreBool = (char)0; +} + +void vkCmdControlVideoCodingKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdControlVideoCodingKHR_CALL_INSTANCE)); + CMOCK_vkCmdControlVideoCodingKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdControlVideoCodingKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdControlVideoCodingKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdControlVideoCodingKHR_CallInstance, cmock_guts_index); + Mock.vkCmdControlVideoCodingKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdControlVideoCodingKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdControlVideoCodingKHR_CALL_INSTANCE)); + CMOCK_vkCmdControlVideoCodingKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdControlVideoCodingKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdControlVideoCodingKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdControlVideoCodingKHR_CallInstance, cmock_guts_index); + Mock.vkCmdControlVideoCodingKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdControlVideoCodingKHR(cmock_call_instance, commandBuffer, pCodingControlInfo); +} + +void vkCmdControlVideoCodingKHR_AddCallback(CMOCK_vkCmdControlVideoCodingKHR_CALLBACK Callback) +{ + Mock.vkCmdControlVideoCodingKHR_IgnoreBool = (char)0; + Mock.vkCmdControlVideoCodingKHR_CallbackBool = (char)1; + Mock.vkCmdControlVideoCodingKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdControlVideoCodingKHR_Stub(CMOCK_vkCmdControlVideoCodingKHR_CALLBACK Callback) +{ + Mock.vkCmdControlVideoCodingKHR_IgnoreBool = (char)0; + Mock.vkCmdControlVideoCodingKHR_CallbackBool = (char)0; + Mock.vkCmdControlVideoCodingKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdControlVideoCodingKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdControlVideoCodingKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdControlVideoCodingKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdControlVideoCodingKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdControlVideoCodingKHR_CMockIgnoreArg_pCodingControlInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdControlVideoCodingKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdControlVideoCodingKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdControlVideoCodingKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCodingControlInfo = 1; +} + +void vkCmdDecodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDecodeVideoKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDecodeVideoKHR); + cmock_call_instance = (CMOCK_vkCmdDecodeVideoKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDecodeVideoKHR_CallInstance); + Mock.vkCmdDecodeVideoKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDecodeVideoKHR_CallInstance); + if (Mock.vkCmdDecodeVideoKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDecodeVideoKHR_CallbackBool && + Mock.vkCmdDecodeVideoKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDecodeVideoKHR_CallbackFunctionPointer(commandBuffer, pDecodeInfo, Mock.vkCmdDecodeVideoKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDecodeVideoKHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDecodeInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdDecodeVideoKHR,CMockString_pDecodeInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDecodeInfo), (void*)(pDecodeInfo), sizeof(const VkVideoDecodeInfoKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdDecodeVideoKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDecodeVideoKHR_CallbackFunctionPointer(commandBuffer, pDecodeInfo, Mock.vkCmdDecodeVideoKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDecodeVideoKHR(CMOCK_vkCmdDecodeVideoKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo); +void CMockExpectParameters_vkCmdDecodeVideoKHR(CMOCK_vkCmdDecodeVideoKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pDecodeInfo = pDecodeInfo; + cmock_call_instance->IgnoreArg_pDecodeInfo = 0; +} + +void vkCmdDecodeVideoKHR_CMockIgnore(void) +{ + Mock.vkCmdDecodeVideoKHR_IgnoreBool = (char)1; +} + +void vkCmdDecodeVideoKHR_CMockStopIgnore(void) +{ + Mock.vkCmdDecodeVideoKHR_IgnoreBool = (char)0; +} + +void vkCmdDecodeVideoKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDecodeVideoKHR_CALL_INSTANCE)); + CMOCK_vkCmdDecodeVideoKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDecodeVideoKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDecodeVideoKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDecodeVideoKHR_CallInstance, cmock_guts_index); + Mock.vkCmdDecodeVideoKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDecodeVideoKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDecodeVideoKHR_CALL_INSTANCE)); + CMOCK_vkCmdDecodeVideoKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDecodeVideoKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDecodeVideoKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDecodeVideoKHR_CallInstance, cmock_guts_index); + Mock.vkCmdDecodeVideoKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDecodeVideoKHR(cmock_call_instance, commandBuffer, pDecodeInfo); +} + +void vkCmdDecodeVideoKHR_AddCallback(CMOCK_vkCmdDecodeVideoKHR_CALLBACK Callback) +{ + Mock.vkCmdDecodeVideoKHR_IgnoreBool = (char)0; + Mock.vkCmdDecodeVideoKHR_CallbackBool = (char)1; + Mock.vkCmdDecodeVideoKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdDecodeVideoKHR_Stub(CMOCK_vkCmdDecodeVideoKHR_CALLBACK Callback) +{ + Mock.vkCmdDecodeVideoKHR_IgnoreBool = (char)0; + Mock.vkCmdDecodeVideoKHR_CallbackBool = (char)0; + Mock.vkCmdDecodeVideoKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdDecodeVideoKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDecodeVideoKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDecodeVideoKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDecodeVideoKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDecodeVideoKHR_CMockIgnoreArg_pDecodeInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDecodeVideoKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDecodeVideoKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDecodeVideoKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDecodeInfo = 1; +} + +void vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBeginRenderingKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBeginRenderingKHR); + cmock_call_instance = (CMOCK_vkCmdBeginRenderingKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBeginRenderingKHR_CallInstance); + Mock.vkCmdBeginRenderingKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBeginRenderingKHR_CallInstance); + if (Mock.vkCmdBeginRenderingKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBeginRenderingKHR_CallbackBool && + Mock.vkCmdBeginRenderingKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBeginRenderingKHR_CallbackFunctionPointer(commandBuffer, pRenderingInfo, Mock.vkCmdBeginRenderingKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginRenderingKHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pRenderingInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginRenderingKHR,CMockString_pRenderingInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pRenderingInfo), (void*)(pRenderingInfo), sizeof(const VkRenderingInfo), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdBeginRenderingKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBeginRenderingKHR_CallbackFunctionPointer(commandBuffer, pRenderingInfo, Mock.vkCmdBeginRenderingKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBeginRenderingKHR(CMOCK_vkCmdBeginRenderingKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo); +void CMockExpectParameters_vkCmdBeginRenderingKHR(CMOCK_vkCmdBeginRenderingKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pRenderingInfo = pRenderingInfo; + cmock_call_instance->IgnoreArg_pRenderingInfo = 0; +} + +void vkCmdBeginRenderingKHR_CMockIgnore(void) +{ + Mock.vkCmdBeginRenderingKHR_IgnoreBool = (char)1; +} + +void vkCmdBeginRenderingKHR_CMockStopIgnore(void) +{ + Mock.vkCmdBeginRenderingKHR_IgnoreBool = (char)0; +} + +void vkCmdBeginRenderingKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBeginRenderingKHR_CALL_INSTANCE)); + CMOCK_vkCmdBeginRenderingKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginRenderingKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBeginRenderingKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBeginRenderingKHR_CallInstance, cmock_guts_index); + Mock.vkCmdBeginRenderingKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBeginRenderingKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBeginRenderingKHR_CALL_INSTANCE)); + CMOCK_vkCmdBeginRenderingKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginRenderingKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBeginRenderingKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBeginRenderingKHR_CallInstance, cmock_guts_index); + Mock.vkCmdBeginRenderingKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBeginRenderingKHR(cmock_call_instance, commandBuffer, pRenderingInfo); +} + +void vkCmdBeginRenderingKHR_AddCallback(CMOCK_vkCmdBeginRenderingKHR_CALLBACK Callback) +{ + Mock.vkCmdBeginRenderingKHR_IgnoreBool = (char)0; + Mock.vkCmdBeginRenderingKHR_CallbackBool = (char)1; + Mock.vkCmdBeginRenderingKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdBeginRenderingKHR_Stub(CMOCK_vkCmdBeginRenderingKHR_CALLBACK Callback) +{ + Mock.vkCmdBeginRenderingKHR_IgnoreBool = (char)0; + Mock.vkCmdBeginRenderingKHR_CallbackBool = (char)0; + Mock.vkCmdBeginRenderingKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdBeginRenderingKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginRenderingKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginRenderingKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginRenderingKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBeginRenderingKHR_CMockIgnoreArg_pRenderingInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginRenderingKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginRenderingKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginRenderingKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pRenderingInfo = 1; +} + +void vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdEndRenderingKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdEndRenderingKHR); + cmock_call_instance = (CMOCK_vkCmdEndRenderingKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdEndRenderingKHR_CallInstance); + Mock.vkCmdEndRenderingKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdEndRenderingKHR_CallInstance); + if (Mock.vkCmdEndRenderingKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdEndRenderingKHR_CallbackBool && + Mock.vkCmdEndRenderingKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdEndRenderingKHR_CallbackFunctionPointer(commandBuffer, Mock.vkCmdEndRenderingKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdEndRenderingKHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdEndRenderingKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdEndRenderingKHR_CallbackFunctionPointer(commandBuffer, Mock.vkCmdEndRenderingKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdEndRenderingKHR(CMOCK_vkCmdEndRenderingKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer); +void CMockExpectParameters_vkCmdEndRenderingKHR(CMOCK_vkCmdEndRenderingKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; +} + +void vkCmdEndRenderingKHR_CMockIgnore(void) +{ + Mock.vkCmdEndRenderingKHR_IgnoreBool = (char)1; +} + +void vkCmdEndRenderingKHR_CMockStopIgnore(void) +{ + Mock.vkCmdEndRenderingKHR_IgnoreBool = (char)0; +} + +void vkCmdEndRenderingKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdEndRenderingKHR_CALL_INSTANCE)); + CMOCK_vkCmdEndRenderingKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndRenderingKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdEndRenderingKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdEndRenderingKHR_CallInstance, cmock_guts_index); + Mock.vkCmdEndRenderingKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdEndRenderingKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdEndRenderingKHR_CALL_INSTANCE)); + CMOCK_vkCmdEndRenderingKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndRenderingKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdEndRenderingKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdEndRenderingKHR_CallInstance, cmock_guts_index); + Mock.vkCmdEndRenderingKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdEndRenderingKHR(cmock_call_instance, commandBuffer); +} + +void vkCmdEndRenderingKHR_AddCallback(CMOCK_vkCmdEndRenderingKHR_CALLBACK Callback) +{ + Mock.vkCmdEndRenderingKHR_IgnoreBool = (char)0; + Mock.vkCmdEndRenderingKHR_CallbackBool = (char)1; + Mock.vkCmdEndRenderingKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdEndRenderingKHR_Stub(CMOCK_vkCmdEndRenderingKHR_CALLBACK Callback) +{ + Mock.vkCmdEndRenderingKHR_IgnoreBool = (char)0; + Mock.vkCmdEndRenderingKHR_CallbackBool = (char)0; + Mock.vkCmdEndRenderingKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdEndRenderingKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdEndRenderingKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndRenderingKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdEndRenderingKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceFeatures2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceFeatures2KHR); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFeatures2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceFeatures2KHR_CallInstance); + Mock.vkGetPhysicalDeviceFeatures2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceFeatures2KHR_CallInstance); + if (Mock.vkGetPhysicalDeviceFeatures2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetPhysicalDeviceFeatures2KHR_CallbackBool && + Mock.vkGetPhysicalDeviceFeatures2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceFeatures2KHR_CallbackFunctionPointer(physicalDevice, pFeatures, Mock.vkGetPhysicalDeviceFeatures2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceFeatures2KHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pFeatures) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceFeatures2KHR,CMockString_pFeatures); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pFeatures), (void*)(pFeatures), sizeof(VkPhysicalDeviceFeatures2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceFeatures2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceFeatures2KHR_CallbackFunctionPointer(physicalDevice, pFeatures, Mock.vkGetPhysicalDeviceFeatures2KHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pFeatures_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pFeatures, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pFeatures, (const void*)cmock_call_instance->ReturnThruPtr_pFeatures_Val, + cmock_call_instance->ReturnThruPtr_pFeatures_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetPhysicalDeviceFeatures2KHR(CMOCK_vkGetPhysicalDeviceFeatures2KHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); +void CMockExpectParameters_vkGetPhysicalDeviceFeatures2KHR(CMOCK_vkGetPhysicalDeviceFeatures2KHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pFeatures = pFeatures; + cmock_call_instance->IgnoreArg_pFeatures = 0; + cmock_call_instance->ReturnThruPtr_pFeatures_Used = 0; +} + +void vkGetPhysicalDeviceFeatures2KHR_CMockIgnore(void) +{ + Mock.vkGetPhysicalDeviceFeatures2KHR_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceFeatures2KHR_CMockStopIgnore(void) +{ + Mock.vkGetPhysicalDeviceFeatures2KHR_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceFeatures2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceFeatures2KHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceFeatures2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFeatures2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceFeatures2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceFeatures2KHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceFeatures2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceFeatures2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceFeatures2KHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceFeatures2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFeatures2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceFeatures2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceFeatures2KHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceFeatures2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceFeatures2KHR(cmock_call_instance, physicalDevice, pFeatures); +} + +void vkGetPhysicalDeviceFeatures2KHR_AddCallback(CMOCK_vkGetPhysicalDeviceFeatures2KHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceFeatures2KHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceFeatures2KHR_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceFeatures2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceFeatures2KHR_Stub(CMOCK_vkGetPhysicalDeviceFeatures2KHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceFeatures2KHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceFeatures2KHR_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceFeatures2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceFeatures2KHR_CMockReturnMemThruPtr_pFeatures(UNITY_LINE_TYPE cmock_line, VkPhysicalDeviceFeatures2 const* pFeatures, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceFeatures2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFeatures2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceFeatures2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pFeatures_Used = 1; + cmock_call_instance->ReturnThruPtr_pFeatures_Val = pFeatures; + cmock_call_instance->ReturnThruPtr_pFeatures_Size = cmock_size; +} + +void vkGetPhysicalDeviceFeatures2KHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceFeatures2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFeatures2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceFeatures2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceFeatures2KHR_CMockIgnoreArg_pFeatures(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceFeatures2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFeatures2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceFeatures2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pFeatures = 1; +} + +void vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceProperties2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceProperties2KHR); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceProperties2KHR_CallInstance); + Mock.vkGetPhysicalDeviceProperties2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceProperties2KHR_CallInstance); + if (Mock.vkGetPhysicalDeviceProperties2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetPhysicalDeviceProperties2KHR_CallbackBool && + Mock.vkGetPhysicalDeviceProperties2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceProperties2KHR_CallbackFunctionPointer(physicalDevice, pProperties, Mock.vkGetPhysicalDeviceProperties2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceProperties2KHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceProperties2KHR,CMockString_pProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pProperties), (void*)(pProperties), sizeof(VkPhysicalDeviceProperties2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceProperties2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceProperties2KHR_CallbackFunctionPointer(physicalDevice, pProperties, Mock.vkGetPhysicalDeviceProperties2KHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pProperties, (const void*)cmock_call_instance->ReturnThruPtr_pProperties_Val, + cmock_call_instance->ReturnThruPtr_pProperties_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetPhysicalDeviceProperties2KHR(CMOCK_vkGetPhysicalDeviceProperties2KHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); +void CMockExpectParameters_vkGetPhysicalDeviceProperties2KHR(CMOCK_vkGetPhysicalDeviceProperties2KHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pProperties = pProperties; + cmock_call_instance->IgnoreArg_pProperties = 0; + cmock_call_instance->ReturnThruPtr_pProperties_Used = 0; +} + +void vkGetPhysicalDeviceProperties2KHR_CMockIgnore(void) +{ + Mock.vkGetPhysicalDeviceProperties2KHR_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceProperties2KHR_CMockStopIgnore(void) +{ + Mock.vkGetPhysicalDeviceProperties2KHR_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceProperties2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceProperties2KHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceProperties2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceProperties2KHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceProperties2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceProperties2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceProperties2KHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceProperties2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceProperties2KHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceProperties2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceProperties2KHR(cmock_call_instance, physicalDevice, pProperties); +} + +void vkGetPhysicalDeviceProperties2KHR_AddCallback(CMOCK_vkGetPhysicalDeviceProperties2KHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceProperties2KHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceProperties2KHR_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceProperties2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceProperties2KHR_Stub(CMOCK_vkGetPhysicalDeviceProperties2KHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceProperties2KHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceProperties2KHR_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceProperties2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceProperties2KHR_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkPhysicalDeviceProperties2 const* pProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pProperties_Val = pProperties; + cmock_call_instance->ReturnThruPtr_pProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceProperties2KHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceProperties2KHR_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pProperties = 1; +} + +void vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceFormatProperties2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceFormatProperties2KHR); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFormatProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceFormatProperties2KHR_CallInstance); + Mock.vkGetPhysicalDeviceFormatProperties2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceFormatProperties2KHR_CallInstance); + if (Mock.vkGetPhysicalDeviceFormatProperties2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetPhysicalDeviceFormatProperties2KHR_CallbackBool && + Mock.vkGetPhysicalDeviceFormatProperties2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceFormatProperties2KHR_CallbackFunctionPointer(physicalDevice, format, pFormatProperties, Mock.vkGetPhysicalDeviceFormatProperties2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceFormatProperties2KHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_format) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceFormatProperties2KHR,CMockString_format); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_format), (void*)(&format), sizeof(VkFormat), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pFormatProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceFormatProperties2KHR,CMockString_pFormatProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pFormatProperties), (void*)(pFormatProperties), sizeof(VkFormatProperties2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceFormatProperties2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceFormatProperties2KHR_CallbackFunctionPointer(physicalDevice, format, pFormatProperties, Mock.vkGetPhysicalDeviceFormatProperties2KHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pFormatProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pFormatProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pFormatProperties, (const void*)cmock_call_instance->ReturnThruPtr_pFormatProperties_Val, + cmock_call_instance->ReturnThruPtr_pFormatProperties_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetPhysicalDeviceFormatProperties2KHR(CMOCK_vkGetPhysicalDeviceFormatProperties2KHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); +void CMockExpectParameters_vkGetPhysicalDeviceFormatProperties2KHR(CMOCK_vkGetPhysicalDeviceFormatProperties2KHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + memcpy((void*)(&cmock_call_instance->Expected_format), (void*)(&format), + sizeof(VkFormat[sizeof(format) == sizeof(VkFormat) ? 1 : -1])); /* add VkFormat to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_format = 0; + cmock_call_instance->Expected_pFormatProperties = pFormatProperties; + cmock_call_instance->IgnoreArg_pFormatProperties = 0; + cmock_call_instance->ReturnThruPtr_pFormatProperties_Used = 0; +} + +void vkGetPhysicalDeviceFormatProperties2KHR_CMockIgnore(void) +{ + Mock.vkGetPhysicalDeviceFormatProperties2KHR_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceFormatProperties2KHR_CMockStopIgnore(void) +{ + Mock.vkGetPhysicalDeviceFormatProperties2KHR_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceFormatProperties2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceFormatProperties2KHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceFormatProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFormatProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceFormatProperties2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceFormatProperties2KHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceFormatProperties2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceFormatProperties2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceFormatProperties2KHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceFormatProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFormatProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceFormatProperties2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceFormatProperties2KHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceFormatProperties2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceFormatProperties2KHR(cmock_call_instance, physicalDevice, format, pFormatProperties); +} + +void vkGetPhysicalDeviceFormatProperties2KHR_AddCallback(CMOCK_vkGetPhysicalDeviceFormatProperties2KHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceFormatProperties2KHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceFormatProperties2KHR_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceFormatProperties2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceFormatProperties2KHR_Stub(CMOCK_vkGetPhysicalDeviceFormatProperties2KHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceFormatProperties2KHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceFormatProperties2KHR_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceFormatProperties2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceFormatProperties2KHR_CMockReturnMemThruPtr_pFormatProperties(UNITY_LINE_TYPE cmock_line, VkFormatProperties2 const* pFormatProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceFormatProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFormatProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceFormatProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pFormatProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pFormatProperties_Val = pFormatProperties; + cmock_call_instance->ReturnThruPtr_pFormatProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceFormatProperties2KHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceFormatProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFormatProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceFormatProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceFormatProperties2KHR_CMockIgnoreArg_format(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceFormatProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFormatProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceFormatProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_format = 1; +} + +void vkGetPhysicalDeviceFormatProperties2KHR_CMockIgnoreArg_pFormatProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceFormatProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFormatProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceFormatProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pFormatProperties = 1; +} + +VkResult vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceImageFormatProperties2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceImageFormatProperties2KHR); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceImageFormatProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_CallInstance); + Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_CallInstance); + if (Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_FinalReturn; + memcpy((void*)(&Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_CallbackBool && + Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_CallbackFunctionPointer(physicalDevice, pImageFormatInfo, pImageFormatProperties, Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceImageFormatProperties2KHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pImageFormatInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceImageFormatProperties2KHR,CMockString_pImageFormatInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pImageFormatInfo), (void*)(pImageFormatInfo), sizeof(const VkPhysicalDeviceImageFormatInfo2), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pImageFormatProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceImageFormatProperties2KHR,CMockString_pImageFormatProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pImageFormatProperties), (void*)(pImageFormatProperties), sizeof(VkImageFormatProperties2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_CallbackFunctionPointer(physicalDevice, pImageFormatInfo, pImageFormatProperties, Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pImageFormatProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pImageFormatProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pImageFormatProperties, (const void*)cmock_call_instance->ReturnThruPtr_pImageFormatProperties_Val, + cmock_call_instance->ReturnThruPtr_pImageFormatProperties_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPhysicalDeviceImageFormatProperties2KHR(CMOCK_vkGetPhysicalDeviceImageFormatProperties2KHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); +void CMockExpectParameters_vkGetPhysicalDeviceImageFormatProperties2KHR(CMOCK_vkGetPhysicalDeviceImageFormatProperties2KHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pImageFormatInfo = pImageFormatInfo; + cmock_call_instance->IgnoreArg_pImageFormatInfo = 0; + cmock_call_instance->Expected_pImageFormatProperties = pImageFormatProperties; + cmock_call_instance->IgnoreArg_pImageFormatProperties = 0; + cmock_call_instance->ReturnThruPtr_pImageFormatProperties_Used = 0; +} + +void vkGetPhysicalDeviceImageFormatProperties2KHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceImageFormatProperties2KHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceImageFormatProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceImageFormatProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceImageFormatProperties2KHR_CMockStopIgnore(void) +{ + if(Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_IgnoreBool) + Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_CallInstance); + Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceImageFormatProperties2KHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceImageFormatProperties2KHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceImageFormatProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceImageFormatProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceImageFormatProperties2KHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceImageFormatProperties2KHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceImageFormatProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceImageFormatProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceImageFormatProperties2KHR(cmock_call_instance, physicalDevice, pImageFormatInfo, pImageFormatProperties); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPhysicalDeviceImageFormatProperties2KHR_AddCallback(CMOCK_vkGetPhysicalDeviceImageFormatProperties2KHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceImageFormatProperties2KHR_Stub(CMOCK_vkGetPhysicalDeviceImageFormatProperties2KHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceImageFormatProperties2KHR_CMockReturnMemThruPtr_pImageFormatProperties(UNITY_LINE_TYPE cmock_line, VkImageFormatProperties2 const* pImageFormatProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceImageFormatProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceImageFormatProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pImageFormatProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pImageFormatProperties_Val = pImageFormatProperties; + cmock_call_instance->ReturnThruPtr_pImageFormatProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceImageFormatProperties2KHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceImageFormatProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceImageFormatProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceImageFormatProperties2KHR_CMockIgnoreArg_pImageFormatInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceImageFormatProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceImageFormatProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pImageFormatInfo = 1; +} + +void vkGetPhysicalDeviceImageFormatProperties2KHR_CMockIgnoreArg_pImageFormatProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceImageFormatProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceImageFormatProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceImageFormatProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pImageFormatProperties = 1; +} + +void vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceQueueFamilyProperties2KHR); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_CallInstance); + Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_CallInstance); + if (Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_CallbackBool && + Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_CallbackFunctionPointer(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceQueueFamilyProperties2KHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pQueueFamilyPropertyCount) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceQueueFamilyProperties2KHR,CMockString_pQueueFamilyPropertyCount); + if (cmock_call_instance->Expected_pQueueFamilyPropertyCount == NULL) + { UNITY_TEST_ASSERT_NULL(pQueueFamilyPropertyCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pQueueFamilyPropertyCount, pQueueFamilyPropertyCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pQueueFamilyProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceQueueFamilyProperties2KHR,CMockString_pQueueFamilyProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pQueueFamilyProperties), (void*)(pQueueFamilyProperties), sizeof(VkQueueFamilyProperties2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_CallbackFunctionPointer(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pQueueFamilyPropertyCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pQueueFamilyPropertyCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pQueueFamilyPropertyCount, (const void*)cmock_call_instance->ReturnThruPtr_pQueueFamilyPropertyCount_Val, + cmock_call_instance->ReturnThruPtr_pQueueFamilyPropertyCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pQueueFamilyProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pQueueFamilyProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pQueueFamilyProperties, (const void*)cmock_call_instance->ReturnThruPtr_pQueueFamilyProperties_Val, + cmock_call_instance->ReturnThruPtr_pQueueFamilyProperties_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetPhysicalDeviceQueueFamilyProperties2KHR(CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2KHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); +void CMockExpectParameters_vkGetPhysicalDeviceQueueFamilyProperties2KHR(CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2KHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pQueueFamilyPropertyCount = pQueueFamilyPropertyCount; + cmock_call_instance->IgnoreArg_pQueueFamilyPropertyCount = 0; + cmock_call_instance->ReturnThruPtr_pQueueFamilyPropertyCount_Used = 0; + cmock_call_instance->Expected_pQueueFamilyProperties = pQueueFamilyProperties; + cmock_call_instance->IgnoreArg_pQueueFamilyProperties = 0; + cmock_call_instance->ReturnThruPtr_pQueueFamilyProperties_Used = 0; +} + +void vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockIgnore(void) +{ + Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockStopIgnore(void) +{ + Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2KHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2KHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceQueueFamilyProperties2KHR(cmock_call_instance, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); +} + +void vkGetPhysicalDeviceQueueFamilyProperties2KHR_AddCallback(CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2KHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceQueueFamilyProperties2KHR_Stub(CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2KHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockReturnMemThruPtr_pQueueFamilyPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pQueueFamilyPropertyCount, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pQueueFamilyPropertyCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pQueueFamilyPropertyCount_Val = pQueueFamilyPropertyCount; + cmock_call_instance->ReturnThruPtr_pQueueFamilyPropertyCount_Size = cmock_size; +} + +void vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockReturnMemThruPtr_pQueueFamilyProperties(UNITY_LINE_TYPE cmock_line, VkQueueFamilyProperties2 const* pQueueFamilyProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pQueueFamilyProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pQueueFamilyProperties_Val = pQueueFamilyProperties; + cmock_call_instance->ReturnThruPtr_pQueueFamilyProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockIgnoreArg_pQueueFamilyPropertyCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pQueueFamilyPropertyCount = 1; +} + +void vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockIgnoreArg_pQueueFamilyProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceQueueFamilyProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pQueueFamilyProperties = 1; +} + +void vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceMemoryProperties2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceMemoryProperties2KHR); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceMemoryProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceMemoryProperties2KHR_CallInstance); + Mock.vkGetPhysicalDeviceMemoryProperties2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceMemoryProperties2KHR_CallInstance); + if (Mock.vkGetPhysicalDeviceMemoryProperties2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetPhysicalDeviceMemoryProperties2KHR_CallbackBool && + Mock.vkGetPhysicalDeviceMemoryProperties2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceMemoryProperties2KHR_CallbackFunctionPointer(physicalDevice, pMemoryProperties, Mock.vkGetPhysicalDeviceMemoryProperties2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceMemoryProperties2KHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMemoryProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceMemoryProperties2KHR,CMockString_pMemoryProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMemoryProperties), (void*)(pMemoryProperties), sizeof(VkPhysicalDeviceMemoryProperties2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceMemoryProperties2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceMemoryProperties2KHR_CallbackFunctionPointer(physicalDevice, pMemoryProperties, Mock.vkGetPhysicalDeviceMemoryProperties2KHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pMemoryProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pMemoryProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pMemoryProperties, (const void*)cmock_call_instance->ReturnThruPtr_pMemoryProperties_Val, + cmock_call_instance->ReturnThruPtr_pMemoryProperties_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetPhysicalDeviceMemoryProperties2KHR(CMOCK_vkGetPhysicalDeviceMemoryProperties2KHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); +void CMockExpectParameters_vkGetPhysicalDeviceMemoryProperties2KHR(CMOCK_vkGetPhysicalDeviceMemoryProperties2KHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pMemoryProperties = pMemoryProperties; + cmock_call_instance->IgnoreArg_pMemoryProperties = 0; + cmock_call_instance->ReturnThruPtr_pMemoryProperties_Used = 0; +} + +void vkGetPhysicalDeviceMemoryProperties2KHR_CMockIgnore(void) +{ + Mock.vkGetPhysicalDeviceMemoryProperties2KHR_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceMemoryProperties2KHR_CMockStopIgnore(void) +{ + Mock.vkGetPhysicalDeviceMemoryProperties2KHR_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceMemoryProperties2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceMemoryProperties2KHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceMemoryProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceMemoryProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceMemoryProperties2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceMemoryProperties2KHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceMemoryProperties2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceMemoryProperties2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceMemoryProperties2KHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceMemoryProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceMemoryProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceMemoryProperties2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceMemoryProperties2KHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceMemoryProperties2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceMemoryProperties2KHR(cmock_call_instance, physicalDevice, pMemoryProperties); +} + +void vkGetPhysicalDeviceMemoryProperties2KHR_AddCallback(CMOCK_vkGetPhysicalDeviceMemoryProperties2KHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceMemoryProperties2KHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceMemoryProperties2KHR_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceMemoryProperties2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceMemoryProperties2KHR_Stub(CMOCK_vkGetPhysicalDeviceMemoryProperties2KHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceMemoryProperties2KHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceMemoryProperties2KHR_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceMemoryProperties2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceMemoryProperties2KHR_CMockReturnMemThruPtr_pMemoryProperties(UNITY_LINE_TYPE cmock_line, VkPhysicalDeviceMemoryProperties2 const* pMemoryProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceMemoryProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceMemoryProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceMemoryProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pMemoryProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pMemoryProperties_Val = pMemoryProperties; + cmock_call_instance->ReturnThruPtr_pMemoryProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceMemoryProperties2KHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceMemoryProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceMemoryProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceMemoryProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceMemoryProperties2KHR_CMockIgnoreArg_pMemoryProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceMemoryProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceMemoryProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceMemoryProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMemoryProperties = 1; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceSparseImageFormatProperties2KHR); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CallInstance); + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CallInstance); + if (Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CallbackBool && + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CallbackFunctionPointer(physicalDevice, pFormatInfo, pPropertyCount, pProperties, Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSparseImageFormatProperties2KHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pFormatInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSparseImageFormatProperties2KHR,CMockString_pFormatInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pFormatInfo), (void*)(pFormatInfo), sizeof(const VkPhysicalDeviceSparseImageFormatInfo2), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPropertyCount) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSparseImageFormatProperties2KHR,CMockString_pPropertyCount); + if (cmock_call_instance->Expected_pPropertyCount == NULL) + { UNITY_TEST_ASSERT_NULL(pPropertyCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pPropertyCount, pPropertyCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSparseImageFormatProperties2KHR,CMockString_pProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pProperties), (void*)(pProperties), sizeof(VkSparseImageFormatProperties2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CallbackFunctionPointer(physicalDevice, pFormatInfo, pPropertyCount, pProperties, Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPropertyCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPropertyCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPropertyCount, (const void*)cmock_call_instance->ReturnThruPtr_pPropertyCount_Val, + cmock_call_instance->ReturnThruPtr_pPropertyCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pProperties, (const void*)cmock_call_instance->ReturnThruPtr_pProperties_Val, + cmock_call_instance->ReturnThruPtr_pProperties_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); +void CMockExpectParameters_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pFormatInfo = pFormatInfo; + cmock_call_instance->IgnoreArg_pFormatInfo = 0; + cmock_call_instance->Expected_pPropertyCount = pPropertyCount; + cmock_call_instance->IgnoreArg_pPropertyCount = 0; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Used = 0; + cmock_call_instance->Expected_pProperties = pProperties; + cmock_call_instance->IgnoreArg_pProperties = 0; + cmock_call_instance->ReturnThruPtr_pProperties_Used = 0; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockIgnore(void) +{ + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockStopIgnore(void) +{ + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(cmock_call_instance, physicalDevice, pFormatInfo, pPropertyCount, pProperties); +} + +void vkGetPhysicalDeviceSparseImageFormatProperties2KHR_AddCallback(CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties2KHR_Stub(CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockReturnMemThruPtr_pPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPropertyCount, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPropertyCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Val = pPropertyCount; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Size = cmock_size; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkSparseImageFormatProperties2 const* pProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pProperties_Val = pProperties; + cmock_call_instance->ReturnThruPtr_pProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockIgnoreArg_pFormatInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pFormatInfo = 1; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockIgnoreArg_pPropertyCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPropertyCount = 1; +} + +void vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pProperties = 1; +} + +void vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDeviceGroupPeerMemoryFeaturesKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDeviceGroupPeerMemoryFeaturesKHR); + cmock_call_instance = (CMOCK_vkGetDeviceGroupPeerMemoryFeaturesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_CallInstance); + Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_CallInstance); + if (Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_CallbackBool && + Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_CallbackFunctionPointer(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures, Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceGroupPeerMemoryFeaturesKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_heapIndex) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceGroupPeerMemoryFeaturesKHR,CMockString_heapIndex); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_heapIndex, heapIndex, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_localDeviceIndex) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceGroupPeerMemoryFeaturesKHR,CMockString_localDeviceIndex); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_localDeviceIndex, localDeviceIndex, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_remoteDeviceIndex) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceGroupPeerMemoryFeaturesKHR,CMockString_remoteDeviceIndex); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_remoteDeviceIndex, remoteDeviceIndex, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPeerMemoryFeatures) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceGroupPeerMemoryFeaturesKHR,CMockString_pPeerMemoryFeatures); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pPeerMemoryFeatures), (void*)(pPeerMemoryFeatures), sizeof(VkPeerMemoryFeatureFlags), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_CallbackFunctionPointer(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures, Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPeerMemoryFeatures_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPeerMemoryFeatures, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPeerMemoryFeatures, (const void*)cmock_call_instance->ReturnThruPtr_pPeerMemoryFeatures_Val, + cmock_call_instance->ReturnThruPtr_pPeerMemoryFeatures_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetDeviceGroupPeerMemoryFeaturesKHR(CMOCK_vkGetDeviceGroupPeerMemoryFeaturesKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); +void CMockExpectParameters_vkGetDeviceGroupPeerMemoryFeaturesKHR(CMOCK_vkGetDeviceGroupPeerMemoryFeaturesKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_heapIndex = heapIndex; + cmock_call_instance->IgnoreArg_heapIndex = 0; + cmock_call_instance->Expected_localDeviceIndex = localDeviceIndex; + cmock_call_instance->IgnoreArg_localDeviceIndex = 0; + cmock_call_instance->Expected_remoteDeviceIndex = remoteDeviceIndex; + cmock_call_instance->IgnoreArg_remoteDeviceIndex = 0; + cmock_call_instance->Expected_pPeerMemoryFeatures = pPeerMemoryFeatures; + cmock_call_instance->IgnoreArg_pPeerMemoryFeatures = 0; + cmock_call_instance->ReturnThruPtr_pPeerMemoryFeatures_Used = 0; +} + +void vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockIgnore(void) +{ + Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_IgnoreBool = (char)1; +} + +void vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockStopIgnore(void) +{ + Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_IgnoreBool = (char)0; +} + +void vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceGroupPeerMemoryFeaturesKHR_CALL_INSTANCE)); + CMOCK_vkGetDeviceGroupPeerMemoryFeaturesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceGroupPeerMemoryFeaturesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_CallInstance, cmock_guts_index); + Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceGroupPeerMemoryFeaturesKHR_CALL_INSTANCE)); + CMOCK_vkGetDeviceGroupPeerMemoryFeaturesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceGroupPeerMemoryFeaturesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_CallInstance, cmock_guts_index); + Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDeviceGroupPeerMemoryFeaturesKHR(cmock_call_instance, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); +} + +void vkGetDeviceGroupPeerMemoryFeaturesKHR_AddCallback(CMOCK_vkGetDeviceGroupPeerMemoryFeaturesKHR_CALLBACK Callback) +{ + Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_IgnoreBool = (char)0; + Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_CallbackBool = (char)1; + Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceGroupPeerMemoryFeaturesKHR_Stub(CMOCK_vkGetDeviceGroupPeerMemoryFeaturesKHR_CALLBACK Callback) +{ + Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_IgnoreBool = (char)0; + Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_CallbackBool = (char)0; + Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockReturnMemThruPtr_pPeerMemoryFeatures(UNITY_LINE_TYPE cmock_line, VkPeerMemoryFeatureFlags const* pPeerMemoryFeatures, size_t cmock_size) +{ + CMOCK_vkGetDeviceGroupPeerMemoryFeaturesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceGroupPeerMemoryFeaturesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPeerMemoryFeatures_Used = 1; + cmock_call_instance->ReturnThruPtr_pPeerMemoryFeatures_Val = pPeerMemoryFeatures; + cmock_call_instance->ReturnThruPtr_pPeerMemoryFeatures_Size = cmock_size; +} + +void vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceGroupPeerMemoryFeaturesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceGroupPeerMemoryFeaturesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockIgnoreArg_heapIndex(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceGroupPeerMemoryFeaturesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceGroupPeerMemoryFeaturesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_heapIndex = 1; +} + +void vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockIgnoreArg_localDeviceIndex(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceGroupPeerMemoryFeaturesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceGroupPeerMemoryFeaturesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_localDeviceIndex = 1; +} + +void vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockIgnoreArg_remoteDeviceIndex(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceGroupPeerMemoryFeaturesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceGroupPeerMemoryFeaturesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_remoteDeviceIndex = 1; +} + +void vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockIgnoreArg_pPeerMemoryFeatures(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceGroupPeerMemoryFeaturesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceGroupPeerMemoryFeaturesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceGroupPeerMemoryFeaturesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPeerMemoryFeatures = 1; +} + +void vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetDeviceMaskKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetDeviceMaskKHR); + cmock_call_instance = (CMOCK_vkCmdSetDeviceMaskKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetDeviceMaskKHR_CallInstance); + Mock.vkCmdSetDeviceMaskKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetDeviceMaskKHR_CallInstance); + if (Mock.vkCmdSetDeviceMaskKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetDeviceMaskKHR_CallbackBool && + Mock.vkCmdSetDeviceMaskKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDeviceMaskKHR_CallbackFunctionPointer(commandBuffer, deviceMask, Mock.vkCmdSetDeviceMaskKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDeviceMaskKHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_deviceMask) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDeviceMaskKHR,CMockString_deviceMask); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_deviceMask, deviceMask, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetDeviceMaskKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDeviceMaskKHR_CallbackFunctionPointer(commandBuffer, deviceMask, Mock.vkCmdSetDeviceMaskKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetDeviceMaskKHR(CMOCK_vkCmdSetDeviceMaskKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t deviceMask); +void CMockExpectParameters_vkCmdSetDeviceMaskKHR(CMOCK_vkCmdSetDeviceMaskKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t deviceMask) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_deviceMask = deviceMask; + cmock_call_instance->IgnoreArg_deviceMask = 0; +} + +void vkCmdSetDeviceMaskKHR_CMockIgnore(void) +{ + Mock.vkCmdSetDeviceMaskKHR_IgnoreBool = (char)1; +} + +void vkCmdSetDeviceMaskKHR_CMockStopIgnore(void) +{ + Mock.vkCmdSetDeviceMaskKHR_IgnoreBool = (char)0; +} + +void vkCmdSetDeviceMaskKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDeviceMaskKHR_CALL_INSTANCE)); + CMOCK_vkCmdSetDeviceMaskKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDeviceMaskKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDeviceMaskKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDeviceMaskKHR_CallInstance, cmock_guts_index); + Mock.vkCmdSetDeviceMaskKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetDeviceMaskKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t deviceMask) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDeviceMaskKHR_CALL_INSTANCE)); + CMOCK_vkCmdSetDeviceMaskKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDeviceMaskKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDeviceMaskKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDeviceMaskKHR_CallInstance, cmock_guts_index); + Mock.vkCmdSetDeviceMaskKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetDeviceMaskKHR(cmock_call_instance, commandBuffer, deviceMask); +} + +void vkCmdSetDeviceMaskKHR_AddCallback(CMOCK_vkCmdSetDeviceMaskKHR_CALLBACK Callback) +{ + Mock.vkCmdSetDeviceMaskKHR_IgnoreBool = (char)0; + Mock.vkCmdSetDeviceMaskKHR_CallbackBool = (char)1; + Mock.vkCmdSetDeviceMaskKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDeviceMaskKHR_Stub(CMOCK_vkCmdSetDeviceMaskKHR_CALLBACK Callback) +{ + Mock.vkCmdSetDeviceMaskKHR_IgnoreBool = (char)0; + Mock.vkCmdSetDeviceMaskKHR_CallbackBool = (char)0; + Mock.vkCmdSetDeviceMaskKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDeviceMaskKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDeviceMaskKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDeviceMaskKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDeviceMaskKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetDeviceMaskKHR_CMockIgnoreArg_deviceMask(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDeviceMaskKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDeviceMaskKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDeviceMaskKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_deviceMask = 1; +} + +void vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDispatchBaseKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDispatchBaseKHR); + cmock_call_instance = (CMOCK_vkCmdDispatchBaseKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDispatchBaseKHR_CallInstance); + Mock.vkCmdDispatchBaseKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDispatchBaseKHR_CallInstance); + if (Mock.vkCmdDispatchBaseKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDispatchBaseKHR_CallbackBool && + Mock.vkCmdDispatchBaseKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDispatchBaseKHR_CallbackFunctionPointer(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ, Mock.vkCmdDispatchBaseKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDispatchBaseKHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_baseGroupX) + { + UNITY_SET_DETAILS(CMockString_vkCmdDispatchBaseKHR,CMockString_baseGroupX); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_baseGroupX, baseGroupX, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_baseGroupY) + { + UNITY_SET_DETAILS(CMockString_vkCmdDispatchBaseKHR,CMockString_baseGroupY); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_baseGroupY, baseGroupY, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_baseGroupZ) + { + UNITY_SET_DETAILS(CMockString_vkCmdDispatchBaseKHR,CMockString_baseGroupZ); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_baseGroupZ, baseGroupZ, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_groupCountX) + { + UNITY_SET_DETAILS(CMockString_vkCmdDispatchBaseKHR,CMockString_groupCountX); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_groupCountX, groupCountX, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_groupCountY) + { + UNITY_SET_DETAILS(CMockString_vkCmdDispatchBaseKHR,CMockString_groupCountY); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_groupCountY, groupCountY, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_groupCountZ) + { + UNITY_SET_DETAILS(CMockString_vkCmdDispatchBaseKHR,CMockString_groupCountZ); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_groupCountZ, groupCountZ, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdDispatchBaseKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDispatchBaseKHR_CallbackFunctionPointer(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ, Mock.vkCmdDispatchBaseKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDispatchBaseKHR(CMOCK_vkCmdDispatchBaseKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +void CMockExpectParameters_vkCmdDispatchBaseKHR(CMOCK_vkCmdDispatchBaseKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_baseGroupX = baseGroupX; + cmock_call_instance->IgnoreArg_baseGroupX = 0; + cmock_call_instance->Expected_baseGroupY = baseGroupY; + cmock_call_instance->IgnoreArg_baseGroupY = 0; + cmock_call_instance->Expected_baseGroupZ = baseGroupZ; + cmock_call_instance->IgnoreArg_baseGroupZ = 0; + cmock_call_instance->Expected_groupCountX = groupCountX; + cmock_call_instance->IgnoreArg_groupCountX = 0; + cmock_call_instance->Expected_groupCountY = groupCountY; + cmock_call_instance->IgnoreArg_groupCountY = 0; + cmock_call_instance->Expected_groupCountZ = groupCountZ; + cmock_call_instance->IgnoreArg_groupCountZ = 0; +} + +void vkCmdDispatchBaseKHR_CMockIgnore(void) +{ + Mock.vkCmdDispatchBaseKHR_IgnoreBool = (char)1; +} + +void vkCmdDispatchBaseKHR_CMockStopIgnore(void) +{ + Mock.vkCmdDispatchBaseKHR_IgnoreBool = (char)0; +} + +void vkCmdDispatchBaseKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDispatchBaseKHR_CALL_INSTANCE)); + CMOCK_vkCmdDispatchBaseKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDispatchBaseKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDispatchBaseKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDispatchBaseKHR_CallInstance, cmock_guts_index); + Mock.vkCmdDispatchBaseKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDispatchBaseKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDispatchBaseKHR_CALL_INSTANCE)); + CMOCK_vkCmdDispatchBaseKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDispatchBaseKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDispatchBaseKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDispatchBaseKHR_CallInstance, cmock_guts_index); + Mock.vkCmdDispatchBaseKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDispatchBaseKHR(cmock_call_instance, commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); +} + +void vkCmdDispatchBaseKHR_AddCallback(CMOCK_vkCmdDispatchBaseKHR_CALLBACK Callback) +{ + Mock.vkCmdDispatchBaseKHR_IgnoreBool = (char)0; + Mock.vkCmdDispatchBaseKHR_CallbackBool = (char)1; + Mock.vkCmdDispatchBaseKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdDispatchBaseKHR_Stub(CMOCK_vkCmdDispatchBaseKHR_CALLBACK Callback) +{ + Mock.vkCmdDispatchBaseKHR_IgnoreBool = (char)0; + Mock.vkCmdDispatchBaseKHR_CallbackBool = (char)0; + Mock.vkCmdDispatchBaseKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdDispatchBaseKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDispatchBaseKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDispatchBaseKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDispatchBaseKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDispatchBaseKHR_CMockIgnoreArg_baseGroupX(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDispatchBaseKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDispatchBaseKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDispatchBaseKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_baseGroupX = 1; +} + +void vkCmdDispatchBaseKHR_CMockIgnoreArg_baseGroupY(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDispatchBaseKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDispatchBaseKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDispatchBaseKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_baseGroupY = 1; +} + +void vkCmdDispatchBaseKHR_CMockIgnoreArg_baseGroupZ(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDispatchBaseKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDispatchBaseKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDispatchBaseKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_baseGroupZ = 1; +} + +void vkCmdDispatchBaseKHR_CMockIgnoreArg_groupCountX(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDispatchBaseKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDispatchBaseKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDispatchBaseKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_groupCountX = 1; +} + +void vkCmdDispatchBaseKHR_CMockIgnoreArg_groupCountY(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDispatchBaseKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDispatchBaseKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDispatchBaseKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_groupCountY = 1; +} + +void vkCmdDispatchBaseKHR_CMockIgnoreArg_groupCountZ(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDispatchBaseKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDispatchBaseKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDispatchBaseKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_groupCountZ = 1; +} + +void vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkTrimCommandPoolKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkTrimCommandPoolKHR); + cmock_call_instance = (CMOCK_vkTrimCommandPoolKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkTrimCommandPoolKHR_CallInstance); + Mock.vkTrimCommandPoolKHR_CallInstance = CMock_Guts_MemNext(Mock.vkTrimCommandPoolKHR_CallInstance); + if (Mock.vkTrimCommandPoolKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkTrimCommandPoolKHR_CallbackBool && + Mock.vkTrimCommandPoolKHR_CallbackFunctionPointer != NULL) + { + Mock.vkTrimCommandPoolKHR_CallbackFunctionPointer(device, commandPool, flags, Mock.vkTrimCommandPoolKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkTrimCommandPoolKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_commandPool) + { + UNITY_SET_DETAILS(CMockString_vkTrimCommandPoolKHR,CMockString_commandPool); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandPool), (void*)(&commandPool), sizeof(VkCommandPool), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_flags) + { + UNITY_SET_DETAILS(CMockString_vkTrimCommandPoolKHR,CMockString_flags); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_flags), (void*)(&flags), sizeof(VkCommandPoolTrimFlags), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkTrimCommandPoolKHR_CallbackFunctionPointer != NULL) + { + Mock.vkTrimCommandPoolKHR_CallbackFunctionPointer(device, commandPool, flags, Mock.vkTrimCommandPoolKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkTrimCommandPoolKHR(CMOCK_vkTrimCommandPoolKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); +void CMockExpectParameters_vkTrimCommandPoolKHR(CMOCK_vkTrimCommandPoolKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_commandPool), (void*)(&commandPool), + sizeof(VkCommandPool[sizeof(commandPool) == sizeof(VkCommandPool) ? 1 : -1])); /* add VkCommandPool to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandPool = 0; + memcpy((void*)(&cmock_call_instance->Expected_flags), (void*)(&flags), + sizeof(VkCommandPoolTrimFlags[sizeof(flags) == sizeof(VkCommandPoolTrimFlags) ? 1 : -1])); /* add VkCommandPoolTrimFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_flags = 0; +} + +void vkTrimCommandPoolKHR_CMockIgnore(void) +{ + Mock.vkTrimCommandPoolKHR_IgnoreBool = (char)1; +} + +void vkTrimCommandPoolKHR_CMockStopIgnore(void) +{ + Mock.vkTrimCommandPoolKHR_IgnoreBool = (char)0; +} + +void vkTrimCommandPoolKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkTrimCommandPoolKHR_CALL_INSTANCE)); + CMOCK_vkTrimCommandPoolKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkTrimCommandPoolKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkTrimCommandPoolKHR_CallInstance = CMock_Guts_MemChain(Mock.vkTrimCommandPoolKHR_CallInstance, cmock_guts_index); + Mock.vkTrimCommandPoolKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkTrimCommandPoolKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkTrimCommandPoolKHR_CALL_INSTANCE)); + CMOCK_vkTrimCommandPoolKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkTrimCommandPoolKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkTrimCommandPoolKHR_CallInstance = CMock_Guts_MemChain(Mock.vkTrimCommandPoolKHR_CallInstance, cmock_guts_index); + Mock.vkTrimCommandPoolKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkTrimCommandPoolKHR(cmock_call_instance, device, commandPool, flags); +} + +void vkTrimCommandPoolKHR_AddCallback(CMOCK_vkTrimCommandPoolKHR_CALLBACK Callback) +{ + Mock.vkTrimCommandPoolKHR_IgnoreBool = (char)0; + Mock.vkTrimCommandPoolKHR_CallbackBool = (char)1; + Mock.vkTrimCommandPoolKHR_CallbackFunctionPointer = Callback; +} + +void vkTrimCommandPoolKHR_Stub(CMOCK_vkTrimCommandPoolKHR_CALLBACK Callback) +{ + Mock.vkTrimCommandPoolKHR_IgnoreBool = (char)0; + Mock.vkTrimCommandPoolKHR_CallbackBool = (char)0; + Mock.vkTrimCommandPoolKHR_CallbackFunctionPointer = Callback; +} + +void vkTrimCommandPoolKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkTrimCommandPoolKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkTrimCommandPoolKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkTrimCommandPoolKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkTrimCommandPoolKHR_CMockIgnoreArg_commandPool(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkTrimCommandPoolKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkTrimCommandPoolKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkTrimCommandPoolKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandPool = 1; +} + +void vkTrimCommandPoolKHR_CMockIgnoreArg_flags(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkTrimCommandPoolKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkTrimCommandPoolKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkTrimCommandPoolKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_flags = 1; +} + +VkResult vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkEnumeratePhysicalDeviceGroupsKHR); + cmock_call_instance = (CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkEnumeratePhysicalDeviceGroupsKHR_CallInstance); + Mock.vkEnumeratePhysicalDeviceGroupsKHR_CallInstance = CMock_Guts_MemNext(Mock.vkEnumeratePhysicalDeviceGroupsKHR_CallInstance); + if (Mock.vkEnumeratePhysicalDeviceGroupsKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkEnumeratePhysicalDeviceGroupsKHR_FinalReturn; + memcpy((void*)(&Mock.vkEnumeratePhysicalDeviceGroupsKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkEnumeratePhysicalDeviceGroupsKHR_CallbackBool && + Mock.vkEnumeratePhysicalDeviceGroupsKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkEnumeratePhysicalDeviceGroupsKHR_CallbackFunctionPointer(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, Mock.vkEnumeratePhysicalDeviceGroupsKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_instance) + { + UNITY_SET_DETAILS(CMockString_vkEnumeratePhysicalDeviceGroupsKHR,CMockString_instance); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), sizeof(VkInstance), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPhysicalDeviceGroupCount) + { + UNITY_SET_DETAILS(CMockString_vkEnumeratePhysicalDeviceGroupsKHR,CMockString_pPhysicalDeviceGroupCount); + if (cmock_call_instance->Expected_pPhysicalDeviceGroupCount == NULL) + { UNITY_TEST_ASSERT_NULL(pPhysicalDeviceGroupCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pPhysicalDeviceGroupCount, pPhysicalDeviceGroupCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pPhysicalDeviceGroupProperties) + { + UNITY_SET_DETAILS(CMockString_vkEnumeratePhysicalDeviceGroupsKHR,CMockString_pPhysicalDeviceGroupProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pPhysicalDeviceGroupProperties), (void*)(pPhysicalDeviceGroupProperties), sizeof(VkPhysicalDeviceGroupProperties), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkEnumeratePhysicalDeviceGroupsKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkEnumeratePhysicalDeviceGroupsKHR_CallbackFunctionPointer(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, Mock.vkEnumeratePhysicalDeviceGroupsKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPhysicalDeviceGroupCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPhysicalDeviceGroupCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPhysicalDeviceGroupCount, (const void*)cmock_call_instance->ReturnThruPtr_pPhysicalDeviceGroupCount_Val, + cmock_call_instance->ReturnThruPtr_pPhysicalDeviceGroupCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pPhysicalDeviceGroupProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPhysicalDeviceGroupProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPhysicalDeviceGroupProperties, (const void*)cmock_call_instance->ReturnThruPtr_pPhysicalDeviceGroupProperties_Val, + cmock_call_instance->ReturnThruPtr_pPhysicalDeviceGroupProperties_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkEnumeratePhysicalDeviceGroupsKHR(CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALL_INSTANCE* cmock_call_instance, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); +void CMockExpectParameters_vkEnumeratePhysicalDeviceGroupsKHR(CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALL_INSTANCE* cmock_call_instance, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), + sizeof(VkInstance[sizeof(instance) == sizeof(VkInstance) ? 1 : -1])); /* add VkInstance to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_instance = 0; + cmock_call_instance->Expected_pPhysicalDeviceGroupCount = pPhysicalDeviceGroupCount; + cmock_call_instance->IgnoreArg_pPhysicalDeviceGroupCount = 0; + cmock_call_instance->ReturnThruPtr_pPhysicalDeviceGroupCount_Used = 0; + cmock_call_instance->Expected_pPhysicalDeviceGroupProperties = pPhysicalDeviceGroupProperties; + cmock_call_instance->IgnoreArg_pPhysicalDeviceGroupProperties = 0; + cmock_call_instance->ReturnThruPtr_pPhysicalDeviceGroupProperties_Used = 0; +} + +void vkEnumeratePhysicalDeviceGroupsKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALL_INSTANCE)); + CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkEnumeratePhysicalDeviceGroupsKHR_CallInstance = CMock_Guts_MemChain(Mock.vkEnumeratePhysicalDeviceGroupsKHR_CallInstance, cmock_guts_index); + Mock.vkEnumeratePhysicalDeviceGroupsKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkEnumeratePhysicalDeviceGroupsKHR_IgnoreBool = (char)1; +} + +void vkEnumeratePhysicalDeviceGroupsKHR_CMockStopIgnore(void) +{ + if(Mock.vkEnumeratePhysicalDeviceGroupsKHR_IgnoreBool) + Mock.vkEnumeratePhysicalDeviceGroupsKHR_CallInstance = CMock_Guts_MemNext(Mock.vkEnumeratePhysicalDeviceGroupsKHR_CallInstance); + Mock.vkEnumeratePhysicalDeviceGroupsKHR_IgnoreBool = (char)0; +} + +void vkEnumeratePhysicalDeviceGroupsKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALL_INSTANCE)); + CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkEnumeratePhysicalDeviceGroupsKHR_CallInstance = CMock_Guts_MemChain(Mock.vkEnumeratePhysicalDeviceGroupsKHR_CallInstance, cmock_guts_index); + Mock.vkEnumeratePhysicalDeviceGroupsKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkEnumeratePhysicalDeviceGroupsKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALL_INSTANCE)); + CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkEnumeratePhysicalDeviceGroupsKHR_CallInstance = CMock_Guts_MemChain(Mock.vkEnumeratePhysicalDeviceGroupsKHR_CallInstance, cmock_guts_index); + Mock.vkEnumeratePhysicalDeviceGroupsKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkEnumeratePhysicalDeviceGroupsKHR(cmock_call_instance, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkEnumeratePhysicalDeviceGroupsKHR_AddCallback(CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALLBACK Callback) +{ + Mock.vkEnumeratePhysicalDeviceGroupsKHR_IgnoreBool = (char)0; + Mock.vkEnumeratePhysicalDeviceGroupsKHR_CallbackBool = (char)1; + Mock.vkEnumeratePhysicalDeviceGroupsKHR_CallbackFunctionPointer = Callback; +} + +void vkEnumeratePhysicalDeviceGroupsKHR_Stub(CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALLBACK Callback) +{ + Mock.vkEnumeratePhysicalDeviceGroupsKHR_IgnoreBool = (char)0; + Mock.vkEnumeratePhysicalDeviceGroupsKHR_CallbackBool = (char)0; + Mock.vkEnumeratePhysicalDeviceGroupsKHR_CallbackFunctionPointer = Callback; +} + +void vkEnumeratePhysicalDeviceGroupsKHR_CMockReturnMemThruPtr_pPhysicalDeviceGroupCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPhysicalDeviceGroupCount, size_t cmock_size) +{ + CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumeratePhysicalDeviceGroupsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPhysicalDeviceGroupCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pPhysicalDeviceGroupCount_Val = pPhysicalDeviceGroupCount; + cmock_call_instance->ReturnThruPtr_pPhysicalDeviceGroupCount_Size = cmock_size; +} + +void vkEnumeratePhysicalDeviceGroupsKHR_CMockReturnMemThruPtr_pPhysicalDeviceGroupProperties(UNITY_LINE_TYPE cmock_line, VkPhysicalDeviceGroupProperties const* pPhysicalDeviceGroupProperties, size_t cmock_size) +{ + CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumeratePhysicalDeviceGroupsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPhysicalDeviceGroupProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pPhysicalDeviceGroupProperties_Val = pPhysicalDeviceGroupProperties; + cmock_call_instance->ReturnThruPtr_pPhysicalDeviceGroupProperties_Size = cmock_size; +} + +void vkEnumeratePhysicalDeviceGroupsKHR_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumeratePhysicalDeviceGroupsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_instance = 1; +} + +void vkEnumeratePhysicalDeviceGroupsKHR_CMockIgnoreArg_pPhysicalDeviceGroupCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumeratePhysicalDeviceGroupsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPhysicalDeviceGroupCount = 1; +} + +void vkEnumeratePhysicalDeviceGroupsKHR_CMockIgnoreArg_pPhysicalDeviceGroupProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumeratePhysicalDeviceGroupsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPhysicalDeviceGroupProperties = 1; +} + +void vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceExternalBufferPropertiesKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceExternalBufferPropertiesKHR); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalBufferPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_CallInstance); + Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_CallInstance); + if (Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_CallbackBool && + Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_CallbackFunctionPointer(physicalDevice, pExternalBufferInfo, pExternalBufferProperties, Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceExternalBufferPropertiesKHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pExternalBufferInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceExternalBufferPropertiesKHR,CMockString_pExternalBufferInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pExternalBufferInfo), (void*)(pExternalBufferInfo), sizeof(const VkPhysicalDeviceExternalBufferInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pExternalBufferProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceExternalBufferPropertiesKHR,CMockString_pExternalBufferProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pExternalBufferProperties), (void*)(pExternalBufferProperties), sizeof(VkExternalBufferProperties), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_CallbackFunctionPointer(physicalDevice, pExternalBufferInfo, pExternalBufferProperties, Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pExternalBufferProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pExternalBufferProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pExternalBufferProperties, (const void*)cmock_call_instance->ReturnThruPtr_pExternalBufferProperties_Val, + cmock_call_instance->ReturnThruPtr_pExternalBufferProperties_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetPhysicalDeviceExternalBufferPropertiesKHR(CMOCK_vkGetPhysicalDeviceExternalBufferPropertiesKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); +void CMockExpectParameters_vkGetPhysicalDeviceExternalBufferPropertiesKHR(CMOCK_vkGetPhysicalDeviceExternalBufferPropertiesKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pExternalBufferInfo = pExternalBufferInfo; + cmock_call_instance->IgnoreArg_pExternalBufferInfo = 0; + cmock_call_instance->Expected_pExternalBufferProperties = pExternalBufferProperties; + cmock_call_instance->IgnoreArg_pExternalBufferProperties = 0; + cmock_call_instance->ReturnThruPtr_pExternalBufferProperties_Used = 0; +} + +void vkGetPhysicalDeviceExternalBufferPropertiesKHR_CMockIgnore(void) +{ + Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceExternalBufferPropertiesKHR_CMockStopIgnore(void) +{ + Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceExternalBufferPropertiesKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceExternalBufferPropertiesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceExternalBufferPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalBufferPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceExternalBufferPropertiesKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceExternalBufferPropertiesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceExternalBufferPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalBufferPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceExternalBufferPropertiesKHR(cmock_call_instance, physicalDevice, pExternalBufferInfo, pExternalBufferProperties); +} + +void vkGetPhysicalDeviceExternalBufferPropertiesKHR_AddCallback(CMOCK_vkGetPhysicalDeviceExternalBufferPropertiesKHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceExternalBufferPropertiesKHR_Stub(CMOCK_vkGetPhysicalDeviceExternalBufferPropertiesKHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceExternalBufferPropertiesKHR_CMockReturnMemThruPtr_pExternalBufferProperties(UNITY_LINE_TYPE cmock_line, VkExternalBufferProperties const* pExternalBufferProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceExternalBufferPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalBufferPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pExternalBufferProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pExternalBufferProperties_Val = pExternalBufferProperties; + cmock_call_instance->ReturnThruPtr_pExternalBufferProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceExternalBufferPropertiesKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceExternalBufferPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalBufferPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceExternalBufferPropertiesKHR_CMockIgnoreArg_pExternalBufferInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceExternalBufferPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalBufferPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pExternalBufferInfo = 1; +} + +void vkGetPhysicalDeviceExternalBufferPropertiesKHR_CMockIgnoreArg_pExternalBufferProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceExternalBufferPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalBufferPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalBufferPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pExternalBufferProperties = 1; +} + +VkResult vkGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetMemoryFdKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetMemoryFdKHR); + cmock_call_instance = (CMOCK_vkGetMemoryFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetMemoryFdKHR_CallInstance); + Mock.vkGetMemoryFdKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetMemoryFdKHR_CallInstance); + if (Mock.vkGetMemoryFdKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetMemoryFdKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetMemoryFdKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetMemoryFdKHR_CallbackBool && + Mock.vkGetMemoryFdKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetMemoryFdKHR_CallbackFunctionPointer(device, pGetFdInfo, pFd, Mock.vkGetMemoryFdKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetMemoryFdKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pGetFdInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetMemoryFdKHR,CMockString_pGetFdInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pGetFdInfo), (void*)(pGetFdInfo), sizeof(const VkMemoryGetFdInfoKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pFd) + { + UNITY_SET_DETAILS(CMockString_vkGetMemoryFdKHR,CMockString_pFd); + if (cmock_call_instance->Expected_pFd == NULL) + { UNITY_TEST_ASSERT_NULL(pFd, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_INT_ARRAY(cmock_call_instance->Expected_pFd, pFd, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkGetMemoryFdKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetMemoryFdKHR_CallbackFunctionPointer(device, pGetFdInfo, pFd, Mock.vkGetMemoryFdKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pFd_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pFd, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pFd, (const void*)cmock_call_instance->ReturnThruPtr_pFd_Val, + cmock_call_instance->ReturnThruPtr_pFd_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetMemoryFdKHR(CMOCK_vkGetMemoryFdKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd); +void CMockExpectParameters_vkGetMemoryFdKHR(CMOCK_vkGetMemoryFdKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pGetFdInfo = pGetFdInfo; + cmock_call_instance->IgnoreArg_pGetFdInfo = 0; + cmock_call_instance->Expected_pFd = pFd; + cmock_call_instance->IgnoreArg_pFd = 0; + cmock_call_instance->ReturnThruPtr_pFd_Used = 0; +} + +void vkGetMemoryFdKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetMemoryFdKHR_CALL_INSTANCE)); + CMOCK_vkGetMemoryFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMemoryFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetMemoryFdKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetMemoryFdKHR_CallInstance, cmock_guts_index); + Mock.vkGetMemoryFdKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetMemoryFdKHR_IgnoreBool = (char)1; +} + +void vkGetMemoryFdKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetMemoryFdKHR_IgnoreBool) + Mock.vkGetMemoryFdKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetMemoryFdKHR_CallInstance); + Mock.vkGetMemoryFdKHR_IgnoreBool = (char)0; +} + +void vkGetMemoryFdKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetMemoryFdKHR_CALL_INSTANCE)); + CMOCK_vkGetMemoryFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMemoryFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetMemoryFdKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetMemoryFdKHR_CallInstance, cmock_guts_index); + Mock.vkGetMemoryFdKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetMemoryFdKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetMemoryFdKHR_CALL_INSTANCE)); + CMOCK_vkGetMemoryFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMemoryFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetMemoryFdKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetMemoryFdKHR_CallInstance, cmock_guts_index); + Mock.vkGetMemoryFdKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetMemoryFdKHR(cmock_call_instance, device, pGetFdInfo, pFd); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetMemoryFdKHR_AddCallback(CMOCK_vkGetMemoryFdKHR_CALLBACK Callback) +{ + Mock.vkGetMemoryFdKHR_IgnoreBool = (char)0; + Mock.vkGetMemoryFdKHR_CallbackBool = (char)1; + Mock.vkGetMemoryFdKHR_CallbackFunctionPointer = Callback; +} + +void vkGetMemoryFdKHR_Stub(CMOCK_vkGetMemoryFdKHR_CALLBACK Callback) +{ + Mock.vkGetMemoryFdKHR_IgnoreBool = (char)0; + Mock.vkGetMemoryFdKHR_CallbackBool = (char)0; + Mock.vkGetMemoryFdKHR_CallbackFunctionPointer = Callback; +} + +void vkGetMemoryFdKHR_CMockReturnMemThruPtr_pFd(UNITY_LINE_TYPE cmock_line, int const* pFd, size_t cmock_size) +{ + CMOCK_vkGetMemoryFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMemoryFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetMemoryFdKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pFd_Used = 1; + cmock_call_instance->ReturnThruPtr_pFd_Val = pFd; + cmock_call_instance->ReturnThruPtr_pFd_Size = cmock_size; +} + +void vkGetMemoryFdKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetMemoryFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMemoryFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetMemoryFdKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetMemoryFdKHR_CMockIgnoreArg_pGetFdInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetMemoryFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMemoryFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetMemoryFdKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pGetFdInfo = 1; +} + +void vkGetMemoryFdKHR_CMockIgnoreArg_pFd(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetMemoryFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMemoryFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetMemoryFdKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pFd = 1; +} + +VkResult vkGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetMemoryFdPropertiesKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetMemoryFdPropertiesKHR); + cmock_call_instance = (CMOCK_vkGetMemoryFdPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetMemoryFdPropertiesKHR_CallInstance); + Mock.vkGetMemoryFdPropertiesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetMemoryFdPropertiesKHR_CallInstance); + if (Mock.vkGetMemoryFdPropertiesKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetMemoryFdPropertiesKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetMemoryFdPropertiesKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetMemoryFdPropertiesKHR_CallbackBool && + Mock.vkGetMemoryFdPropertiesKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetMemoryFdPropertiesKHR_CallbackFunctionPointer(device, handleType, fd, pMemoryFdProperties, Mock.vkGetMemoryFdPropertiesKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetMemoryFdPropertiesKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_handleType) + { + UNITY_SET_DETAILS(CMockString_vkGetMemoryFdPropertiesKHR,CMockString_handleType); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_handleType), (void*)(&handleType), sizeof(VkExternalMemoryHandleTypeFlagBits), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_fd) + { + UNITY_SET_DETAILS(CMockString_vkGetMemoryFdPropertiesKHR,CMockString_fd); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_fd, fd, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMemoryFdProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetMemoryFdPropertiesKHR,CMockString_pMemoryFdProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMemoryFdProperties), (void*)(pMemoryFdProperties), sizeof(VkMemoryFdPropertiesKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetMemoryFdPropertiesKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetMemoryFdPropertiesKHR_CallbackFunctionPointer(device, handleType, fd, pMemoryFdProperties, Mock.vkGetMemoryFdPropertiesKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pMemoryFdProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pMemoryFdProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pMemoryFdProperties, (const void*)cmock_call_instance->ReturnThruPtr_pMemoryFdProperties_Val, + cmock_call_instance->ReturnThruPtr_pMemoryFdProperties_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetMemoryFdPropertiesKHR(CMOCK_vkGetMemoryFdPropertiesKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties); +void CMockExpectParameters_vkGetMemoryFdPropertiesKHR(CMOCK_vkGetMemoryFdPropertiesKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_handleType), (void*)(&handleType), + sizeof(VkExternalMemoryHandleTypeFlagBits[sizeof(handleType) == sizeof(VkExternalMemoryHandleTypeFlagBits) ? 1 : -1])); /* add VkExternalMemoryHandleTypeFlagBits to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_handleType = 0; + cmock_call_instance->Expected_fd = fd; + cmock_call_instance->IgnoreArg_fd = 0; + cmock_call_instance->Expected_pMemoryFdProperties = pMemoryFdProperties; + cmock_call_instance->IgnoreArg_pMemoryFdProperties = 0; + cmock_call_instance->ReturnThruPtr_pMemoryFdProperties_Used = 0; +} + +void vkGetMemoryFdPropertiesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetMemoryFdPropertiesKHR_CALL_INSTANCE)); + CMOCK_vkGetMemoryFdPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMemoryFdPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetMemoryFdPropertiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetMemoryFdPropertiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetMemoryFdPropertiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetMemoryFdPropertiesKHR_IgnoreBool = (char)1; +} + +void vkGetMemoryFdPropertiesKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetMemoryFdPropertiesKHR_IgnoreBool) + Mock.vkGetMemoryFdPropertiesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetMemoryFdPropertiesKHR_CallInstance); + Mock.vkGetMemoryFdPropertiesKHR_IgnoreBool = (char)0; +} + +void vkGetMemoryFdPropertiesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetMemoryFdPropertiesKHR_CALL_INSTANCE)); + CMOCK_vkGetMemoryFdPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMemoryFdPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetMemoryFdPropertiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetMemoryFdPropertiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetMemoryFdPropertiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetMemoryFdPropertiesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetMemoryFdPropertiesKHR_CALL_INSTANCE)); + CMOCK_vkGetMemoryFdPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMemoryFdPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetMemoryFdPropertiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetMemoryFdPropertiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetMemoryFdPropertiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetMemoryFdPropertiesKHR(cmock_call_instance, device, handleType, fd, pMemoryFdProperties); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetMemoryFdPropertiesKHR_AddCallback(CMOCK_vkGetMemoryFdPropertiesKHR_CALLBACK Callback) +{ + Mock.vkGetMemoryFdPropertiesKHR_IgnoreBool = (char)0; + Mock.vkGetMemoryFdPropertiesKHR_CallbackBool = (char)1; + Mock.vkGetMemoryFdPropertiesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetMemoryFdPropertiesKHR_Stub(CMOCK_vkGetMemoryFdPropertiesKHR_CALLBACK Callback) +{ + Mock.vkGetMemoryFdPropertiesKHR_IgnoreBool = (char)0; + Mock.vkGetMemoryFdPropertiesKHR_CallbackBool = (char)0; + Mock.vkGetMemoryFdPropertiesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetMemoryFdPropertiesKHR_CMockReturnMemThruPtr_pMemoryFdProperties(UNITY_LINE_TYPE cmock_line, VkMemoryFdPropertiesKHR const* pMemoryFdProperties, size_t cmock_size) +{ + CMOCK_vkGetMemoryFdPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMemoryFdPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetMemoryFdPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pMemoryFdProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pMemoryFdProperties_Val = pMemoryFdProperties; + cmock_call_instance->ReturnThruPtr_pMemoryFdProperties_Size = cmock_size; +} + +void vkGetMemoryFdPropertiesKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetMemoryFdPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMemoryFdPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetMemoryFdPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetMemoryFdPropertiesKHR_CMockIgnoreArg_handleType(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetMemoryFdPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMemoryFdPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetMemoryFdPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_handleType = 1; +} + +void vkGetMemoryFdPropertiesKHR_CMockIgnoreArg_fd(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetMemoryFdPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMemoryFdPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetMemoryFdPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_fd = 1; +} + +void vkGetMemoryFdPropertiesKHR_CMockIgnoreArg_pMemoryFdProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetMemoryFdPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMemoryFdPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetMemoryFdPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMemoryFdProperties = 1; +} + +void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CallInstance); + Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CallInstance); + if (Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CallbackBool && + Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CallbackFunctionPointer(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pExternalSemaphoreInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR,CMockString_pExternalSemaphoreInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pExternalSemaphoreInfo), (void*)(pExternalSemaphoreInfo), sizeof(const VkPhysicalDeviceExternalSemaphoreInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pExternalSemaphoreProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR,CMockString_pExternalSemaphoreProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pExternalSemaphoreProperties), (void*)(pExternalSemaphoreProperties), sizeof(VkExternalSemaphoreProperties), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CallbackFunctionPointer(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pExternalSemaphoreProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pExternalSemaphoreProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pExternalSemaphoreProperties, (const void*)cmock_call_instance->ReturnThruPtr_pExternalSemaphoreProperties_Val, + cmock_call_instance->ReturnThruPtr_pExternalSemaphoreProperties_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(CMOCK_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); +void CMockExpectParameters_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(CMOCK_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pExternalSemaphoreInfo = pExternalSemaphoreInfo; + cmock_call_instance->IgnoreArg_pExternalSemaphoreInfo = 0; + cmock_call_instance->Expected_pExternalSemaphoreProperties = pExternalSemaphoreProperties; + cmock_call_instance->IgnoreArg_pExternalSemaphoreProperties = 0; + cmock_call_instance->ReturnThruPtr_pExternalSemaphoreProperties_Used = 0; +} + +void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CMockIgnore(void) +{ + Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CMockStopIgnore(void) +{ + Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(cmock_call_instance, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); +} + +void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_AddCallback(CMOCK_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_Stub(CMOCK_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CMockReturnMemThruPtr_pExternalSemaphoreProperties(UNITY_LINE_TYPE cmock_line, VkExternalSemaphoreProperties const* pExternalSemaphoreProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pExternalSemaphoreProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pExternalSemaphoreProperties_Val = pExternalSemaphoreProperties; + cmock_call_instance->ReturnThruPtr_pExternalSemaphoreProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CMockIgnoreArg_pExternalSemaphoreInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pExternalSemaphoreInfo = 1; +} + +void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CMockIgnoreArg_pExternalSemaphoreProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pExternalSemaphoreProperties = 1; +} + +VkResult vkImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkImportSemaphoreFdKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkImportSemaphoreFdKHR); + cmock_call_instance = (CMOCK_vkImportSemaphoreFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkImportSemaphoreFdKHR_CallInstance); + Mock.vkImportSemaphoreFdKHR_CallInstance = CMock_Guts_MemNext(Mock.vkImportSemaphoreFdKHR_CallInstance); + if (Mock.vkImportSemaphoreFdKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkImportSemaphoreFdKHR_FinalReturn; + memcpy((void*)(&Mock.vkImportSemaphoreFdKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkImportSemaphoreFdKHR_CallbackBool && + Mock.vkImportSemaphoreFdKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkImportSemaphoreFdKHR_CallbackFunctionPointer(device, pImportSemaphoreFdInfo, Mock.vkImportSemaphoreFdKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkImportSemaphoreFdKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pImportSemaphoreFdInfo) + { + UNITY_SET_DETAILS(CMockString_vkImportSemaphoreFdKHR,CMockString_pImportSemaphoreFdInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pImportSemaphoreFdInfo), (void*)(pImportSemaphoreFdInfo), sizeof(const VkImportSemaphoreFdInfoKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkImportSemaphoreFdKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkImportSemaphoreFdKHR_CallbackFunctionPointer(device, pImportSemaphoreFdInfo, Mock.vkImportSemaphoreFdKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkImportSemaphoreFdKHR(CMOCK_vkImportSemaphoreFdKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); +void CMockExpectParameters_vkImportSemaphoreFdKHR(CMOCK_vkImportSemaphoreFdKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pImportSemaphoreFdInfo = pImportSemaphoreFdInfo; + cmock_call_instance->IgnoreArg_pImportSemaphoreFdInfo = 0; +} + +void vkImportSemaphoreFdKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkImportSemaphoreFdKHR_CALL_INSTANCE)); + CMOCK_vkImportSemaphoreFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkImportSemaphoreFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkImportSemaphoreFdKHR_CallInstance = CMock_Guts_MemChain(Mock.vkImportSemaphoreFdKHR_CallInstance, cmock_guts_index); + Mock.vkImportSemaphoreFdKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkImportSemaphoreFdKHR_IgnoreBool = (char)1; +} + +void vkImportSemaphoreFdKHR_CMockStopIgnore(void) +{ + if(Mock.vkImportSemaphoreFdKHR_IgnoreBool) + Mock.vkImportSemaphoreFdKHR_CallInstance = CMock_Guts_MemNext(Mock.vkImportSemaphoreFdKHR_CallInstance); + Mock.vkImportSemaphoreFdKHR_IgnoreBool = (char)0; +} + +void vkImportSemaphoreFdKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkImportSemaphoreFdKHR_CALL_INSTANCE)); + CMOCK_vkImportSemaphoreFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkImportSemaphoreFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkImportSemaphoreFdKHR_CallInstance = CMock_Guts_MemChain(Mock.vkImportSemaphoreFdKHR_CallInstance, cmock_guts_index); + Mock.vkImportSemaphoreFdKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkImportSemaphoreFdKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkImportSemaphoreFdKHR_CALL_INSTANCE)); + CMOCK_vkImportSemaphoreFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkImportSemaphoreFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkImportSemaphoreFdKHR_CallInstance = CMock_Guts_MemChain(Mock.vkImportSemaphoreFdKHR_CallInstance, cmock_guts_index); + Mock.vkImportSemaphoreFdKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkImportSemaphoreFdKHR(cmock_call_instance, device, pImportSemaphoreFdInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkImportSemaphoreFdKHR_AddCallback(CMOCK_vkImportSemaphoreFdKHR_CALLBACK Callback) +{ + Mock.vkImportSemaphoreFdKHR_IgnoreBool = (char)0; + Mock.vkImportSemaphoreFdKHR_CallbackBool = (char)1; + Mock.vkImportSemaphoreFdKHR_CallbackFunctionPointer = Callback; +} + +void vkImportSemaphoreFdKHR_Stub(CMOCK_vkImportSemaphoreFdKHR_CALLBACK Callback) +{ + Mock.vkImportSemaphoreFdKHR_IgnoreBool = (char)0; + Mock.vkImportSemaphoreFdKHR_CallbackBool = (char)0; + Mock.vkImportSemaphoreFdKHR_CallbackFunctionPointer = Callback; +} + +void vkImportSemaphoreFdKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkImportSemaphoreFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkImportSemaphoreFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkImportSemaphoreFdKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkImportSemaphoreFdKHR_CMockIgnoreArg_pImportSemaphoreFdInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkImportSemaphoreFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkImportSemaphoreFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkImportSemaphoreFdKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pImportSemaphoreFdInfo = 1; +} + +VkResult vkGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetSemaphoreFdKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetSemaphoreFdKHR); + cmock_call_instance = (CMOCK_vkGetSemaphoreFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetSemaphoreFdKHR_CallInstance); + Mock.vkGetSemaphoreFdKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetSemaphoreFdKHR_CallInstance); + if (Mock.vkGetSemaphoreFdKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetSemaphoreFdKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetSemaphoreFdKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetSemaphoreFdKHR_CallbackBool && + Mock.vkGetSemaphoreFdKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetSemaphoreFdKHR_CallbackFunctionPointer(device, pGetFdInfo, pFd, Mock.vkGetSemaphoreFdKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetSemaphoreFdKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pGetFdInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetSemaphoreFdKHR,CMockString_pGetFdInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pGetFdInfo), (void*)(pGetFdInfo), sizeof(const VkSemaphoreGetFdInfoKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pFd) + { + UNITY_SET_DETAILS(CMockString_vkGetSemaphoreFdKHR,CMockString_pFd); + if (cmock_call_instance->Expected_pFd == NULL) + { UNITY_TEST_ASSERT_NULL(pFd, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_INT_ARRAY(cmock_call_instance->Expected_pFd, pFd, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkGetSemaphoreFdKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetSemaphoreFdKHR_CallbackFunctionPointer(device, pGetFdInfo, pFd, Mock.vkGetSemaphoreFdKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pFd_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pFd, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pFd, (const void*)cmock_call_instance->ReturnThruPtr_pFd_Val, + cmock_call_instance->ReturnThruPtr_pFd_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetSemaphoreFdKHR(CMOCK_vkGetSemaphoreFdKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd); +void CMockExpectParameters_vkGetSemaphoreFdKHR(CMOCK_vkGetSemaphoreFdKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pGetFdInfo = pGetFdInfo; + cmock_call_instance->IgnoreArg_pGetFdInfo = 0; + cmock_call_instance->Expected_pFd = pFd; + cmock_call_instance->IgnoreArg_pFd = 0; + cmock_call_instance->ReturnThruPtr_pFd_Used = 0; +} + +void vkGetSemaphoreFdKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetSemaphoreFdKHR_CALL_INSTANCE)); + CMOCK_vkGetSemaphoreFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSemaphoreFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetSemaphoreFdKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetSemaphoreFdKHR_CallInstance, cmock_guts_index); + Mock.vkGetSemaphoreFdKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetSemaphoreFdKHR_IgnoreBool = (char)1; +} + +void vkGetSemaphoreFdKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetSemaphoreFdKHR_IgnoreBool) + Mock.vkGetSemaphoreFdKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetSemaphoreFdKHR_CallInstance); + Mock.vkGetSemaphoreFdKHR_IgnoreBool = (char)0; +} + +void vkGetSemaphoreFdKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetSemaphoreFdKHR_CALL_INSTANCE)); + CMOCK_vkGetSemaphoreFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSemaphoreFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetSemaphoreFdKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetSemaphoreFdKHR_CallInstance, cmock_guts_index); + Mock.vkGetSemaphoreFdKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetSemaphoreFdKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetSemaphoreFdKHR_CALL_INSTANCE)); + CMOCK_vkGetSemaphoreFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSemaphoreFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetSemaphoreFdKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetSemaphoreFdKHR_CallInstance, cmock_guts_index); + Mock.vkGetSemaphoreFdKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetSemaphoreFdKHR(cmock_call_instance, device, pGetFdInfo, pFd); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetSemaphoreFdKHR_AddCallback(CMOCK_vkGetSemaphoreFdKHR_CALLBACK Callback) +{ + Mock.vkGetSemaphoreFdKHR_IgnoreBool = (char)0; + Mock.vkGetSemaphoreFdKHR_CallbackBool = (char)1; + Mock.vkGetSemaphoreFdKHR_CallbackFunctionPointer = Callback; +} + +void vkGetSemaphoreFdKHR_Stub(CMOCK_vkGetSemaphoreFdKHR_CALLBACK Callback) +{ + Mock.vkGetSemaphoreFdKHR_IgnoreBool = (char)0; + Mock.vkGetSemaphoreFdKHR_CallbackBool = (char)0; + Mock.vkGetSemaphoreFdKHR_CallbackFunctionPointer = Callback; +} + +void vkGetSemaphoreFdKHR_CMockReturnMemThruPtr_pFd(UNITY_LINE_TYPE cmock_line, int const* pFd, size_t cmock_size) +{ + CMOCK_vkGetSemaphoreFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSemaphoreFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetSemaphoreFdKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pFd_Used = 1; + cmock_call_instance->ReturnThruPtr_pFd_Val = pFd; + cmock_call_instance->ReturnThruPtr_pFd_Size = cmock_size; +} + +void vkGetSemaphoreFdKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetSemaphoreFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSemaphoreFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetSemaphoreFdKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetSemaphoreFdKHR_CMockIgnoreArg_pGetFdInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetSemaphoreFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSemaphoreFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetSemaphoreFdKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pGetFdInfo = 1; +} + +void vkGetSemaphoreFdKHR_CMockIgnoreArg_pFd(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetSemaphoreFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSemaphoreFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetSemaphoreFdKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pFd = 1; +} + +void vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdPushDescriptorSetKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdPushDescriptorSetKHR); + cmock_call_instance = (CMOCK_vkCmdPushDescriptorSetKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdPushDescriptorSetKHR_CallInstance); + Mock.vkCmdPushDescriptorSetKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdPushDescriptorSetKHR_CallInstance); + if (Mock.vkCmdPushDescriptorSetKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdPushDescriptorSetKHR_CallbackBool && + Mock.vkCmdPushDescriptorSetKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdPushDescriptorSetKHR_CallbackFunctionPointer(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites, Mock.vkCmdPushDescriptorSetKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdPushDescriptorSetKHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pipelineBindPoint) + { + UNITY_SET_DETAILS(CMockString_vkCmdPushDescriptorSetKHR,CMockString_pipelineBindPoint); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_pipelineBindPoint), (void*)(&pipelineBindPoint), sizeof(VkPipelineBindPoint), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_layout) + { + UNITY_SET_DETAILS(CMockString_vkCmdPushDescriptorSetKHR,CMockString_layout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_layout), (void*)(&layout), sizeof(VkPipelineLayout), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_set) + { + UNITY_SET_DETAILS(CMockString_vkCmdPushDescriptorSetKHR,CMockString_set); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_set, set, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_descriptorWriteCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdPushDescriptorSetKHR,CMockString_descriptorWriteCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_descriptorWriteCount, descriptorWriteCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDescriptorWrites) + { + UNITY_SET_DETAILS(CMockString_vkCmdPushDescriptorSetKHR,CMockString_pDescriptorWrites); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDescriptorWrites), (void*)(pDescriptorWrites), sizeof(const VkWriteDescriptorSet), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdPushDescriptorSetKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdPushDescriptorSetKHR_CallbackFunctionPointer(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites, Mock.vkCmdPushDescriptorSetKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdPushDescriptorSetKHR(CMOCK_vkCmdPushDescriptorSetKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites); +void CMockExpectParameters_vkCmdPushDescriptorSetKHR(CMOCK_vkCmdPushDescriptorSetKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_pipelineBindPoint), (void*)(&pipelineBindPoint), + sizeof(VkPipelineBindPoint[sizeof(pipelineBindPoint) == sizeof(VkPipelineBindPoint) ? 1 : -1])); /* add VkPipelineBindPoint to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_pipelineBindPoint = 0; + memcpy((void*)(&cmock_call_instance->Expected_layout), (void*)(&layout), + sizeof(VkPipelineLayout[sizeof(layout) == sizeof(VkPipelineLayout) ? 1 : -1])); /* add VkPipelineLayout to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_layout = 0; + cmock_call_instance->Expected_set = set; + cmock_call_instance->IgnoreArg_set = 0; + cmock_call_instance->Expected_descriptorWriteCount = descriptorWriteCount; + cmock_call_instance->IgnoreArg_descriptorWriteCount = 0; + cmock_call_instance->Expected_pDescriptorWrites = pDescriptorWrites; + cmock_call_instance->IgnoreArg_pDescriptorWrites = 0; +} + +void vkCmdPushDescriptorSetKHR_CMockIgnore(void) +{ + Mock.vkCmdPushDescriptorSetKHR_IgnoreBool = (char)1; +} + +void vkCmdPushDescriptorSetKHR_CMockStopIgnore(void) +{ + Mock.vkCmdPushDescriptorSetKHR_IgnoreBool = (char)0; +} + +void vkCmdPushDescriptorSetKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdPushDescriptorSetKHR_CALL_INSTANCE)); + CMOCK_vkCmdPushDescriptorSetKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPushDescriptorSetKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdPushDescriptorSetKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdPushDescriptorSetKHR_CallInstance, cmock_guts_index); + Mock.vkCmdPushDescriptorSetKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdPushDescriptorSetKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdPushDescriptorSetKHR_CALL_INSTANCE)); + CMOCK_vkCmdPushDescriptorSetKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPushDescriptorSetKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdPushDescriptorSetKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdPushDescriptorSetKHR_CallInstance, cmock_guts_index); + Mock.vkCmdPushDescriptorSetKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdPushDescriptorSetKHR(cmock_call_instance, commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); +} + +void vkCmdPushDescriptorSetKHR_AddCallback(CMOCK_vkCmdPushDescriptorSetKHR_CALLBACK Callback) +{ + Mock.vkCmdPushDescriptorSetKHR_IgnoreBool = (char)0; + Mock.vkCmdPushDescriptorSetKHR_CallbackBool = (char)1; + Mock.vkCmdPushDescriptorSetKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdPushDescriptorSetKHR_Stub(CMOCK_vkCmdPushDescriptorSetKHR_CALLBACK Callback) +{ + Mock.vkCmdPushDescriptorSetKHR_IgnoreBool = (char)0; + Mock.vkCmdPushDescriptorSetKHR_CallbackBool = (char)0; + Mock.vkCmdPushDescriptorSetKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdPushDescriptorSetKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPushDescriptorSetKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPushDescriptorSetKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPushDescriptorSetKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdPushDescriptorSetKHR_CMockIgnoreArg_pipelineBindPoint(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPushDescriptorSetKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPushDescriptorSetKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPushDescriptorSetKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pipelineBindPoint = 1; +} + +void vkCmdPushDescriptorSetKHR_CMockIgnoreArg_layout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPushDescriptorSetKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPushDescriptorSetKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPushDescriptorSetKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_layout = 1; +} + +void vkCmdPushDescriptorSetKHR_CMockIgnoreArg_set(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPushDescriptorSetKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPushDescriptorSetKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPushDescriptorSetKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_set = 1; +} + +void vkCmdPushDescriptorSetKHR_CMockIgnoreArg_descriptorWriteCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPushDescriptorSetKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPushDescriptorSetKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPushDescriptorSetKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_descriptorWriteCount = 1; +} + +void vkCmdPushDescriptorSetKHR_CMockIgnoreArg_pDescriptorWrites(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPushDescriptorSetKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPushDescriptorSetKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPushDescriptorSetKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDescriptorWrites = 1; +} + +void vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdPushDescriptorSetWithTemplateKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdPushDescriptorSetWithTemplateKHR); + cmock_call_instance = (CMOCK_vkCmdPushDescriptorSetWithTemplateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdPushDescriptorSetWithTemplateKHR_CallInstance); + Mock.vkCmdPushDescriptorSetWithTemplateKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdPushDescriptorSetWithTemplateKHR_CallInstance); + if (Mock.vkCmdPushDescriptorSetWithTemplateKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdPushDescriptorSetWithTemplateKHR_CallbackBool && + Mock.vkCmdPushDescriptorSetWithTemplateKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdPushDescriptorSetWithTemplateKHR_CallbackFunctionPointer(commandBuffer, descriptorUpdateTemplate, layout, set, pData, Mock.vkCmdPushDescriptorSetWithTemplateKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdPushDescriptorSetWithTemplateKHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_descriptorUpdateTemplate) + { + UNITY_SET_DETAILS(CMockString_vkCmdPushDescriptorSetWithTemplateKHR,CMockString_descriptorUpdateTemplate); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_descriptorUpdateTemplate), (void*)(&descriptorUpdateTemplate), sizeof(VkDescriptorUpdateTemplate), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_layout) + { + UNITY_SET_DETAILS(CMockString_vkCmdPushDescriptorSetWithTemplateKHR,CMockString_layout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_layout), (void*)(&layout), sizeof(VkPipelineLayout), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_set) + { + UNITY_SET_DETAILS(CMockString_vkCmdPushDescriptorSetWithTemplateKHR,CMockString_set); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_set, set, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pData) + { + UNITY_SET_DETAILS(CMockString_vkCmdPushDescriptorSetWithTemplateKHR,CMockString_pData); + if (cmock_call_instance->Expected_pData == NULL) + { UNITY_TEST_ASSERT_NULL(pData, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(cmock_call_instance->Expected_pData, pData, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkCmdPushDescriptorSetWithTemplateKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdPushDescriptorSetWithTemplateKHR_CallbackFunctionPointer(commandBuffer, descriptorUpdateTemplate, layout, set, pData, Mock.vkCmdPushDescriptorSetWithTemplateKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdPushDescriptorSetWithTemplateKHR(CMOCK_vkCmdPushDescriptorSetWithTemplateKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData); +void CMockExpectParameters_vkCmdPushDescriptorSetWithTemplateKHR(CMOCK_vkCmdPushDescriptorSetWithTemplateKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_descriptorUpdateTemplate), (void*)(&descriptorUpdateTemplate), + sizeof(VkDescriptorUpdateTemplate[sizeof(descriptorUpdateTemplate) == sizeof(VkDescriptorUpdateTemplate) ? 1 : -1])); /* add VkDescriptorUpdateTemplate to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_descriptorUpdateTemplate = 0; + memcpy((void*)(&cmock_call_instance->Expected_layout), (void*)(&layout), + sizeof(VkPipelineLayout[sizeof(layout) == sizeof(VkPipelineLayout) ? 1 : -1])); /* add VkPipelineLayout to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_layout = 0; + cmock_call_instance->Expected_set = set; + cmock_call_instance->IgnoreArg_set = 0; + cmock_call_instance->Expected_pData = pData; + cmock_call_instance->IgnoreArg_pData = 0; +} + +void vkCmdPushDescriptorSetWithTemplateKHR_CMockIgnore(void) +{ + Mock.vkCmdPushDescriptorSetWithTemplateKHR_IgnoreBool = (char)1; +} + +void vkCmdPushDescriptorSetWithTemplateKHR_CMockStopIgnore(void) +{ + Mock.vkCmdPushDescriptorSetWithTemplateKHR_IgnoreBool = (char)0; +} + +void vkCmdPushDescriptorSetWithTemplateKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdPushDescriptorSetWithTemplateKHR_CALL_INSTANCE)); + CMOCK_vkCmdPushDescriptorSetWithTemplateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPushDescriptorSetWithTemplateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdPushDescriptorSetWithTemplateKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdPushDescriptorSetWithTemplateKHR_CallInstance, cmock_guts_index); + Mock.vkCmdPushDescriptorSetWithTemplateKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdPushDescriptorSetWithTemplateKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdPushDescriptorSetWithTemplateKHR_CALL_INSTANCE)); + CMOCK_vkCmdPushDescriptorSetWithTemplateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPushDescriptorSetWithTemplateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdPushDescriptorSetWithTemplateKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdPushDescriptorSetWithTemplateKHR_CallInstance, cmock_guts_index); + Mock.vkCmdPushDescriptorSetWithTemplateKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdPushDescriptorSetWithTemplateKHR(cmock_call_instance, commandBuffer, descriptorUpdateTemplate, layout, set, pData); +} + +void vkCmdPushDescriptorSetWithTemplateKHR_AddCallback(CMOCK_vkCmdPushDescriptorSetWithTemplateKHR_CALLBACK Callback) +{ + Mock.vkCmdPushDescriptorSetWithTemplateKHR_IgnoreBool = (char)0; + Mock.vkCmdPushDescriptorSetWithTemplateKHR_CallbackBool = (char)1; + Mock.vkCmdPushDescriptorSetWithTemplateKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdPushDescriptorSetWithTemplateKHR_Stub(CMOCK_vkCmdPushDescriptorSetWithTemplateKHR_CALLBACK Callback) +{ + Mock.vkCmdPushDescriptorSetWithTemplateKHR_IgnoreBool = (char)0; + Mock.vkCmdPushDescriptorSetWithTemplateKHR_CallbackBool = (char)0; + Mock.vkCmdPushDescriptorSetWithTemplateKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdPushDescriptorSetWithTemplateKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPushDescriptorSetWithTemplateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPushDescriptorSetWithTemplateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPushDescriptorSetWithTemplateKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdPushDescriptorSetWithTemplateKHR_CMockIgnoreArg_descriptorUpdateTemplate(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPushDescriptorSetWithTemplateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPushDescriptorSetWithTemplateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPushDescriptorSetWithTemplateKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_descriptorUpdateTemplate = 1; +} + +void vkCmdPushDescriptorSetWithTemplateKHR_CMockIgnoreArg_layout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPushDescriptorSetWithTemplateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPushDescriptorSetWithTemplateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPushDescriptorSetWithTemplateKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_layout = 1; +} + +void vkCmdPushDescriptorSetWithTemplateKHR_CMockIgnoreArg_set(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPushDescriptorSetWithTemplateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPushDescriptorSetWithTemplateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPushDescriptorSetWithTemplateKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_set = 1; +} + +void vkCmdPushDescriptorSetWithTemplateKHR_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPushDescriptorSetWithTemplateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPushDescriptorSetWithTemplateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPushDescriptorSetWithTemplateKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pData = 1; +} + +VkResult vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateDescriptorUpdateTemplateKHR); + cmock_call_instance = (CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateDescriptorUpdateTemplateKHR_CallInstance); + Mock.vkCreateDescriptorUpdateTemplateKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCreateDescriptorUpdateTemplateKHR_CallInstance); + if (Mock.vkCreateDescriptorUpdateTemplateKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateDescriptorUpdateTemplateKHR_FinalReturn; + memcpy((void*)(&Mock.vkCreateDescriptorUpdateTemplateKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateDescriptorUpdateTemplateKHR_CallbackBool && + Mock.vkCreateDescriptorUpdateTemplateKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateDescriptorUpdateTemplateKHR_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, Mock.vkCreateDescriptorUpdateTemplateKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateDescriptorUpdateTemplateKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateDescriptorUpdateTemplateKHR,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkDescriptorUpdateTemplateCreateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateDescriptorUpdateTemplateKHR,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDescriptorUpdateTemplate) + { + UNITY_SET_DETAILS(CMockString_vkCreateDescriptorUpdateTemplateKHR,CMockString_pDescriptorUpdateTemplate); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDescriptorUpdateTemplate), (void*)(pDescriptorUpdateTemplate), sizeof(VkDescriptorUpdateTemplate), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateDescriptorUpdateTemplateKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateDescriptorUpdateTemplateKHR_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, Mock.vkCreateDescriptorUpdateTemplateKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pDescriptorUpdateTemplate_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pDescriptorUpdateTemplate, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pDescriptorUpdateTemplate, (const void*)cmock_call_instance->ReturnThruPtr_pDescriptorUpdateTemplate_Val, + cmock_call_instance->ReturnThruPtr_pDescriptorUpdateTemplate_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateDescriptorUpdateTemplateKHR(CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); +void CMockExpectParameters_vkCreateDescriptorUpdateTemplateKHR(CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pDescriptorUpdateTemplate = pDescriptorUpdateTemplate; + cmock_call_instance->IgnoreArg_pDescriptorUpdateTemplate = 0; + cmock_call_instance->ReturnThruPtr_pDescriptorUpdateTemplate_Used = 0; +} + +void vkCreateDescriptorUpdateTemplateKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALL_INSTANCE)); + CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateDescriptorUpdateTemplateKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateDescriptorUpdateTemplateKHR_CallInstance, cmock_guts_index); + Mock.vkCreateDescriptorUpdateTemplateKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateDescriptorUpdateTemplateKHR_IgnoreBool = (char)1; +} + +void vkCreateDescriptorUpdateTemplateKHR_CMockStopIgnore(void) +{ + if(Mock.vkCreateDescriptorUpdateTemplateKHR_IgnoreBool) + Mock.vkCreateDescriptorUpdateTemplateKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCreateDescriptorUpdateTemplateKHR_CallInstance); + Mock.vkCreateDescriptorUpdateTemplateKHR_IgnoreBool = (char)0; +} + +void vkCreateDescriptorUpdateTemplateKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALL_INSTANCE)); + CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateDescriptorUpdateTemplateKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateDescriptorUpdateTemplateKHR_CallInstance, cmock_guts_index); + Mock.vkCreateDescriptorUpdateTemplateKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateDescriptorUpdateTemplateKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALL_INSTANCE)); + CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateDescriptorUpdateTemplateKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateDescriptorUpdateTemplateKHR_CallInstance, cmock_guts_index); + Mock.vkCreateDescriptorUpdateTemplateKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateDescriptorUpdateTemplateKHR(cmock_call_instance, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateDescriptorUpdateTemplateKHR_AddCallback(CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALLBACK Callback) +{ + Mock.vkCreateDescriptorUpdateTemplateKHR_IgnoreBool = (char)0; + Mock.vkCreateDescriptorUpdateTemplateKHR_CallbackBool = (char)1; + Mock.vkCreateDescriptorUpdateTemplateKHR_CallbackFunctionPointer = Callback; +} + +void vkCreateDescriptorUpdateTemplateKHR_Stub(CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALLBACK Callback) +{ + Mock.vkCreateDescriptorUpdateTemplateKHR_IgnoreBool = (char)0; + Mock.vkCreateDescriptorUpdateTemplateKHR_CallbackBool = (char)0; + Mock.vkCreateDescriptorUpdateTemplateKHR_CallbackFunctionPointer = Callback; +} + +void vkCreateDescriptorUpdateTemplateKHR_CMockReturnMemThruPtr_pDescriptorUpdateTemplate(UNITY_LINE_TYPE cmock_line, VkDescriptorUpdateTemplate const* pDescriptorUpdateTemplate, size_t cmock_size) +{ + CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDescriptorUpdateTemplateKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pDescriptorUpdateTemplate_Used = 1; + cmock_call_instance->ReturnThruPtr_pDescriptorUpdateTemplate_Val = pDescriptorUpdateTemplate; + cmock_call_instance->ReturnThruPtr_pDescriptorUpdateTemplate_Size = cmock_size; +} + +void vkCreateDescriptorUpdateTemplateKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDescriptorUpdateTemplateKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateDescriptorUpdateTemplateKHR_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDescriptorUpdateTemplateKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateDescriptorUpdateTemplateKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDescriptorUpdateTemplateKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateDescriptorUpdateTemplateKHR_CMockIgnoreArg_pDescriptorUpdateTemplate(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDescriptorUpdateTemplateKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDescriptorUpdateTemplate = 1; +} + +void vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyDescriptorUpdateTemplateKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyDescriptorUpdateTemplateKHR); + cmock_call_instance = (CMOCK_vkDestroyDescriptorUpdateTemplateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyDescriptorUpdateTemplateKHR_CallInstance); + Mock.vkDestroyDescriptorUpdateTemplateKHR_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyDescriptorUpdateTemplateKHR_CallInstance); + if (Mock.vkDestroyDescriptorUpdateTemplateKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyDescriptorUpdateTemplateKHR_CallbackBool && + Mock.vkDestroyDescriptorUpdateTemplateKHR_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyDescriptorUpdateTemplateKHR_CallbackFunctionPointer(device, descriptorUpdateTemplate, pAllocator, Mock.vkDestroyDescriptorUpdateTemplateKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyDescriptorUpdateTemplateKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_descriptorUpdateTemplate) + { + UNITY_SET_DETAILS(CMockString_vkDestroyDescriptorUpdateTemplateKHR,CMockString_descriptorUpdateTemplate); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_descriptorUpdateTemplate), (void*)(&descriptorUpdateTemplate), sizeof(VkDescriptorUpdateTemplate), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyDescriptorUpdateTemplateKHR,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyDescriptorUpdateTemplateKHR_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyDescriptorUpdateTemplateKHR_CallbackFunctionPointer(device, descriptorUpdateTemplate, pAllocator, Mock.vkDestroyDescriptorUpdateTemplateKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyDescriptorUpdateTemplateKHR(CMOCK_vkDestroyDescriptorUpdateTemplateKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyDescriptorUpdateTemplateKHR(CMOCK_vkDestroyDescriptorUpdateTemplateKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_descriptorUpdateTemplate), (void*)(&descriptorUpdateTemplate), + sizeof(VkDescriptorUpdateTemplate[sizeof(descriptorUpdateTemplate) == sizeof(VkDescriptorUpdateTemplate) ? 1 : -1])); /* add VkDescriptorUpdateTemplate to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_descriptorUpdateTemplate = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyDescriptorUpdateTemplateKHR_CMockIgnore(void) +{ + Mock.vkDestroyDescriptorUpdateTemplateKHR_IgnoreBool = (char)1; +} + +void vkDestroyDescriptorUpdateTemplateKHR_CMockStopIgnore(void) +{ + Mock.vkDestroyDescriptorUpdateTemplateKHR_IgnoreBool = (char)0; +} + +void vkDestroyDescriptorUpdateTemplateKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyDescriptorUpdateTemplateKHR_CALL_INSTANCE)); + CMOCK_vkDestroyDescriptorUpdateTemplateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDescriptorUpdateTemplateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyDescriptorUpdateTemplateKHR_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyDescriptorUpdateTemplateKHR_CallInstance, cmock_guts_index); + Mock.vkDestroyDescriptorUpdateTemplateKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyDescriptorUpdateTemplateKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyDescriptorUpdateTemplateKHR_CALL_INSTANCE)); + CMOCK_vkDestroyDescriptorUpdateTemplateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDescriptorUpdateTemplateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyDescriptorUpdateTemplateKHR_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyDescriptorUpdateTemplateKHR_CallInstance, cmock_guts_index); + Mock.vkDestroyDescriptorUpdateTemplateKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyDescriptorUpdateTemplateKHR(cmock_call_instance, device, descriptorUpdateTemplate, pAllocator); +} + +void vkDestroyDescriptorUpdateTemplateKHR_AddCallback(CMOCK_vkDestroyDescriptorUpdateTemplateKHR_CALLBACK Callback) +{ + Mock.vkDestroyDescriptorUpdateTemplateKHR_IgnoreBool = (char)0; + Mock.vkDestroyDescriptorUpdateTemplateKHR_CallbackBool = (char)1; + Mock.vkDestroyDescriptorUpdateTemplateKHR_CallbackFunctionPointer = Callback; +} + +void vkDestroyDescriptorUpdateTemplateKHR_Stub(CMOCK_vkDestroyDescriptorUpdateTemplateKHR_CALLBACK Callback) +{ + Mock.vkDestroyDescriptorUpdateTemplateKHR_IgnoreBool = (char)0; + Mock.vkDestroyDescriptorUpdateTemplateKHR_CallbackBool = (char)0; + Mock.vkDestroyDescriptorUpdateTemplateKHR_CallbackFunctionPointer = Callback; +} + +void vkDestroyDescriptorUpdateTemplateKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyDescriptorUpdateTemplateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDescriptorUpdateTemplateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyDescriptorUpdateTemplateKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyDescriptorUpdateTemplateKHR_CMockIgnoreArg_descriptorUpdateTemplate(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyDescriptorUpdateTemplateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDescriptorUpdateTemplateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyDescriptorUpdateTemplateKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_descriptorUpdateTemplate = 1; +} + +void vkDestroyDescriptorUpdateTemplateKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyDescriptorUpdateTemplateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDescriptorUpdateTemplateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyDescriptorUpdateTemplateKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkUpdateDescriptorSetWithTemplateKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkUpdateDescriptorSetWithTemplateKHR); + cmock_call_instance = (CMOCK_vkUpdateDescriptorSetWithTemplateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkUpdateDescriptorSetWithTemplateKHR_CallInstance); + Mock.vkUpdateDescriptorSetWithTemplateKHR_CallInstance = CMock_Guts_MemNext(Mock.vkUpdateDescriptorSetWithTemplateKHR_CallInstance); + if (Mock.vkUpdateDescriptorSetWithTemplateKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkUpdateDescriptorSetWithTemplateKHR_CallbackBool && + Mock.vkUpdateDescriptorSetWithTemplateKHR_CallbackFunctionPointer != NULL) + { + Mock.vkUpdateDescriptorSetWithTemplateKHR_CallbackFunctionPointer(device, descriptorSet, descriptorUpdateTemplate, pData, Mock.vkUpdateDescriptorSetWithTemplateKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkUpdateDescriptorSetWithTemplateKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_descriptorSet) + { + UNITY_SET_DETAILS(CMockString_vkUpdateDescriptorSetWithTemplateKHR,CMockString_descriptorSet); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_descriptorSet), (void*)(&descriptorSet), sizeof(VkDescriptorSet), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_descriptorUpdateTemplate) + { + UNITY_SET_DETAILS(CMockString_vkUpdateDescriptorSetWithTemplateKHR,CMockString_descriptorUpdateTemplate); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_descriptorUpdateTemplate), (void*)(&descriptorUpdateTemplate), sizeof(VkDescriptorUpdateTemplate), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pData) + { + UNITY_SET_DETAILS(CMockString_vkUpdateDescriptorSetWithTemplateKHR,CMockString_pData); + if (cmock_call_instance->Expected_pData == NULL) + { UNITY_TEST_ASSERT_NULL(pData, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(cmock_call_instance->Expected_pData, pData, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkUpdateDescriptorSetWithTemplateKHR_CallbackFunctionPointer != NULL) + { + Mock.vkUpdateDescriptorSetWithTemplateKHR_CallbackFunctionPointer(device, descriptorSet, descriptorUpdateTemplate, pData, Mock.vkUpdateDescriptorSetWithTemplateKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkUpdateDescriptorSetWithTemplateKHR(CMOCK_vkUpdateDescriptorSetWithTemplateKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); +void CMockExpectParameters_vkUpdateDescriptorSetWithTemplateKHR(CMOCK_vkUpdateDescriptorSetWithTemplateKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_descriptorSet), (void*)(&descriptorSet), + sizeof(VkDescriptorSet[sizeof(descriptorSet) == sizeof(VkDescriptorSet) ? 1 : -1])); /* add VkDescriptorSet to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_descriptorSet = 0; + memcpy((void*)(&cmock_call_instance->Expected_descriptorUpdateTemplate), (void*)(&descriptorUpdateTemplate), + sizeof(VkDescriptorUpdateTemplate[sizeof(descriptorUpdateTemplate) == sizeof(VkDescriptorUpdateTemplate) ? 1 : -1])); /* add VkDescriptorUpdateTemplate to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_descriptorUpdateTemplate = 0; + cmock_call_instance->Expected_pData = pData; + cmock_call_instance->IgnoreArg_pData = 0; +} + +void vkUpdateDescriptorSetWithTemplateKHR_CMockIgnore(void) +{ + Mock.vkUpdateDescriptorSetWithTemplateKHR_IgnoreBool = (char)1; +} + +void vkUpdateDescriptorSetWithTemplateKHR_CMockStopIgnore(void) +{ + Mock.vkUpdateDescriptorSetWithTemplateKHR_IgnoreBool = (char)0; +} + +void vkUpdateDescriptorSetWithTemplateKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkUpdateDescriptorSetWithTemplateKHR_CALL_INSTANCE)); + CMOCK_vkUpdateDescriptorSetWithTemplateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUpdateDescriptorSetWithTemplateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkUpdateDescriptorSetWithTemplateKHR_CallInstance = CMock_Guts_MemChain(Mock.vkUpdateDescriptorSetWithTemplateKHR_CallInstance, cmock_guts_index); + Mock.vkUpdateDescriptorSetWithTemplateKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkUpdateDescriptorSetWithTemplateKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkUpdateDescriptorSetWithTemplateKHR_CALL_INSTANCE)); + CMOCK_vkUpdateDescriptorSetWithTemplateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUpdateDescriptorSetWithTemplateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkUpdateDescriptorSetWithTemplateKHR_CallInstance = CMock_Guts_MemChain(Mock.vkUpdateDescriptorSetWithTemplateKHR_CallInstance, cmock_guts_index); + Mock.vkUpdateDescriptorSetWithTemplateKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkUpdateDescriptorSetWithTemplateKHR(cmock_call_instance, device, descriptorSet, descriptorUpdateTemplate, pData); +} + +void vkUpdateDescriptorSetWithTemplateKHR_AddCallback(CMOCK_vkUpdateDescriptorSetWithTemplateKHR_CALLBACK Callback) +{ + Mock.vkUpdateDescriptorSetWithTemplateKHR_IgnoreBool = (char)0; + Mock.vkUpdateDescriptorSetWithTemplateKHR_CallbackBool = (char)1; + Mock.vkUpdateDescriptorSetWithTemplateKHR_CallbackFunctionPointer = Callback; +} + +void vkUpdateDescriptorSetWithTemplateKHR_Stub(CMOCK_vkUpdateDescriptorSetWithTemplateKHR_CALLBACK Callback) +{ + Mock.vkUpdateDescriptorSetWithTemplateKHR_IgnoreBool = (char)0; + Mock.vkUpdateDescriptorSetWithTemplateKHR_CallbackBool = (char)0; + Mock.vkUpdateDescriptorSetWithTemplateKHR_CallbackFunctionPointer = Callback; +} + +void vkUpdateDescriptorSetWithTemplateKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkUpdateDescriptorSetWithTemplateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUpdateDescriptorSetWithTemplateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkUpdateDescriptorSetWithTemplateKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkUpdateDescriptorSetWithTemplateKHR_CMockIgnoreArg_descriptorSet(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkUpdateDescriptorSetWithTemplateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUpdateDescriptorSetWithTemplateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkUpdateDescriptorSetWithTemplateKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_descriptorSet = 1; +} + +void vkUpdateDescriptorSetWithTemplateKHR_CMockIgnoreArg_descriptorUpdateTemplate(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkUpdateDescriptorSetWithTemplateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUpdateDescriptorSetWithTemplateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkUpdateDescriptorSetWithTemplateKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_descriptorUpdateTemplate = 1; +} + +void vkUpdateDescriptorSetWithTemplateKHR_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkUpdateDescriptorSetWithTemplateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUpdateDescriptorSetWithTemplateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkUpdateDescriptorSetWithTemplateKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pData = 1; +} + +VkResult vkCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateRenderPass2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateRenderPass2KHR); + cmock_call_instance = (CMOCK_vkCreateRenderPass2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateRenderPass2KHR_CallInstance); + Mock.vkCreateRenderPass2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkCreateRenderPass2KHR_CallInstance); + if (Mock.vkCreateRenderPass2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateRenderPass2KHR_FinalReturn; + memcpy((void*)(&Mock.vkCreateRenderPass2KHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateRenderPass2KHR_CallbackBool && + Mock.vkCreateRenderPass2KHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateRenderPass2KHR_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pRenderPass, Mock.vkCreateRenderPass2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateRenderPass2KHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateRenderPass2KHR,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkRenderPassCreateInfo2), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateRenderPass2KHR,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pRenderPass) + { + UNITY_SET_DETAILS(CMockString_vkCreateRenderPass2KHR,CMockString_pRenderPass); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pRenderPass), (void*)(pRenderPass), sizeof(VkRenderPass), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateRenderPass2KHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateRenderPass2KHR_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pRenderPass, Mock.vkCreateRenderPass2KHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pRenderPass_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pRenderPass, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pRenderPass, (const void*)cmock_call_instance->ReturnThruPtr_pRenderPass_Val, + cmock_call_instance->ReturnThruPtr_pRenderPass_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateRenderPass2KHR(CMOCK_vkCreateRenderPass2KHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); +void CMockExpectParameters_vkCreateRenderPass2KHR(CMOCK_vkCreateRenderPass2KHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pRenderPass = pRenderPass; + cmock_call_instance->IgnoreArg_pRenderPass = 0; + cmock_call_instance->ReturnThruPtr_pRenderPass_Used = 0; +} + +void vkCreateRenderPass2KHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateRenderPass2KHR_CALL_INSTANCE)); + CMOCK_vkCreateRenderPass2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRenderPass2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateRenderPass2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateRenderPass2KHR_CallInstance, cmock_guts_index); + Mock.vkCreateRenderPass2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateRenderPass2KHR_IgnoreBool = (char)1; +} + +void vkCreateRenderPass2KHR_CMockStopIgnore(void) +{ + if(Mock.vkCreateRenderPass2KHR_IgnoreBool) + Mock.vkCreateRenderPass2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkCreateRenderPass2KHR_CallInstance); + Mock.vkCreateRenderPass2KHR_IgnoreBool = (char)0; +} + +void vkCreateRenderPass2KHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateRenderPass2KHR_CALL_INSTANCE)); + CMOCK_vkCreateRenderPass2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRenderPass2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateRenderPass2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateRenderPass2KHR_CallInstance, cmock_guts_index); + Mock.vkCreateRenderPass2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateRenderPass2KHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateRenderPass2KHR_CALL_INSTANCE)); + CMOCK_vkCreateRenderPass2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRenderPass2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateRenderPass2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateRenderPass2KHR_CallInstance, cmock_guts_index); + Mock.vkCreateRenderPass2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateRenderPass2KHR(cmock_call_instance, device, pCreateInfo, pAllocator, pRenderPass); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateRenderPass2KHR_AddCallback(CMOCK_vkCreateRenderPass2KHR_CALLBACK Callback) +{ + Mock.vkCreateRenderPass2KHR_IgnoreBool = (char)0; + Mock.vkCreateRenderPass2KHR_CallbackBool = (char)1; + Mock.vkCreateRenderPass2KHR_CallbackFunctionPointer = Callback; +} + +void vkCreateRenderPass2KHR_Stub(CMOCK_vkCreateRenderPass2KHR_CALLBACK Callback) +{ + Mock.vkCreateRenderPass2KHR_IgnoreBool = (char)0; + Mock.vkCreateRenderPass2KHR_CallbackBool = (char)0; + Mock.vkCreateRenderPass2KHR_CallbackFunctionPointer = Callback; +} + +void vkCreateRenderPass2KHR_CMockReturnMemThruPtr_pRenderPass(UNITY_LINE_TYPE cmock_line, VkRenderPass const* pRenderPass, size_t cmock_size) +{ + CMOCK_vkCreateRenderPass2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRenderPass2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateRenderPass2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pRenderPass_Used = 1; + cmock_call_instance->ReturnThruPtr_pRenderPass_Val = pRenderPass; + cmock_call_instance->ReturnThruPtr_pRenderPass_Size = cmock_size; +} + +void vkCreateRenderPass2KHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateRenderPass2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRenderPass2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateRenderPass2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateRenderPass2KHR_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateRenderPass2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRenderPass2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateRenderPass2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateRenderPass2KHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateRenderPass2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRenderPass2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateRenderPass2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateRenderPass2KHR_CMockIgnoreArg_pRenderPass(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateRenderPass2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRenderPass2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateRenderPass2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pRenderPass = 1; +} + +void vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBeginRenderPass2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBeginRenderPass2KHR); + cmock_call_instance = (CMOCK_vkCmdBeginRenderPass2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBeginRenderPass2KHR_CallInstance); + Mock.vkCmdBeginRenderPass2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBeginRenderPass2KHR_CallInstance); + if (Mock.vkCmdBeginRenderPass2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBeginRenderPass2KHR_CallbackBool && + Mock.vkCmdBeginRenderPass2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBeginRenderPass2KHR_CallbackFunctionPointer(commandBuffer, pRenderPassBegin, pSubpassBeginInfo, Mock.vkCmdBeginRenderPass2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginRenderPass2KHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pRenderPassBegin) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginRenderPass2KHR,CMockString_pRenderPassBegin); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pRenderPassBegin), (void*)(pRenderPassBegin), sizeof(const VkRenderPassBeginInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSubpassBeginInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginRenderPass2KHR,CMockString_pSubpassBeginInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSubpassBeginInfo), (void*)(pSubpassBeginInfo), sizeof(const VkSubpassBeginInfo), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdBeginRenderPass2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBeginRenderPass2KHR_CallbackFunctionPointer(commandBuffer, pRenderPassBegin, pSubpassBeginInfo, Mock.vkCmdBeginRenderPass2KHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBeginRenderPass2KHR(CMOCK_vkCmdBeginRenderPass2KHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo); +void CMockExpectParameters_vkCmdBeginRenderPass2KHR(CMOCK_vkCmdBeginRenderPass2KHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pRenderPassBegin = pRenderPassBegin; + cmock_call_instance->IgnoreArg_pRenderPassBegin = 0; + cmock_call_instance->Expected_pSubpassBeginInfo = pSubpassBeginInfo; + cmock_call_instance->IgnoreArg_pSubpassBeginInfo = 0; +} + +void vkCmdBeginRenderPass2KHR_CMockIgnore(void) +{ + Mock.vkCmdBeginRenderPass2KHR_IgnoreBool = (char)1; +} + +void vkCmdBeginRenderPass2KHR_CMockStopIgnore(void) +{ + Mock.vkCmdBeginRenderPass2KHR_IgnoreBool = (char)0; +} + +void vkCmdBeginRenderPass2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBeginRenderPass2KHR_CALL_INSTANCE)); + CMOCK_vkCmdBeginRenderPass2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginRenderPass2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBeginRenderPass2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBeginRenderPass2KHR_CallInstance, cmock_guts_index); + Mock.vkCmdBeginRenderPass2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBeginRenderPass2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBeginRenderPass2KHR_CALL_INSTANCE)); + CMOCK_vkCmdBeginRenderPass2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginRenderPass2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBeginRenderPass2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBeginRenderPass2KHR_CallInstance, cmock_guts_index); + Mock.vkCmdBeginRenderPass2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBeginRenderPass2KHR(cmock_call_instance, commandBuffer, pRenderPassBegin, pSubpassBeginInfo); +} + +void vkCmdBeginRenderPass2KHR_AddCallback(CMOCK_vkCmdBeginRenderPass2KHR_CALLBACK Callback) +{ + Mock.vkCmdBeginRenderPass2KHR_IgnoreBool = (char)0; + Mock.vkCmdBeginRenderPass2KHR_CallbackBool = (char)1; + Mock.vkCmdBeginRenderPass2KHR_CallbackFunctionPointer = Callback; +} + +void vkCmdBeginRenderPass2KHR_Stub(CMOCK_vkCmdBeginRenderPass2KHR_CALLBACK Callback) +{ + Mock.vkCmdBeginRenderPass2KHR_IgnoreBool = (char)0; + Mock.vkCmdBeginRenderPass2KHR_CallbackBool = (char)0; + Mock.vkCmdBeginRenderPass2KHR_CallbackFunctionPointer = Callback; +} + +void vkCmdBeginRenderPass2KHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginRenderPass2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginRenderPass2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginRenderPass2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBeginRenderPass2KHR_CMockIgnoreArg_pRenderPassBegin(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginRenderPass2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginRenderPass2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginRenderPass2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pRenderPassBegin = 1; +} + +void vkCmdBeginRenderPass2KHR_CMockIgnoreArg_pSubpassBeginInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginRenderPass2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginRenderPass2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginRenderPass2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSubpassBeginInfo = 1; +} + +void vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdNextSubpass2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdNextSubpass2KHR); + cmock_call_instance = (CMOCK_vkCmdNextSubpass2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdNextSubpass2KHR_CallInstance); + Mock.vkCmdNextSubpass2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdNextSubpass2KHR_CallInstance); + if (Mock.vkCmdNextSubpass2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdNextSubpass2KHR_CallbackBool && + Mock.vkCmdNextSubpass2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdNextSubpass2KHR_CallbackFunctionPointer(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo, Mock.vkCmdNextSubpass2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdNextSubpass2KHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSubpassBeginInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdNextSubpass2KHR,CMockString_pSubpassBeginInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSubpassBeginInfo), (void*)(pSubpassBeginInfo), sizeof(const VkSubpassBeginInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSubpassEndInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdNextSubpass2KHR,CMockString_pSubpassEndInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSubpassEndInfo), (void*)(pSubpassEndInfo), sizeof(const VkSubpassEndInfo), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdNextSubpass2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdNextSubpass2KHR_CallbackFunctionPointer(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo, Mock.vkCmdNextSubpass2KHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdNextSubpass2KHR(CMOCK_vkCmdNextSubpass2KHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo); +void CMockExpectParameters_vkCmdNextSubpass2KHR(CMOCK_vkCmdNextSubpass2KHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pSubpassBeginInfo = pSubpassBeginInfo; + cmock_call_instance->IgnoreArg_pSubpassBeginInfo = 0; + cmock_call_instance->Expected_pSubpassEndInfo = pSubpassEndInfo; + cmock_call_instance->IgnoreArg_pSubpassEndInfo = 0; +} + +void vkCmdNextSubpass2KHR_CMockIgnore(void) +{ + Mock.vkCmdNextSubpass2KHR_IgnoreBool = (char)1; +} + +void vkCmdNextSubpass2KHR_CMockStopIgnore(void) +{ + Mock.vkCmdNextSubpass2KHR_IgnoreBool = (char)0; +} + +void vkCmdNextSubpass2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdNextSubpass2KHR_CALL_INSTANCE)); + CMOCK_vkCmdNextSubpass2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdNextSubpass2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdNextSubpass2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdNextSubpass2KHR_CallInstance, cmock_guts_index); + Mock.vkCmdNextSubpass2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdNextSubpass2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdNextSubpass2KHR_CALL_INSTANCE)); + CMOCK_vkCmdNextSubpass2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdNextSubpass2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdNextSubpass2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdNextSubpass2KHR_CallInstance, cmock_guts_index); + Mock.vkCmdNextSubpass2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdNextSubpass2KHR(cmock_call_instance, commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); +} + +void vkCmdNextSubpass2KHR_AddCallback(CMOCK_vkCmdNextSubpass2KHR_CALLBACK Callback) +{ + Mock.vkCmdNextSubpass2KHR_IgnoreBool = (char)0; + Mock.vkCmdNextSubpass2KHR_CallbackBool = (char)1; + Mock.vkCmdNextSubpass2KHR_CallbackFunctionPointer = Callback; +} + +void vkCmdNextSubpass2KHR_Stub(CMOCK_vkCmdNextSubpass2KHR_CALLBACK Callback) +{ + Mock.vkCmdNextSubpass2KHR_IgnoreBool = (char)0; + Mock.vkCmdNextSubpass2KHR_CallbackBool = (char)0; + Mock.vkCmdNextSubpass2KHR_CallbackFunctionPointer = Callback; +} + +void vkCmdNextSubpass2KHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdNextSubpass2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdNextSubpass2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdNextSubpass2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdNextSubpass2KHR_CMockIgnoreArg_pSubpassBeginInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdNextSubpass2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdNextSubpass2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdNextSubpass2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSubpassBeginInfo = 1; +} + +void vkCmdNextSubpass2KHR_CMockIgnoreArg_pSubpassEndInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdNextSubpass2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdNextSubpass2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdNextSubpass2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSubpassEndInfo = 1; +} + +void vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdEndRenderPass2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdEndRenderPass2KHR); + cmock_call_instance = (CMOCK_vkCmdEndRenderPass2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdEndRenderPass2KHR_CallInstance); + Mock.vkCmdEndRenderPass2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdEndRenderPass2KHR_CallInstance); + if (Mock.vkCmdEndRenderPass2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdEndRenderPass2KHR_CallbackBool && + Mock.vkCmdEndRenderPass2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdEndRenderPass2KHR_CallbackFunctionPointer(commandBuffer, pSubpassEndInfo, Mock.vkCmdEndRenderPass2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdEndRenderPass2KHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSubpassEndInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdEndRenderPass2KHR,CMockString_pSubpassEndInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSubpassEndInfo), (void*)(pSubpassEndInfo), sizeof(const VkSubpassEndInfo), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdEndRenderPass2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdEndRenderPass2KHR_CallbackFunctionPointer(commandBuffer, pSubpassEndInfo, Mock.vkCmdEndRenderPass2KHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdEndRenderPass2KHR(CMOCK_vkCmdEndRenderPass2KHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo); +void CMockExpectParameters_vkCmdEndRenderPass2KHR(CMOCK_vkCmdEndRenderPass2KHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pSubpassEndInfo = pSubpassEndInfo; + cmock_call_instance->IgnoreArg_pSubpassEndInfo = 0; +} + +void vkCmdEndRenderPass2KHR_CMockIgnore(void) +{ + Mock.vkCmdEndRenderPass2KHR_IgnoreBool = (char)1; +} + +void vkCmdEndRenderPass2KHR_CMockStopIgnore(void) +{ + Mock.vkCmdEndRenderPass2KHR_IgnoreBool = (char)0; +} + +void vkCmdEndRenderPass2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdEndRenderPass2KHR_CALL_INSTANCE)); + CMOCK_vkCmdEndRenderPass2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndRenderPass2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdEndRenderPass2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdEndRenderPass2KHR_CallInstance, cmock_guts_index); + Mock.vkCmdEndRenderPass2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdEndRenderPass2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdEndRenderPass2KHR_CALL_INSTANCE)); + CMOCK_vkCmdEndRenderPass2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndRenderPass2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdEndRenderPass2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdEndRenderPass2KHR_CallInstance, cmock_guts_index); + Mock.vkCmdEndRenderPass2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdEndRenderPass2KHR(cmock_call_instance, commandBuffer, pSubpassEndInfo); +} + +void vkCmdEndRenderPass2KHR_AddCallback(CMOCK_vkCmdEndRenderPass2KHR_CALLBACK Callback) +{ + Mock.vkCmdEndRenderPass2KHR_IgnoreBool = (char)0; + Mock.vkCmdEndRenderPass2KHR_CallbackBool = (char)1; + Mock.vkCmdEndRenderPass2KHR_CallbackFunctionPointer = Callback; +} + +void vkCmdEndRenderPass2KHR_Stub(CMOCK_vkCmdEndRenderPass2KHR_CALLBACK Callback) +{ + Mock.vkCmdEndRenderPass2KHR_IgnoreBool = (char)0; + Mock.vkCmdEndRenderPass2KHR_CallbackBool = (char)0; + Mock.vkCmdEndRenderPass2KHR_CallbackFunctionPointer = Callback; +} + +void vkCmdEndRenderPass2KHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdEndRenderPass2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndRenderPass2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdEndRenderPass2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdEndRenderPass2KHR_CMockIgnoreArg_pSubpassEndInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdEndRenderPass2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndRenderPass2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdEndRenderPass2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSubpassEndInfo = 1; +} + +VkResult vkGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetSwapchainStatusKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetSwapchainStatusKHR); + cmock_call_instance = (CMOCK_vkGetSwapchainStatusKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetSwapchainStatusKHR_CallInstance); + Mock.vkGetSwapchainStatusKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetSwapchainStatusKHR_CallInstance); + if (Mock.vkGetSwapchainStatusKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetSwapchainStatusKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetSwapchainStatusKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetSwapchainStatusKHR_CallbackBool && + Mock.vkGetSwapchainStatusKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetSwapchainStatusKHR_CallbackFunctionPointer(device, swapchain, Mock.vkGetSwapchainStatusKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetSwapchainStatusKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_swapchain) + { + UNITY_SET_DETAILS(CMockString_vkGetSwapchainStatusKHR,CMockString_swapchain); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_swapchain), (void*)(&swapchain), sizeof(VkSwapchainKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetSwapchainStatusKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetSwapchainStatusKHR_CallbackFunctionPointer(device, swapchain, Mock.vkGetSwapchainStatusKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetSwapchainStatusKHR(CMOCK_vkGetSwapchainStatusKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSwapchainKHR swapchain); +void CMockExpectParameters_vkGetSwapchainStatusKHR(CMOCK_vkGetSwapchainStatusKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSwapchainKHR swapchain) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_swapchain), (void*)(&swapchain), + sizeof(VkSwapchainKHR[sizeof(swapchain) == sizeof(VkSwapchainKHR) ? 1 : -1])); /* add VkSwapchainKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_swapchain = 0; +} + +void vkGetSwapchainStatusKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetSwapchainStatusKHR_CALL_INSTANCE)); + CMOCK_vkGetSwapchainStatusKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSwapchainStatusKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetSwapchainStatusKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetSwapchainStatusKHR_CallInstance, cmock_guts_index); + Mock.vkGetSwapchainStatusKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetSwapchainStatusKHR_IgnoreBool = (char)1; +} + +void vkGetSwapchainStatusKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetSwapchainStatusKHR_IgnoreBool) + Mock.vkGetSwapchainStatusKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetSwapchainStatusKHR_CallInstance); + Mock.vkGetSwapchainStatusKHR_IgnoreBool = (char)0; +} + +void vkGetSwapchainStatusKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetSwapchainStatusKHR_CALL_INSTANCE)); + CMOCK_vkGetSwapchainStatusKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSwapchainStatusKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetSwapchainStatusKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetSwapchainStatusKHR_CallInstance, cmock_guts_index); + Mock.vkGetSwapchainStatusKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetSwapchainStatusKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSwapchainKHR swapchain, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetSwapchainStatusKHR_CALL_INSTANCE)); + CMOCK_vkGetSwapchainStatusKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSwapchainStatusKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetSwapchainStatusKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetSwapchainStatusKHR_CallInstance, cmock_guts_index); + Mock.vkGetSwapchainStatusKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetSwapchainStatusKHR(cmock_call_instance, device, swapchain); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetSwapchainStatusKHR_AddCallback(CMOCK_vkGetSwapchainStatusKHR_CALLBACK Callback) +{ + Mock.vkGetSwapchainStatusKHR_IgnoreBool = (char)0; + Mock.vkGetSwapchainStatusKHR_CallbackBool = (char)1; + Mock.vkGetSwapchainStatusKHR_CallbackFunctionPointer = Callback; +} + +void vkGetSwapchainStatusKHR_Stub(CMOCK_vkGetSwapchainStatusKHR_CALLBACK Callback) +{ + Mock.vkGetSwapchainStatusKHR_IgnoreBool = (char)0; + Mock.vkGetSwapchainStatusKHR_CallbackBool = (char)0; + Mock.vkGetSwapchainStatusKHR_CallbackFunctionPointer = Callback; +} + +void vkGetSwapchainStatusKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetSwapchainStatusKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSwapchainStatusKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetSwapchainStatusKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetSwapchainStatusKHR_CMockIgnoreArg_swapchain(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetSwapchainStatusKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSwapchainStatusKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetSwapchainStatusKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_swapchain = 1; +} + +void vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceExternalFencePropertiesKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceExternalFencePropertiesKHR); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalFencePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_CallInstance); + Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_CallInstance); + if (Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_CallbackBool && + Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_CallbackFunctionPointer(physicalDevice, pExternalFenceInfo, pExternalFenceProperties, Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceExternalFencePropertiesKHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pExternalFenceInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceExternalFencePropertiesKHR,CMockString_pExternalFenceInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pExternalFenceInfo), (void*)(pExternalFenceInfo), sizeof(const VkPhysicalDeviceExternalFenceInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pExternalFenceProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceExternalFencePropertiesKHR,CMockString_pExternalFenceProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pExternalFenceProperties), (void*)(pExternalFenceProperties), sizeof(VkExternalFenceProperties), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_CallbackFunctionPointer(physicalDevice, pExternalFenceInfo, pExternalFenceProperties, Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pExternalFenceProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pExternalFenceProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pExternalFenceProperties, (const void*)cmock_call_instance->ReturnThruPtr_pExternalFenceProperties_Val, + cmock_call_instance->ReturnThruPtr_pExternalFenceProperties_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetPhysicalDeviceExternalFencePropertiesKHR(CMOCK_vkGetPhysicalDeviceExternalFencePropertiesKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); +void CMockExpectParameters_vkGetPhysicalDeviceExternalFencePropertiesKHR(CMOCK_vkGetPhysicalDeviceExternalFencePropertiesKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pExternalFenceInfo = pExternalFenceInfo; + cmock_call_instance->IgnoreArg_pExternalFenceInfo = 0; + cmock_call_instance->Expected_pExternalFenceProperties = pExternalFenceProperties; + cmock_call_instance->IgnoreArg_pExternalFenceProperties = 0; + cmock_call_instance->ReturnThruPtr_pExternalFenceProperties_Used = 0; +} + +void vkGetPhysicalDeviceExternalFencePropertiesKHR_CMockIgnore(void) +{ + Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceExternalFencePropertiesKHR_CMockStopIgnore(void) +{ + Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceExternalFencePropertiesKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceExternalFencePropertiesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceExternalFencePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalFencePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceExternalFencePropertiesKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceExternalFencePropertiesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceExternalFencePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalFencePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceExternalFencePropertiesKHR(cmock_call_instance, physicalDevice, pExternalFenceInfo, pExternalFenceProperties); +} + +void vkGetPhysicalDeviceExternalFencePropertiesKHR_AddCallback(CMOCK_vkGetPhysicalDeviceExternalFencePropertiesKHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceExternalFencePropertiesKHR_Stub(CMOCK_vkGetPhysicalDeviceExternalFencePropertiesKHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceExternalFencePropertiesKHR_CMockReturnMemThruPtr_pExternalFenceProperties(UNITY_LINE_TYPE cmock_line, VkExternalFenceProperties const* pExternalFenceProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceExternalFencePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalFencePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pExternalFenceProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pExternalFenceProperties_Val = pExternalFenceProperties; + cmock_call_instance->ReturnThruPtr_pExternalFenceProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceExternalFencePropertiesKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceExternalFencePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalFencePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceExternalFencePropertiesKHR_CMockIgnoreArg_pExternalFenceInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceExternalFencePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalFencePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pExternalFenceInfo = 1; +} + +void vkGetPhysicalDeviceExternalFencePropertiesKHR_CMockIgnoreArg_pExternalFenceProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceExternalFencePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalFencePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalFencePropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pExternalFenceProperties = 1; +} + +VkResult vkImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkImportFenceFdKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkImportFenceFdKHR); + cmock_call_instance = (CMOCK_vkImportFenceFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkImportFenceFdKHR_CallInstance); + Mock.vkImportFenceFdKHR_CallInstance = CMock_Guts_MemNext(Mock.vkImportFenceFdKHR_CallInstance); + if (Mock.vkImportFenceFdKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkImportFenceFdKHR_FinalReturn; + memcpy((void*)(&Mock.vkImportFenceFdKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkImportFenceFdKHR_CallbackBool && + Mock.vkImportFenceFdKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkImportFenceFdKHR_CallbackFunctionPointer(device, pImportFenceFdInfo, Mock.vkImportFenceFdKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkImportFenceFdKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pImportFenceFdInfo) + { + UNITY_SET_DETAILS(CMockString_vkImportFenceFdKHR,CMockString_pImportFenceFdInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pImportFenceFdInfo), (void*)(pImportFenceFdInfo), sizeof(const VkImportFenceFdInfoKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkImportFenceFdKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkImportFenceFdKHR_CallbackFunctionPointer(device, pImportFenceFdInfo, Mock.vkImportFenceFdKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkImportFenceFdKHR(CMOCK_vkImportFenceFdKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo); +void CMockExpectParameters_vkImportFenceFdKHR(CMOCK_vkImportFenceFdKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pImportFenceFdInfo = pImportFenceFdInfo; + cmock_call_instance->IgnoreArg_pImportFenceFdInfo = 0; +} + +void vkImportFenceFdKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkImportFenceFdKHR_CALL_INSTANCE)); + CMOCK_vkImportFenceFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkImportFenceFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkImportFenceFdKHR_CallInstance = CMock_Guts_MemChain(Mock.vkImportFenceFdKHR_CallInstance, cmock_guts_index); + Mock.vkImportFenceFdKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkImportFenceFdKHR_IgnoreBool = (char)1; +} + +void vkImportFenceFdKHR_CMockStopIgnore(void) +{ + if(Mock.vkImportFenceFdKHR_IgnoreBool) + Mock.vkImportFenceFdKHR_CallInstance = CMock_Guts_MemNext(Mock.vkImportFenceFdKHR_CallInstance); + Mock.vkImportFenceFdKHR_IgnoreBool = (char)0; +} + +void vkImportFenceFdKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkImportFenceFdKHR_CALL_INSTANCE)); + CMOCK_vkImportFenceFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkImportFenceFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkImportFenceFdKHR_CallInstance = CMock_Guts_MemChain(Mock.vkImportFenceFdKHR_CallInstance, cmock_guts_index); + Mock.vkImportFenceFdKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkImportFenceFdKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkImportFenceFdKHR_CALL_INSTANCE)); + CMOCK_vkImportFenceFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkImportFenceFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkImportFenceFdKHR_CallInstance = CMock_Guts_MemChain(Mock.vkImportFenceFdKHR_CallInstance, cmock_guts_index); + Mock.vkImportFenceFdKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkImportFenceFdKHR(cmock_call_instance, device, pImportFenceFdInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkImportFenceFdKHR_AddCallback(CMOCK_vkImportFenceFdKHR_CALLBACK Callback) +{ + Mock.vkImportFenceFdKHR_IgnoreBool = (char)0; + Mock.vkImportFenceFdKHR_CallbackBool = (char)1; + Mock.vkImportFenceFdKHR_CallbackFunctionPointer = Callback; +} + +void vkImportFenceFdKHR_Stub(CMOCK_vkImportFenceFdKHR_CALLBACK Callback) +{ + Mock.vkImportFenceFdKHR_IgnoreBool = (char)0; + Mock.vkImportFenceFdKHR_CallbackBool = (char)0; + Mock.vkImportFenceFdKHR_CallbackFunctionPointer = Callback; +} + +void vkImportFenceFdKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkImportFenceFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkImportFenceFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkImportFenceFdKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkImportFenceFdKHR_CMockIgnoreArg_pImportFenceFdInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkImportFenceFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkImportFenceFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkImportFenceFdKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pImportFenceFdInfo = 1; +} + +VkResult vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetFenceFdKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetFenceFdKHR); + cmock_call_instance = (CMOCK_vkGetFenceFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetFenceFdKHR_CallInstance); + Mock.vkGetFenceFdKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetFenceFdKHR_CallInstance); + if (Mock.vkGetFenceFdKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetFenceFdKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetFenceFdKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetFenceFdKHR_CallbackBool && + Mock.vkGetFenceFdKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetFenceFdKHR_CallbackFunctionPointer(device, pGetFdInfo, pFd, Mock.vkGetFenceFdKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetFenceFdKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pGetFdInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetFenceFdKHR,CMockString_pGetFdInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pGetFdInfo), (void*)(pGetFdInfo), sizeof(const VkFenceGetFdInfoKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pFd) + { + UNITY_SET_DETAILS(CMockString_vkGetFenceFdKHR,CMockString_pFd); + if (cmock_call_instance->Expected_pFd == NULL) + { UNITY_TEST_ASSERT_NULL(pFd, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_INT_ARRAY(cmock_call_instance->Expected_pFd, pFd, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkGetFenceFdKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetFenceFdKHR_CallbackFunctionPointer(device, pGetFdInfo, pFd, Mock.vkGetFenceFdKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pFd_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pFd, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pFd, (const void*)cmock_call_instance->ReturnThruPtr_pFd_Val, + cmock_call_instance->ReturnThruPtr_pFd_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetFenceFdKHR(CMOCK_vkGetFenceFdKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd); +void CMockExpectParameters_vkGetFenceFdKHR(CMOCK_vkGetFenceFdKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pGetFdInfo = pGetFdInfo; + cmock_call_instance->IgnoreArg_pGetFdInfo = 0; + cmock_call_instance->Expected_pFd = pFd; + cmock_call_instance->IgnoreArg_pFd = 0; + cmock_call_instance->ReturnThruPtr_pFd_Used = 0; +} + +void vkGetFenceFdKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetFenceFdKHR_CALL_INSTANCE)); + CMOCK_vkGetFenceFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetFenceFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetFenceFdKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetFenceFdKHR_CallInstance, cmock_guts_index); + Mock.vkGetFenceFdKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetFenceFdKHR_IgnoreBool = (char)1; +} + +void vkGetFenceFdKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetFenceFdKHR_IgnoreBool) + Mock.vkGetFenceFdKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetFenceFdKHR_CallInstance); + Mock.vkGetFenceFdKHR_IgnoreBool = (char)0; +} + +void vkGetFenceFdKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetFenceFdKHR_CALL_INSTANCE)); + CMOCK_vkGetFenceFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetFenceFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetFenceFdKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetFenceFdKHR_CallInstance, cmock_guts_index); + Mock.vkGetFenceFdKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetFenceFdKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetFenceFdKHR_CALL_INSTANCE)); + CMOCK_vkGetFenceFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetFenceFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetFenceFdKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetFenceFdKHR_CallInstance, cmock_guts_index); + Mock.vkGetFenceFdKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetFenceFdKHR(cmock_call_instance, device, pGetFdInfo, pFd); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetFenceFdKHR_AddCallback(CMOCK_vkGetFenceFdKHR_CALLBACK Callback) +{ + Mock.vkGetFenceFdKHR_IgnoreBool = (char)0; + Mock.vkGetFenceFdKHR_CallbackBool = (char)1; + Mock.vkGetFenceFdKHR_CallbackFunctionPointer = Callback; +} + +void vkGetFenceFdKHR_Stub(CMOCK_vkGetFenceFdKHR_CALLBACK Callback) +{ + Mock.vkGetFenceFdKHR_IgnoreBool = (char)0; + Mock.vkGetFenceFdKHR_CallbackBool = (char)0; + Mock.vkGetFenceFdKHR_CallbackFunctionPointer = Callback; +} + +void vkGetFenceFdKHR_CMockReturnMemThruPtr_pFd(UNITY_LINE_TYPE cmock_line, int const* pFd, size_t cmock_size) +{ + CMOCK_vkGetFenceFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetFenceFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetFenceFdKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pFd_Used = 1; + cmock_call_instance->ReturnThruPtr_pFd_Val = pFd; + cmock_call_instance->ReturnThruPtr_pFd_Size = cmock_size; +} + +void vkGetFenceFdKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetFenceFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetFenceFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetFenceFdKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetFenceFdKHR_CMockIgnoreArg_pGetFdInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetFenceFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetFenceFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetFenceFdKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pGetFdInfo = 1; +} + +void vkGetFenceFdKHR_CMockIgnoreArg_pFd(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetFenceFdKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetFenceFdKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetFenceFdKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pFd = 1; +} + +VkResult vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR); + cmock_call_instance = (CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallInstance); + Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallInstance = CMock_Guts_MemNext(Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallInstance); + if (Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_FinalReturn; + memcpy((void*)(&Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallbackBool && + Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallbackFunctionPointer(physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions, Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queueFamilyIndex) + { + UNITY_SET_DETAILS(CMockString_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,CMockString_queueFamilyIndex); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_queueFamilyIndex, queueFamilyIndex, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCounterCount) + { + UNITY_SET_DETAILS(CMockString_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,CMockString_pCounterCount); + if (cmock_call_instance->Expected_pCounterCount == NULL) + { UNITY_TEST_ASSERT_NULL(pCounterCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pCounterCount, pCounterCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pCounters) + { + UNITY_SET_DETAILS(CMockString_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,CMockString_pCounters); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCounters), (void*)(pCounters), sizeof(VkPerformanceCounterKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCounterDescriptions) + { + UNITY_SET_DETAILS(CMockString_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,CMockString_pCounterDescriptions); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCounterDescriptions), (void*)(pCounterDescriptions), sizeof(VkPerformanceCounterDescriptionKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallbackFunctionPointer(physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions, Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pCounterCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pCounterCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pCounterCount, (const void*)cmock_call_instance->ReturnThruPtr_pCounterCount_Val, + cmock_call_instance->ReturnThruPtr_pCounterCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pCounters_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pCounters, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pCounters, (const void*)cmock_call_instance->ReturnThruPtr_pCounters_Val, + cmock_call_instance->ReturnThruPtr_pCounters_Size); + } + if (cmock_call_instance->ReturnThruPtr_pCounterDescriptions_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pCounterDescriptions, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pCounterDescriptions, (const void*)cmock_call_instance->ReturnThruPtr_pCounterDescriptions_Val, + cmock_call_instance->ReturnThruPtr_pCounterDescriptions_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions); +void CMockExpectParameters_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_queueFamilyIndex = queueFamilyIndex; + cmock_call_instance->IgnoreArg_queueFamilyIndex = 0; + cmock_call_instance->Expected_pCounterCount = pCounterCount; + cmock_call_instance->IgnoreArg_pCounterCount = 0; + cmock_call_instance->ReturnThruPtr_pCounterCount_Used = 0; + cmock_call_instance->Expected_pCounters = pCounters; + cmock_call_instance->IgnoreArg_pCounters = 0; + cmock_call_instance->ReturnThruPtr_pCounters_Used = 0; + cmock_call_instance->Expected_pCounterDescriptions = pCounterDescriptions; + cmock_call_instance->IgnoreArg_pCounterDescriptions = 0; + cmock_call_instance->ReturnThruPtr_pCounterDescriptions_Used = 0; +} + +void vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE)); + CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallInstance = CMock_Guts_MemChain(Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallInstance, cmock_guts_index); + Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_IgnoreBool = (char)1; +} + +void vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockStopIgnore(void) +{ + if(Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_IgnoreBool) + Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallInstance = CMock_Guts_MemNext(Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallInstance); + Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_IgnoreBool = (char)0; +} + +void vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE)); + CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallInstance = CMock_Guts_MemChain(Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallInstance, cmock_guts_index); + Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE)); + CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallInstance = CMock_Guts_MemChain(Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallInstance, cmock_guts_index); + Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(cmock_call_instance, physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_AddCallback(CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALLBACK Callback) +{ + Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_IgnoreBool = (char)0; + Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallbackBool = (char)1; + Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallbackFunctionPointer = Callback; +} + +void vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_Stub(CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALLBACK Callback) +{ + Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_IgnoreBool = (char)0; + Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallbackBool = (char)0; + Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallbackFunctionPointer = Callback; +} + +void vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockReturnMemThruPtr_pCounterCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pCounterCount, size_t cmock_size) +{ + CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pCounterCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pCounterCount_Val = pCounterCount; + cmock_call_instance->ReturnThruPtr_pCounterCount_Size = cmock_size; +} + +void vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockReturnMemThruPtr_pCounters(UNITY_LINE_TYPE cmock_line, VkPerformanceCounterKHR const* pCounters, size_t cmock_size) +{ + CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pCounters_Used = 1; + cmock_call_instance->ReturnThruPtr_pCounters_Val = pCounters; + cmock_call_instance->ReturnThruPtr_pCounters_Size = cmock_size; +} + +void vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockReturnMemThruPtr_pCounterDescriptions(UNITY_LINE_TYPE cmock_line, VkPerformanceCounterDescriptionKHR const* pCounterDescriptions, size_t cmock_size) +{ + CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pCounterDescriptions_Used = 1; + cmock_call_instance->ReturnThruPtr_pCounterDescriptions_Val = pCounterDescriptions; + cmock_call_instance->ReturnThruPtr_pCounterDescriptions_Size = cmock_size; +} + +void vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockIgnoreArg_queueFamilyIndex(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queueFamilyIndex = 1; +} + +void vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockIgnoreArg_pCounterCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCounterCount = 1; +} + +void vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockIgnoreArg_pCounters(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCounters = 1; +} + +void vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockIgnoreArg_pCounterDescriptions(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCounterDescriptions = 1; +} + +void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CallInstance); + Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CallInstance); + if (Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CallbackBool && + Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CallbackFunctionPointer(physicalDevice, pPerformanceQueryCreateInfo, pNumPasses, Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPerformanceQueryCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR,CMockString_pPerformanceQueryCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pPerformanceQueryCreateInfo), (void*)(pPerformanceQueryCreateInfo), sizeof(const VkQueryPoolPerformanceCreateInfoKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pNumPasses) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR,CMockString_pNumPasses); + if (cmock_call_instance->Expected_pNumPasses == NULL) + { UNITY_TEST_ASSERT_NULL(pNumPasses, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pNumPasses, pNumPasses, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CallbackFunctionPointer(physicalDevice, pPerformanceQueryCreateInfo, pNumPasses, Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pNumPasses_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pNumPasses, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pNumPasses, (const void*)cmock_call_instance->ReturnThruPtr_pNumPasses_Val, + cmock_call_instance->ReturnThruPtr_pNumPasses_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(CMOCK_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses); +void CMockExpectParameters_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(CMOCK_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pPerformanceQueryCreateInfo = pPerformanceQueryCreateInfo; + cmock_call_instance->IgnoreArg_pPerformanceQueryCreateInfo = 0; + cmock_call_instance->Expected_pNumPasses = pNumPasses; + cmock_call_instance->IgnoreArg_pNumPasses = 0; + cmock_call_instance->ReturnThruPtr_pNumPasses_Used = 0; +} + +void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CMockIgnore(void) +{ + Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CMockStopIgnore(void) +{ + Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(cmock_call_instance, physicalDevice, pPerformanceQueryCreateInfo, pNumPasses); +} + +void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_AddCallback(CMOCK_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_Stub(CMOCK_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CMockReturnMemThruPtr_pNumPasses(UNITY_LINE_TYPE cmock_line, uint32_t const* pNumPasses, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pNumPasses_Used = 1; + cmock_call_instance->ReturnThruPtr_pNumPasses_Val = pNumPasses; + cmock_call_instance->ReturnThruPtr_pNumPasses_Size = cmock_size; +} + +void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CMockIgnoreArg_pPerformanceQueryCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPerformanceQueryCreateInfo = 1; +} + +void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CMockIgnoreArg_pNumPasses(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pNumPasses = 1; +} + +VkResult vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkAcquireProfilingLockKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkAcquireProfilingLockKHR); + cmock_call_instance = (CMOCK_vkAcquireProfilingLockKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkAcquireProfilingLockKHR_CallInstance); + Mock.vkAcquireProfilingLockKHR_CallInstance = CMock_Guts_MemNext(Mock.vkAcquireProfilingLockKHR_CallInstance); + if (Mock.vkAcquireProfilingLockKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkAcquireProfilingLockKHR_FinalReturn; + memcpy((void*)(&Mock.vkAcquireProfilingLockKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkAcquireProfilingLockKHR_CallbackBool && + Mock.vkAcquireProfilingLockKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkAcquireProfilingLockKHR_CallbackFunctionPointer(device, pInfo, Mock.vkAcquireProfilingLockKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkAcquireProfilingLockKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkAcquireProfilingLockKHR,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkAcquireProfilingLockInfoKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkAcquireProfilingLockKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkAcquireProfilingLockKHR_CallbackFunctionPointer(device, pInfo, Mock.vkAcquireProfilingLockKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkAcquireProfilingLockKHR(CMOCK_vkAcquireProfilingLockKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo); +void CMockExpectParameters_vkAcquireProfilingLockKHR(CMOCK_vkAcquireProfilingLockKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; +} + +void vkAcquireProfilingLockKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkAcquireProfilingLockKHR_CALL_INSTANCE)); + CMOCK_vkAcquireProfilingLockKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquireProfilingLockKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkAcquireProfilingLockKHR_CallInstance = CMock_Guts_MemChain(Mock.vkAcquireProfilingLockKHR_CallInstance, cmock_guts_index); + Mock.vkAcquireProfilingLockKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkAcquireProfilingLockKHR_IgnoreBool = (char)1; +} + +void vkAcquireProfilingLockKHR_CMockStopIgnore(void) +{ + if(Mock.vkAcquireProfilingLockKHR_IgnoreBool) + Mock.vkAcquireProfilingLockKHR_CallInstance = CMock_Guts_MemNext(Mock.vkAcquireProfilingLockKHR_CallInstance); + Mock.vkAcquireProfilingLockKHR_IgnoreBool = (char)0; +} + +void vkAcquireProfilingLockKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkAcquireProfilingLockKHR_CALL_INSTANCE)); + CMOCK_vkAcquireProfilingLockKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquireProfilingLockKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkAcquireProfilingLockKHR_CallInstance = CMock_Guts_MemChain(Mock.vkAcquireProfilingLockKHR_CallInstance, cmock_guts_index); + Mock.vkAcquireProfilingLockKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkAcquireProfilingLockKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkAcquireProfilingLockKHR_CALL_INSTANCE)); + CMOCK_vkAcquireProfilingLockKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquireProfilingLockKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkAcquireProfilingLockKHR_CallInstance = CMock_Guts_MemChain(Mock.vkAcquireProfilingLockKHR_CallInstance, cmock_guts_index); + Mock.vkAcquireProfilingLockKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkAcquireProfilingLockKHR(cmock_call_instance, device, pInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkAcquireProfilingLockKHR_AddCallback(CMOCK_vkAcquireProfilingLockKHR_CALLBACK Callback) +{ + Mock.vkAcquireProfilingLockKHR_IgnoreBool = (char)0; + Mock.vkAcquireProfilingLockKHR_CallbackBool = (char)1; + Mock.vkAcquireProfilingLockKHR_CallbackFunctionPointer = Callback; +} + +void vkAcquireProfilingLockKHR_Stub(CMOCK_vkAcquireProfilingLockKHR_CALLBACK Callback) +{ + Mock.vkAcquireProfilingLockKHR_IgnoreBool = (char)0; + Mock.vkAcquireProfilingLockKHR_CallbackBool = (char)0; + Mock.vkAcquireProfilingLockKHR_CallbackFunctionPointer = Callback; +} + +void vkAcquireProfilingLockKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkAcquireProfilingLockKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquireProfilingLockKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAcquireProfilingLockKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkAcquireProfilingLockKHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkAcquireProfilingLockKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquireProfilingLockKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAcquireProfilingLockKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +void vkReleaseProfilingLockKHR(VkDevice device) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkReleaseProfilingLockKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkReleaseProfilingLockKHR); + cmock_call_instance = (CMOCK_vkReleaseProfilingLockKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkReleaseProfilingLockKHR_CallInstance); + Mock.vkReleaseProfilingLockKHR_CallInstance = CMock_Guts_MemNext(Mock.vkReleaseProfilingLockKHR_CallInstance); + if (Mock.vkReleaseProfilingLockKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkReleaseProfilingLockKHR_CallbackBool && + Mock.vkReleaseProfilingLockKHR_CallbackFunctionPointer != NULL) + { + Mock.vkReleaseProfilingLockKHR_CallbackFunctionPointer(device, Mock.vkReleaseProfilingLockKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkReleaseProfilingLockKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkReleaseProfilingLockKHR_CallbackFunctionPointer != NULL) + { + Mock.vkReleaseProfilingLockKHR_CallbackFunctionPointer(device, Mock.vkReleaseProfilingLockKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkReleaseProfilingLockKHR(CMOCK_vkReleaseProfilingLockKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device); +void CMockExpectParameters_vkReleaseProfilingLockKHR(CMOCK_vkReleaseProfilingLockKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; +} + +void vkReleaseProfilingLockKHR_CMockIgnore(void) +{ + Mock.vkReleaseProfilingLockKHR_IgnoreBool = (char)1; +} + +void vkReleaseProfilingLockKHR_CMockStopIgnore(void) +{ + Mock.vkReleaseProfilingLockKHR_IgnoreBool = (char)0; +} + +void vkReleaseProfilingLockKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkReleaseProfilingLockKHR_CALL_INSTANCE)); + CMOCK_vkReleaseProfilingLockKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkReleaseProfilingLockKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkReleaseProfilingLockKHR_CallInstance = CMock_Guts_MemChain(Mock.vkReleaseProfilingLockKHR_CallInstance, cmock_guts_index); + Mock.vkReleaseProfilingLockKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkReleaseProfilingLockKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkReleaseProfilingLockKHR_CALL_INSTANCE)); + CMOCK_vkReleaseProfilingLockKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkReleaseProfilingLockKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkReleaseProfilingLockKHR_CallInstance = CMock_Guts_MemChain(Mock.vkReleaseProfilingLockKHR_CallInstance, cmock_guts_index); + Mock.vkReleaseProfilingLockKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkReleaseProfilingLockKHR(cmock_call_instance, device); +} + +void vkReleaseProfilingLockKHR_AddCallback(CMOCK_vkReleaseProfilingLockKHR_CALLBACK Callback) +{ + Mock.vkReleaseProfilingLockKHR_IgnoreBool = (char)0; + Mock.vkReleaseProfilingLockKHR_CallbackBool = (char)1; + Mock.vkReleaseProfilingLockKHR_CallbackFunctionPointer = Callback; +} + +void vkReleaseProfilingLockKHR_Stub(CMOCK_vkReleaseProfilingLockKHR_CALLBACK Callback) +{ + Mock.vkReleaseProfilingLockKHR_IgnoreBool = (char)0; + Mock.vkReleaseProfilingLockKHR_CallbackBool = (char)0; + Mock.vkReleaseProfilingLockKHR_CallbackFunctionPointer = Callback; +} + +void vkReleaseProfilingLockKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkReleaseProfilingLockKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkReleaseProfilingLockKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkReleaseProfilingLockKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceSurfaceCapabilities2KHR); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallInstance); + Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallInstance); + if (Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_FinalReturn; + memcpy((void*)(&Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallbackBool && + Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallbackFunctionPointer(physicalDevice, pSurfaceInfo, pSurfaceCapabilities, Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSurfaceCapabilities2KHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSurfaceInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSurfaceCapabilities2KHR,CMockString_pSurfaceInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSurfaceInfo), (void*)(pSurfaceInfo), sizeof(const VkPhysicalDeviceSurfaceInfo2KHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSurfaceCapabilities) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSurfaceCapabilities2KHR,CMockString_pSurfaceCapabilities); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSurfaceCapabilities), (void*)(pSurfaceCapabilities), sizeof(VkSurfaceCapabilities2KHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallbackFunctionPointer(physicalDevice, pSurfaceInfo, pSurfaceCapabilities, Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pSurfaceCapabilities_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSurfaceCapabilities, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSurfaceCapabilities, (const void*)cmock_call_instance->ReturnThruPtr_pSurfaceCapabilities_Val, + cmock_call_instance->ReturnThruPtr_pSurfaceCapabilities_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPhysicalDeviceSurfaceCapabilities2KHR(CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2KHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities); +void CMockExpectParameters_vkGetPhysicalDeviceSurfaceCapabilities2KHR(CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2KHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pSurfaceInfo = pSurfaceInfo; + cmock_call_instance->IgnoreArg_pSurfaceInfo = 0; + cmock_call_instance->Expected_pSurfaceCapabilities = pSurfaceCapabilities; + cmock_call_instance->IgnoreArg_pSurfaceCapabilities = 0; + cmock_call_instance->ReturnThruPtr_pSurfaceCapabilities_Used = 0; +} + +void vkGetPhysicalDeviceSurfaceCapabilities2KHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2KHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceSurfaceCapabilities2KHR_CMockStopIgnore(void) +{ + if(Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_IgnoreBool) + Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallInstance); + Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceSurfaceCapabilities2KHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2KHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceSurfaceCapabilities2KHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2KHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceSurfaceCapabilities2KHR(cmock_call_instance, physicalDevice, pSurfaceInfo, pSurfaceCapabilities); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPhysicalDeviceSurfaceCapabilities2KHR_AddCallback(CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2KHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceSurfaceCapabilities2KHR_Stub(CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2KHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceSurfaceCapabilities2KHR_CMockReturnMemThruPtr_pSurfaceCapabilities(UNITY_LINE_TYPE cmock_line, VkSurfaceCapabilities2KHR const* pSurfaceCapabilities, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSurfaceCapabilities_Used = 1; + cmock_call_instance->ReturnThruPtr_pSurfaceCapabilities_Val = pSurfaceCapabilities; + cmock_call_instance->ReturnThruPtr_pSurfaceCapabilities_Size = cmock_size; +} + +void vkGetPhysicalDeviceSurfaceCapabilities2KHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceSurfaceCapabilities2KHR_CMockIgnoreArg_pSurfaceInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSurfaceInfo = 1; +} + +void vkGetPhysicalDeviceSurfaceCapabilities2KHR_CMockIgnoreArg_pSurfaceCapabilities(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfaceCapabilities2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSurfaceCapabilities = 1; +} + +VkResult vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceSurfaceFormats2KHR); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_CallInstance); + Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_CallInstance); + if (Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_FinalReturn; + memcpy((void*)(&Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_CallbackBool && + Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_CallbackFunctionPointer(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats, Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSurfaceFormats2KHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSurfaceInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSurfaceFormats2KHR,CMockString_pSurfaceInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSurfaceInfo), (void*)(pSurfaceInfo), sizeof(const VkPhysicalDeviceSurfaceInfo2KHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSurfaceFormatCount) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSurfaceFormats2KHR,CMockString_pSurfaceFormatCount); + if (cmock_call_instance->Expected_pSurfaceFormatCount == NULL) + { UNITY_TEST_ASSERT_NULL(pSurfaceFormatCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pSurfaceFormatCount, pSurfaceFormatCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pSurfaceFormats) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSurfaceFormats2KHR,CMockString_pSurfaceFormats); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSurfaceFormats), (void*)(pSurfaceFormats), sizeof(VkSurfaceFormat2KHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_CallbackFunctionPointer(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats, Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pSurfaceFormatCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSurfaceFormatCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSurfaceFormatCount, (const void*)cmock_call_instance->ReturnThruPtr_pSurfaceFormatCount_Val, + cmock_call_instance->ReturnThruPtr_pSurfaceFormatCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pSurfaceFormats_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSurfaceFormats, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSurfaceFormats, (const void*)cmock_call_instance->ReturnThruPtr_pSurfaceFormats_Val, + cmock_call_instance->ReturnThruPtr_pSurfaceFormats_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPhysicalDeviceSurfaceFormats2KHR(CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats); +void CMockExpectParameters_vkGetPhysicalDeviceSurfaceFormats2KHR(CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pSurfaceInfo = pSurfaceInfo; + cmock_call_instance->IgnoreArg_pSurfaceInfo = 0; + cmock_call_instance->Expected_pSurfaceFormatCount = pSurfaceFormatCount; + cmock_call_instance->IgnoreArg_pSurfaceFormatCount = 0; + cmock_call_instance->ReturnThruPtr_pSurfaceFormatCount_Used = 0; + cmock_call_instance->Expected_pSurfaceFormats = pSurfaceFormats; + cmock_call_instance->IgnoreArg_pSurfaceFormats = 0; + cmock_call_instance->ReturnThruPtr_pSurfaceFormats_Used = 0; +} + +void vkGetPhysicalDeviceSurfaceFormats2KHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceSurfaceFormats2KHR_CMockStopIgnore(void) +{ + if(Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_IgnoreBool) + Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_CallInstance); + Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceSurfaceFormats2KHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceSurfaceFormats2KHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceSurfaceFormats2KHR(cmock_call_instance, physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPhysicalDeviceSurfaceFormats2KHR_AddCallback(CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceSurfaceFormats2KHR_Stub(CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceSurfaceFormats2KHR_CMockReturnMemThruPtr_pSurfaceFormatCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pSurfaceFormatCount, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSurfaceFormatCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pSurfaceFormatCount_Val = pSurfaceFormatCount; + cmock_call_instance->ReturnThruPtr_pSurfaceFormatCount_Size = cmock_size; +} + +void vkGetPhysicalDeviceSurfaceFormats2KHR_CMockReturnMemThruPtr_pSurfaceFormats(UNITY_LINE_TYPE cmock_line, VkSurfaceFormat2KHR const* pSurfaceFormats, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSurfaceFormats_Used = 1; + cmock_call_instance->ReturnThruPtr_pSurfaceFormats_Val = pSurfaceFormats; + cmock_call_instance->ReturnThruPtr_pSurfaceFormats_Size = cmock_size; +} + +void vkGetPhysicalDeviceSurfaceFormats2KHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceSurfaceFormats2KHR_CMockIgnoreArg_pSurfaceInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSurfaceInfo = 1; +} + +void vkGetPhysicalDeviceSurfaceFormats2KHR_CMockIgnoreArg_pSurfaceFormatCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSurfaceFormatCount = 1; +} + +void vkGetPhysicalDeviceSurfaceFormats2KHR_CMockIgnoreArg_pSurfaceFormats(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfaceFormats2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSurfaceFormats = 1; +} + +VkResult vkGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceDisplayProperties2KHR); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceDisplayProperties2KHR_CallInstance); + Mock.vkGetPhysicalDeviceDisplayProperties2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceDisplayProperties2KHR_CallInstance); + if (Mock.vkGetPhysicalDeviceDisplayProperties2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPhysicalDeviceDisplayProperties2KHR_FinalReturn; + memcpy((void*)(&Mock.vkGetPhysicalDeviceDisplayProperties2KHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPhysicalDeviceDisplayProperties2KHR_CallbackBool && + Mock.vkGetPhysicalDeviceDisplayProperties2KHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPhysicalDeviceDisplayProperties2KHR_CallbackFunctionPointer(physicalDevice, pPropertyCount, pProperties, Mock.vkGetPhysicalDeviceDisplayProperties2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceDisplayProperties2KHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPropertyCount) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceDisplayProperties2KHR,CMockString_pPropertyCount); + if (cmock_call_instance->Expected_pPropertyCount == NULL) + { UNITY_TEST_ASSERT_NULL(pPropertyCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pPropertyCount, pPropertyCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceDisplayProperties2KHR,CMockString_pProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pProperties), (void*)(pProperties), sizeof(VkDisplayProperties2KHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceDisplayProperties2KHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPhysicalDeviceDisplayProperties2KHR_CallbackFunctionPointer(physicalDevice, pPropertyCount, pProperties, Mock.vkGetPhysicalDeviceDisplayProperties2KHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPropertyCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPropertyCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPropertyCount, (const void*)cmock_call_instance->ReturnThruPtr_pPropertyCount_Val, + cmock_call_instance->ReturnThruPtr_pPropertyCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pProperties, (const void*)cmock_call_instance->ReturnThruPtr_pProperties_Val, + cmock_call_instance->ReturnThruPtr_pProperties_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPhysicalDeviceDisplayProperties2KHR(CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties); +void CMockExpectParameters_vkGetPhysicalDeviceDisplayProperties2KHR(CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pPropertyCount = pPropertyCount; + cmock_call_instance->IgnoreArg_pPropertyCount = 0; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Used = 0; + cmock_call_instance->Expected_pProperties = pProperties; + cmock_call_instance->IgnoreArg_pProperties = 0; + cmock_call_instance->ReturnThruPtr_pProperties_Used = 0; +} + +void vkGetPhysicalDeviceDisplayProperties2KHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceDisplayProperties2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceDisplayProperties2KHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceDisplayProperties2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPhysicalDeviceDisplayProperties2KHR_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceDisplayProperties2KHR_CMockStopIgnore(void) +{ + if(Mock.vkGetPhysicalDeviceDisplayProperties2KHR_IgnoreBool) + Mock.vkGetPhysicalDeviceDisplayProperties2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceDisplayProperties2KHR_CallInstance); + Mock.vkGetPhysicalDeviceDisplayProperties2KHR_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceDisplayProperties2KHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceDisplayProperties2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceDisplayProperties2KHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceDisplayProperties2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceDisplayProperties2KHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceDisplayProperties2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceDisplayProperties2KHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceDisplayProperties2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceDisplayProperties2KHR(cmock_call_instance, physicalDevice, pPropertyCount, pProperties); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPhysicalDeviceDisplayProperties2KHR_AddCallback(CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceDisplayProperties2KHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceDisplayProperties2KHR_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceDisplayProperties2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceDisplayProperties2KHR_Stub(CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceDisplayProperties2KHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceDisplayProperties2KHR_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceDisplayProperties2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceDisplayProperties2KHR_CMockReturnMemThruPtr_pPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPropertyCount, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceDisplayProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPropertyCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Val = pPropertyCount; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Size = cmock_size; +} + +void vkGetPhysicalDeviceDisplayProperties2KHR_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkDisplayProperties2KHR const* pProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceDisplayProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pProperties_Val = pProperties; + cmock_call_instance->ReturnThruPtr_pProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceDisplayProperties2KHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceDisplayProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceDisplayProperties2KHR_CMockIgnoreArg_pPropertyCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceDisplayProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPropertyCount = 1; +} + +void vkGetPhysicalDeviceDisplayProperties2KHR_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceDisplayProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pProperties = 1; +} + +VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceDisplayPlaneProperties2KHR); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallInstance); + Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallInstance); + if (Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_FinalReturn; + memcpy((void*)(&Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallbackBool && + Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallbackFunctionPointer(physicalDevice, pPropertyCount, pProperties, Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceDisplayPlaneProperties2KHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPropertyCount) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceDisplayPlaneProperties2KHR,CMockString_pPropertyCount); + if (cmock_call_instance->Expected_pPropertyCount == NULL) + { UNITY_TEST_ASSERT_NULL(pPropertyCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pPropertyCount, pPropertyCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceDisplayPlaneProperties2KHR,CMockString_pProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pProperties), (void*)(pProperties), sizeof(VkDisplayPlaneProperties2KHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallbackFunctionPointer(physicalDevice, pPropertyCount, pProperties, Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPropertyCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPropertyCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPropertyCount, (const void*)cmock_call_instance->ReturnThruPtr_pPropertyCount_Val, + cmock_call_instance->ReturnThruPtr_pPropertyCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pProperties, (const void*)cmock_call_instance->ReturnThruPtr_pProperties_Val, + cmock_call_instance->ReturnThruPtr_pProperties_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties); +void CMockExpectParameters_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pPropertyCount = pPropertyCount; + cmock_call_instance->IgnoreArg_pPropertyCount = 0; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Used = 0; + cmock_call_instance->Expected_pProperties = pProperties; + cmock_call_instance->IgnoreArg_pProperties = 0; + cmock_call_instance->ReturnThruPtr_pProperties_Used = 0; +} + +void vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockStopIgnore(void) +{ + if(Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_IgnoreBool) + Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallInstance); + Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(cmock_call_instance, physicalDevice, pPropertyCount, pProperties); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPhysicalDeviceDisplayPlaneProperties2KHR_AddCallback(CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceDisplayPlaneProperties2KHR_Stub(CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockReturnMemThruPtr_pPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPropertyCount, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPropertyCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Val = pPropertyCount; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Size = cmock_size; +} + +void vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkDisplayPlaneProperties2KHR const* pProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pProperties_Val = pProperties; + cmock_call_instance->ReturnThruPtr_pProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockIgnoreArg_pPropertyCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPropertyCount = 1; +} + +void vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pProperties = 1; +} + +VkResult vkGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDisplayModeProperties2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDisplayModeProperties2KHR); + cmock_call_instance = (CMOCK_vkGetDisplayModeProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDisplayModeProperties2KHR_CallInstance); + Mock.vkGetDisplayModeProperties2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetDisplayModeProperties2KHR_CallInstance); + if (Mock.vkGetDisplayModeProperties2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetDisplayModeProperties2KHR_FinalReturn; + memcpy((void*)(&Mock.vkGetDisplayModeProperties2KHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetDisplayModeProperties2KHR_CallbackBool && + Mock.vkGetDisplayModeProperties2KHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetDisplayModeProperties2KHR_CallbackFunctionPointer(physicalDevice, display, pPropertyCount, pProperties, Mock.vkGetDisplayModeProperties2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetDisplayModeProperties2KHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_display) + { + UNITY_SET_DETAILS(CMockString_vkGetDisplayModeProperties2KHR,CMockString_display); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_display), (void*)(&display), sizeof(VkDisplayKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPropertyCount) + { + UNITY_SET_DETAILS(CMockString_vkGetDisplayModeProperties2KHR,CMockString_pPropertyCount); + if (cmock_call_instance->Expected_pPropertyCount == NULL) + { UNITY_TEST_ASSERT_NULL(pPropertyCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pPropertyCount, pPropertyCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetDisplayModeProperties2KHR,CMockString_pProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pProperties), (void*)(pProperties), sizeof(VkDisplayModeProperties2KHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDisplayModeProperties2KHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetDisplayModeProperties2KHR_CallbackFunctionPointer(physicalDevice, display, pPropertyCount, pProperties, Mock.vkGetDisplayModeProperties2KHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPropertyCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPropertyCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPropertyCount, (const void*)cmock_call_instance->ReturnThruPtr_pPropertyCount_Val, + cmock_call_instance->ReturnThruPtr_pPropertyCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pProperties, (const void*)cmock_call_instance->ReturnThruPtr_pProperties_Val, + cmock_call_instance->ReturnThruPtr_pProperties_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetDisplayModeProperties2KHR(CMOCK_vkGetDisplayModeProperties2KHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties); +void CMockExpectParameters_vkGetDisplayModeProperties2KHR(CMOCK_vkGetDisplayModeProperties2KHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + memcpy((void*)(&cmock_call_instance->Expected_display), (void*)(&display), + sizeof(VkDisplayKHR[sizeof(display) == sizeof(VkDisplayKHR) ? 1 : -1])); /* add VkDisplayKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_display = 0; + cmock_call_instance->Expected_pPropertyCount = pPropertyCount; + cmock_call_instance->IgnoreArg_pPropertyCount = 0; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Used = 0; + cmock_call_instance->Expected_pProperties = pProperties; + cmock_call_instance->IgnoreArg_pProperties = 0; + cmock_call_instance->ReturnThruPtr_pProperties_Used = 0; +} + +void vkGetDisplayModeProperties2KHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDisplayModeProperties2KHR_CALL_INSTANCE)); + CMOCK_vkGetDisplayModeProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayModeProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDisplayModeProperties2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDisplayModeProperties2KHR_CallInstance, cmock_guts_index); + Mock.vkGetDisplayModeProperties2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetDisplayModeProperties2KHR_IgnoreBool = (char)1; +} + +void vkGetDisplayModeProperties2KHR_CMockStopIgnore(void) +{ + if(Mock.vkGetDisplayModeProperties2KHR_IgnoreBool) + Mock.vkGetDisplayModeProperties2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetDisplayModeProperties2KHR_CallInstance); + Mock.vkGetDisplayModeProperties2KHR_IgnoreBool = (char)0; +} + +void vkGetDisplayModeProperties2KHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDisplayModeProperties2KHR_CALL_INSTANCE)); + CMOCK_vkGetDisplayModeProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayModeProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDisplayModeProperties2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDisplayModeProperties2KHR_CallInstance, cmock_guts_index); + Mock.vkGetDisplayModeProperties2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDisplayModeProperties2KHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDisplayModeProperties2KHR_CALL_INSTANCE)); + CMOCK_vkGetDisplayModeProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayModeProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDisplayModeProperties2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDisplayModeProperties2KHR_CallInstance, cmock_guts_index); + Mock.vkGetDisplayModeProperties2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDisplayModeProperties2KHR(cmock_call_instance, physicalDevice, display, pPropertyCount, pProperties); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetDisplayModeProperties2KHR_AddCallback(CMOCK_vkGetDisplayModeProperties2KHR_CALLBACK Callback) +{ + Mock.vkGetDisplayModeProperties2KHR_IgnoreBool = (char)0; + Mock.vkGetDisplayModeProperties2KHR_CallbackBool = (char)1; + Mock.vkGetDisplayModeProperties2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetDisplayModeProperties2KHR_Stub(CMOCK_vkGetDisplayModeProperties2KHR_CALLBACK Callback) +{ + Mock.vkGetDisplayModeProperties2KHR_IgnoreBool = (char)0; + Mock.vkGetDisplayModeProperties2KHR_CallbackBool = (char)0; + Mock.vkGetDisplayModeProperties2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetDisplayModeProperties2KHR_CMockReturnMemThruPtr_pPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPropertyCount, size_t cmock_size) +{ + CMOCK_vkGetDisplayModeProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayModeProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDisplayModeProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPropertyCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Val = pPropertyCount; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Size = cmock_size; +} + +void vkGetDisplayModeProperties2KHR_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkDisplayModeProperties2KHR const* pProperties, size_t cmock_size) +{ + CMOCK_vkGetDisplayModeProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayModeProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDisplayModeProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pProperties_Val = pProperties; + cmock_call_instance->ReturnThruPtr_pProperties_Size = cmock_size; +} + +void vkGetDisplayModeProperties2KHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDisplayModeProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayModeProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDisplayModeProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetDisplayModeProperties2KHR_CMockIgnoreArg_display(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDisplayModeProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayModeProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDisplayModeProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_display = 1; +} + +void vkGetDisplayModeProperties2KHR_CMockIgnoreArg_pPropertyCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDisplayModeProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayModeProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDisplayModeProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPropertyCount = 1; +} + +void vkGetDisplayModeProperties2KHR_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDisplayModeProperties2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayModeProperties2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDisplayModeProperties2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pProperties = 1; +} + +VkResult vkGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDisplayPlaneCapabilities2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDisplayPlaneCapabilities2KHR); + cmock_call_instance = (CMOCK_vkGetDisplayPlaneCapabilities2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDisplayPlaneCapabilities2KHR_CallInstance); + Mock.vkGetDisplayPlaneCapabilities2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetDisplayPlaneCapabilities2KHR_CallInstance); + if (Mock.vkGetDisplayPlaneCapabilities2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetDisplayPlaneCapabilities2KHR_FinalReturn; + memcpy((void*)(&Mock.vkGetDisplayPlaneCapabilities2KHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetDisplayPlaneCapabilities2KHR_CallbackBool && + Mock.vkGetDisplayPlaneCapabilities2KHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetDisplayPlaneCapabilities2KHR_CallbackFunctionPointer(physicalDevice, pDisplayPlaneInfo, pCapabilities, Mock.vkGetDisplayPlaneCapabilities2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetDisplayPlaneCapabilities2KHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDisplayPlaneInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetDisplayPlaneCapabilities2KHR,CMockString_pDisplayPlaneInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDisplayPlaneInfo), (void*)(pDisplayPlaneInfo), sizeof(const VkDisplayPlaneInfo2KHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCapabilities) + { + UNITY_SET_DETAILS(CMockString_vkGetDisplayPlaneCapabilities2KHR,CMockString_pCapabilities); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCapabilities), (void*)(pCapabilities), sizeof(VkDisplayPlaneCapabilities2KHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDisplayPlaneCapabilities2KHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetDisplayPlaneCapabilities2KHR_CallbackFunctionPointer(physicalDevice, pDisplayPlaneInfo, pCapabilities, Mock.vkGetDisplayPlaneCapabilities2KHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pCapabilities_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pCapabilities, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pCapabilities, (const void*)cmock_call_instance->ReturnThruPtr_pCapabilities_Val, + cmock_call_instance->ReturnThruPtr_pCapabilities_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetDisplayPlaneCapabilities2KHR(CMOCK_vkGetDisplayPlaneCapabilities2KHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities); +void CMockExpectParameters_vkGetDisplayPlaneCapabilities2KHR(CMOCK_vkGetDisplayPlaneCapabilities2KHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pDisplayPlaneInfo = pDisplayPlaneInfo; + cmock_call_instance->IgnoreArg_pDisplayPlaneInfo = 0; + cmock_call_instance->Expected_pCapabilities = pCapabilities; + cmock_call_instance->IgnoreArg_pCapabilities = 0; + cmock_call_instance->ReturnThruPtr_pCapabilities_Used = 0; +} + +void vkGetDisplayPlaneCapabilities2KHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDisplayPlaneCapabilities2KHR_CALL_INSTANCE)); + CMOCK_vkGetDisplayPlaneCapabilities2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayPlaneCapabilities2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDisplayPlaneCapabilities2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDisplayPlaneCapabilities2KHR_CallInstance, cmock_guts_index); + Mock.vkGetDisplayPlaneCapabilities2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetDisplayPlaneCapabilities2KHR_IgnoreBool = (char)1; +} + +void vkGetDisplayPlaneCapabilities2KHR_CMockStopIgnore(void) +{ + if(Mock.vkGetDisplayPlaneCapabilities2KHR_IgnoreBool) + Mock.vkGetDisplayPlaneCapabilities2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetDisplayPlaneCapabilities2KHR_CallInstance); + Mock.vkGetDisplayPlaneCapabilities2KHR_IgnoreBool = (char)0; +} + +void vkGetDisplayPlaneCapabilities2KHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDisplayPlaneCapabilities2KHR_CALL_INSTANCE)); + CMOCK_vkGetDisplayPlaneCapabilities2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayPlaneCapabilities2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDisplayPlaneCapabilities2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDisplayPlaneCapabilities2KHR_CallInstance, cmock_guts_index); + Mock.vkGetDisplayPlaneCapabilities2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDisplayPlaneCapabilities2KHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDisplayPlaneCapabilities2KHR_CALL_INSTANCE)); + CMOCK_vkGetDisplayPlaneCapabilities2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayPlaneCapabilities2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDisplayPlaneCapabilities2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDisplayPlaneCapabilities2KHR_CallInstance, cmock_guts_index); + Mock.vkGetDisplayPlaneCapabilities2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDisplayPlaneCapabilities2KHR(cmock_call_instance, physicalDevice, pDisplayPlaneInfo, pCapabilities); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetDisplayPlaneCapabilities2KHR_AddCallback(CMOCK_vkGetDisplayPlaneCapabilities2KHR_CALLBACK Callback) +{ + Mock.vkGetDisplayPlaneCapabilities2KHR_IgnoreBool = (char)0; + Mock.vkGetDisplayPlaneCapabilities2KHR_CallbackBool = (char)1; + Mock.vkGetDisplayPlaneCapabilities2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetDisplayPlaneCapabilities2KHR_Stub(CMOCK_vkGetDisplayPlaneCapabilities2KHR_CALLBACK Callback) +{ + Mock.vkGetDisplayPlaneCapabilities2KHR_IgnoreBool = (char)0; + Mock.vkGetDisplayPlaneCapabilities2KHR_CallbackBool = (char)0; + Mock.vkGetDisplayPlaneCapabilities2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetDisplayPlaneCapabilities2KHR_CMockReturnMemThruPtr_pCapabilities(UNITY_LINE_TYPE cmock_line, VkDisplayPlaneCapabilities2KHR const* pCapabilities, size_t cmock_size) +{ + CMOCK_vkGetDisplayPlaneCapabilities2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayPlaneCapabilities2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDisplayPlaneCapabilities2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pCapabilities_Used = 1; + cmock_call_instance->ReturnThruPtr_pCapabilities_Val = pCapabilities; + cmock_call_instance->ReturnThruPtr_pCapabilities_Size = cmock_size; +} + +void vkGetDisplayPlaneCapabilities2KHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDisplayPlaneCapabilities2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayPlaneCapabilities2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDisplayPlaneCapabilities2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetDisplayPlaneCapabilities2KHR_CMockIgnoreArg_pDisplayPlaneInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDisplayPlaneCapabilities2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayPlaneCapabilities2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDisplayPlaneCapabilities2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDisplayPlaneInfo = 1; +} + +void vkGetDisplayPlaneCapabilities2KHR_CMockIgnoreArg_pCapabilities(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDisplayPlaneCapabilities2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDisplayPlaneCapabilities2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDisplayPlaneCapabilities2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCapabilities = 1; +} + +void vkGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetImageMemoryRequirements2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetImageMemoryRequirements2KHR); + cmock_call_instance = (CMOCK_vkGetImageMemoryRequirements2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetImageMemoryRequirements2KHR_CallInstance); + Mock.vkGetImageMemoryRequirements2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetImageMemoryRequirements2KHR_CallInstance); + if (Mock.vkGetImageMemoryRequirements2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetImageMemoryRequirements2KHR_CallbackBool && + Mock.vkGetImageMemoryRequirements2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetImageMemoryRequirements2KHR_CallbackFunctionPointer(device, pInfo, pMemoryRequirements, Mock.vkGetImageMemoryRequirements2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetImageMemoryRequirements2KHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetImageMemoryRequirements2KHR,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkImageMemoryRequirementsInfo2), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMemoryRequirements) + { + UNITY_SET_DETAILS(CMockString_vkGetImageMemoryRequirements2KHR,CMockString_pMemoryRequirements); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMemoryRequirements), (void*)(pMemoryRequirements), sizeof(VkMemoryRequirements2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetImageMemoryRequirements2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetImageMemoryRequirements2KHR_CallbackFunctionPointer(device, pInfo, pMemoryRequirements, Mock.vkGetImageMemoryRequirements2KHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pMemoryRequirements, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pMemoryRequirements, (const void*)cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Val, + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetImageMemoryRequirements2KHR(CMOCK_vkGetImageMemoryRequirements2KHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +void CMockExpectParameters_vkGetImageMemoryRequirements2KHR(CMOCK_vkGetImageMemoryRequirements2KHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; + cmock_call_instance->Expected_pMemoryRequirements = pMemoryRequirements; + cmock_call_instance->IgnoreArg_pMemoryRequirements = 0; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used = 0; +} + +void vkGetImageMemoryRequirements2KHR_CMockIgnore(void) +{ + Mock.vkGetImageMemoryRequirements2KHR_IgnoreBool = (char)1; +} + +void vkGetImageMemoryRequirements2KHR_CMockStopIgnore(void) +{ + Mock.vkGetImageMemoryRequirements2KHR_IgnoreBool = (char)0; +} + +void vkGetImageMemoryRequirements2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageMemoryRequirements2KHR_CALL_INSTANCE)); + CMOCK_vkGetImageMemoryRequirements2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageMemoryRequirements2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageMemoryRequirements2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageMemoryRequirements2KHR_CallInstance, cmock_guts_index); + Mock.vkGetImageMemoryRequirements2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetImageMemoryRequirements2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageMemoryRequirements2KHR_CALL_INSTANCE)); + CMOCK_vkGetImageMemoryRequirements2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageMemoryRequirements2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageMemoryRequirements2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageMemoryRequirements2KHR_CallInstance, cmock_guts_index); + Mock.vkGetImageMemoryRequirements2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetImageMemoryRequirements2KHR(cmock_call_instance, device, pInfo, pMemoryRequirements); +} + +void vkGetImageMemoryRequirements2KHR_AddCallback(CMOCK_vkGetImageMemoryRequirements2KHR_CALLBACK Callback) +{ + Mock.vkGetImageMemoryRequirements2KHR_IgnoreBool = (char)0; + Mock.vkGetImageMemoryRequirements2KHR_CallbackBool = (char)1; + Mock.vkGetImageMemoryRequirements2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetImageMemoryRequirements2KHR_Stub(CMOCK_vkGetImageMemoryRequirements2KHR_CALLBACK Callback) +{ + Mock.vkGetImageMemoryRequirements2KHR_IgnoreBool = (char)0; + Mock.vkGetImageMemoryRequirements2KHR_CallbackBool = (char)0; + Mock.vkGetImageMemoryRequirements2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetImageMemoryRequirements2KHR_CMockReturnMemThruPtr_pMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkMemoryRequirements2 const* pMemoryRequirements, size_t cmock_size) +{ + CMOCK_vkGetImageMemoryRequirements2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageMemoryRequirements2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageMemoryRequirements2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used = 1; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Val = pMemoryRequirements; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Size = cmock_size; +} + +void vkGetImageMemoryRequirements2KHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageMemoryRequirements2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageMemoryRequirements2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageMemoryRequirements2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetImageMemoryRequirements2KHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageMemoryRequirements2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageMemoryRequirements2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageMemoryRequirements2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +void vkGetImageMemoryRequirements2KHR_CMockIgnoreArg_pMemoryRequirements(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageMemoryRequirements2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageMemoryRequirements2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageMemoryRequirements2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMemoryRequirements = 1; +} + +void vkGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetBufferMemoryRequirements2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetBufferMemoryRequirements2KHR); + cmock_call_instance = (CMOCK_vkGetBufferMemoryRequirements2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetBufferMemoryRequirements2KHR_CallInstance); + Mock.vkGetBufferMemoryRequirements2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetBufferMemoryRequirements2KHR_CallInstance); + if (Mock.vkGetBufferMemoryRequirements2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetBufferMemoryRequirements2KHR_CallbackBool && + Mock.vkGetBufferMemoryRequirements2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetBufferMemoryRequirements2KHR_CallbackFunctionPointer(device, pInfo, pMemoryRequirements, Mock.vkGetBufferMemoryRequirements2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetBufferMemoryRequirements2KHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetBufferMemoryRequirements2KHR,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkBufferMemoryRequirementsInfo2), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMemoryRequirements) + { + UNITY_SET_DETAILS(CMockString_vkGetBufferMemoryRequirements2KHR,CMockString_pMemoryRequirements); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMemoryRequirements), (void*)(pMemoryRequirements), sizeof(VkMemoryRequirements2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetBufferMemoryRequirements2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetBufferMemoryRequirements2KHR_CallbackFunctionPointer(device, pInfo, pMemoryRequirements, Mock.vkGetBufferMemoryRequirements2KHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pMemoryRequirements, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pMemoryRequirements, (const void*)cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Val, + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetBufferMemoryRequirements2KHR(CMOCK_vkGetBufferMemoryRequirements2KHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +void CMockExpectParameters_vkGetBufferMemoryRequirements2KHR(CMOCK_vkGetBufferMemoryRequirements2KHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; + cmock_call_instance->Expected_pMemoryRequirements = pMemoryRequirements; + cmock_call_instance->IgnoreArg_pMemoryRequirements = 0; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used = 0; +} + +void vkGetBufferMemoryRequirements2KHR_CMockIgnore(void) +{ + Mock.vkGetBufferMemoryRequirements2KHR_IgnoreBool = (char)1; +} + +void vkGetBufferMemoryRequirements2KHR_CMockStopIgnore(void) +{ + Mock.vkGetBufferMemoryRequirements2KHR_IgnoreBool = (char)0; +} + +void vkGetBufferMemoryRequirements2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetBufferMemoryRequirements2KHR_CALL_INSTANCE)); + CMOCK_vkGetBufferMemoryRequirements2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferMemoryRequirements2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetBufferMemoryRequirements2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetBufferMemoryRequirements2KHR_CallInstance, cmock_guts_index); + Mock.vkGetBufferMemoryRequirements2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetBufferMemoryRequirements2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetBufferMemoryRequirements2KHR_CALL_INSTANCE)); + CMOCK_vkGetBufferMemoryRequirements2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferMemoryRequirements2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetBufferMemoryRequirements2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetBufferMemoryRequirements2KHR_CallInstance, cmock_guts_index); + Mock.vkGetBufferMemoryRequirements2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetBufferMemoryRequirements2KHR(cmock_call_instance, device, pInfo, pMemoryRequirements); +} + +void vkGetBufferMemoryRequirements2KHR_AddCallback(CMOCK_vkGetBufferMemoryRequirements2KHR_CALLBACK Callback) +{ + Mock.vkGetBufferMemoryRequirements2KHR_IgnoreBool = (char)0; + Mock.vkGetBufferMemoryRequirements2KHR_CallbackBool = (char)1; + Mock.vkGetBufferMemoryRequirements2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetBufferMemoryRequirements2KHR_Stub(CMOCK_vkGetBufferMemoryRequirements2KHR_CALLBACK Callback) +{ + Mock.vkGetBufferMemoryRequirements2KHR_IgnoreBool = (char)0; + Mock.vkGetBufferMemoryRequirements2KHR_CallbackBool = (char)0; + Mock.vkGetBufferMemoryRequirements2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetBufferMemoryRequirements2KHR_CMockReturnMemThruPtr_pMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkMemoryRequirements2 const* pMemoryRequirements, size_t cmock_size) +{ + CMOCK_vkGetBufferMemoryRequirements2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferMemoryRequirements2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetBufferMemoryRequirements2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used = 1; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Val = pMemoryRequirements; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Size = cmock_size; +} + +void vkGetBufferMemoryRequirements2KHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetBufferMemoryRequirements2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferMemoryRequirements2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetBufferMemoryRequirements2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetBufferMemoryRequirements2KHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetBufferMemoryRequirements2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferMemoryRequirements2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetBufferMemoryRequirements2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +void vkGetBufferMemoryRequirements2KHR_CMockIgnoreArg_pMemoryRequirements(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetBufferMemoryRequirements2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferMemoryRequirements2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetBufferMemoryRequirements2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMemoryRequirements = 1; +} + +void vkGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetImageSparseMemoryRequirements2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetImageSparseMemoryRequirements2KHR); + cmock_call_instance = (CMOCK_vkGetImageSparseMemoryRequirements2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetImageSparseMemoryRequirements2KHR_CallInstance); + Mock.vkGetImageSparseMemoryRequirements2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetImageSparseMemoryRequirements2KHR_CallInstance); + if (Mock.vkGetImageSparseMemoryRequirements2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetImageSparseMemoryRequirements2KHR_CallbackBool && + Mock.vkGetImageSparseMemoryRequirements2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetImageSparseMemoryRequirements2KHR_CallbackFunctionPointer(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, Mock.vkGetImageSparseMemoryRequirements2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetImageSparseMemoryRequirements2KHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetImageSparseMemoryRequirements2KHR,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkImageSparseMemoryRequirementsInfo2), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSparseMemoryRequirementCount) + { + UNITY_SET_DETAILS(CMockString_vkGetImageSparseMemoryRequirements2KHR,CMockString_pSparseMemoryRequirementCount); + if (cmock_call_instance->Expected_pSparseMemoryRequirementCount == NULL) + { UNITY_TEST_ASSERT_NULL(pSparseMemoryRequirementCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pSparseMemoryRequirementCount, pSparseMemoryRequirementCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pSparseMemoryRequirements) + { + UNITY_SET_DETAILS(CMockString_vkGetImageSparseMemoryRequirements2KHR,CMockString_pSparseMemoryRequirements); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSparseMemoryRequirements), (void*)(pSparseMemoryRequirements), sizeof(VkSparseImageMemoryRequirements2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetImageSparseMemoryRequirements2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetImageSparseMemoryRequirements2KHR_CallbackFunctionPointer(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, Mock.vkGetImageSparseMemoryRequirements2KHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSparseMemoryRequirementCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSparseMemoryRequirementCount, (const void*)cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Val, + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSparseMemoryRequirements, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSparseMemoryRequirements, (const void*)cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Val, + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetImageSparseMemoryRequirements2KHR(CMOCK_vkGetImageSparseMemoryRequirements2KHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +void CMockExpectParameters_vkGetImageSparseMemoryRequirements2KHR(CMOCK_vkGetImageSparseMemoryRequirements2KHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; + cmock_call_instance->Expected_pSparseMemoryRequirementCount = pSparseMemoryRequirementCount; + cmock_call_instance->IgnoreArg_pSparseMemoryRequirementCount = 0; + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Used = 0; + cmock_call_instance->Expected_pSparseMemoryRequirements = pSparseMemoryRequirements; + cmock_call_instance->IgnoreArg_pSparseMemoryRequirements = 0; + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Used = 0; +} + +void vkGetImageSparseMemoryRequirements2KHR_CMockIgnore(void) +{ + Mock.vkGetImageSparseMemoryRequirements2KHR_IgnoreBool = (char)1; +} + +void vkGetImageSparseMemoryRequirements2KHR_CMockStopIgnore(void) +{ + Mock.vkGetImageSparseMemoryRequirements2KHR_IgnoreBool = (char)0; +} + +void vkGetImageSparseMemoryRequirements2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageSparseMemoryRequirements2KHR_CALL_INSTANCE)); + CMOCK_vkGetImageSparseMemoryRequirements2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSparseMemoryRequirements2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageSparseMemoryRequirements2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageSparseMemoryRequirements2KHR_CallInstance, cmock_guts_index); + Mock.vkGetImageSparseMemoryRequirements2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetImageSparseMemoryRequirements2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageSparseMemoryRequirements2KHR_CALL_INSTANCE)); + CMOCK_vkGetImageSparseMemoryRequirements2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSparseMemoryRequirements2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageSparseMemoryRequirements2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageSparseMemoryRequirements2KHR_CallInstance, cmock_guts_index); + Mock.vkGetImageSparseMemoryRequirements2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetImageSparseMemoryRequirements2KHR(cmock_call_instance, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); +} + +void vkGetImageSparseMemoryRequirements2KHR_AddCallback(CMOCK_vkGetImageSparseMemoryRequirements2KHR_CALLBACK Callback) +{ + Mock.vkGetImageSparseMemoryRequirements2KHR_IgnoreBool = (char)0; + Mock.vkGetImageSparseMemoryRequirements2KHR_CallbackBool = (char)1; + Mock.vkGetImageSparseMemoryRequirements2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetImageSparseMemoryRequirements2KHR_Stub(CMOCK_vkGetImageSparseMemoryRequirements2KHR_CALLBACK Callback) +{ + Mock.vkGetImageSparseMemoryRequirements2KHR_IgnoreBool = (char)0; + Mock.vkGetImageSparseMemoryRequirements2KHR_CallbackBool = (char)0; + Mock.vkGetImageSparseMemoryRequirements2KHR_CallbackFunctionPointer = Callback; +} + +void vkGetImageSparseMemoryRequirements2KHR_CMockReturnMemThruPtr_pSparseMemoryRequirementCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pSparseMemoryRequirementCount, size_t cmock_size) +{ + CMOCK_vkGetImageSparseMemoryRequirements2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSparseMemoryRequirements2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageSparseMemoryRequirements2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Val = pSparseMemoryRequirementCount; + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Size = cmock_size; +} + +void vkGetImageSparseMemoryRequirements2KHR_CMockReturnMemThruPtr_pSparseMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkSparseImageMemoryRequirements2 const* pSparseMemoryRequirements, size_t cmock_size) +{ + CMOCK_vkGetImageSparseMemoryRequirements2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSparseMemoryRequirements2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageSparseMemoryRequirements2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Used = 1; + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Val = pSparseMemoryRequirements; + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Size = cmock_size; +} + +void vkGetImageSparseMemoryRequirements2KHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageSparseMemoryRequirements2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSparseMemoryRequirements2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageSparseMemoryRequirements2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetImageSparseMemoryRequirements2KHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageSparseMemoryRequirements2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSparseMemoryRequirements2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageSparseMemoryRequirements2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +void vkGetImageSparseMemoryRequirements2KHR_CMockIgnoreArg_pSparseMemoryRequirementCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageSparseMemoryRequirements2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSparseMemoryRequirements2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageSparseMemoryRequirements2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSparseMemoryRequirementCount = 1; +} + +void vkGetImageSparseMemoryRequirements2KHR_CMockIgnoreArg_pSparseMemoryRequirements(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageSparseMemoryRequirements2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSparseMemoryRequirements2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageSparseMemoryRequirements2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSparseMemoryRequirements = 1; +} + +VkResult vkCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateSamplerYcbcrConversionKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateSamplerYcbcrConversionKHR); + cmock_call_instance = (CMOCK_vkCreateSamplerYcbcrConversionKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateSamplerYcbcrConversionKHR_CallInstance); + Mock.vkCreateSamplerYcbcrConversionKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCreateSamplerYcbcrConversionKHR_CallInstance); + if (Mock.vkCreateSamplerYcbcrConversionKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateSamplerYcbcrConversionKHR_FinalReturn; + memcpy((void*)(&Mock.vkCreateSamplerYcbcrConversionKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateSamplerYcbcrConversionKHR_CallbackBool && + Mock.vkCreateSamplerYcbcrConversionKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateSamplerYcbcrConversionKHR_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pYcbcrConversion, Mock.vkCreateSamplerYcbcrConversionKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateSamplerYcbcrConversionKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateSamplerYcbcrConversionKHR,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkSamplerYcbcrConversionCreateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateSamplerYcbcrConversionKHR,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pYcbcrConversion) + { + UNITY_SET_DETAILS(CMockString_vkCreateSamplerYcbcrConversionKHR,CMockString_pYcbcrConversion); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pYcbcrConversion), (void*)(pYcbcrConversion), sizeof(VkSamplerYcbcrConversion), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateSamplerYcbcrConversionKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateSamplerYcbcrConversionKHR_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pYcbcrConversion, Mock.vkCreateSamplerYcbcrConversionKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pYcbcrConversion_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pYcbcrConversion, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pYcbcrConversion, (const void*)cmock_call_instance->ReturnThruPtr_pYcbcrConversion_Val, + cmock_call_instance->ReturnThruPtr_pYcbcrConversion_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateSamplerYcbcrConversionKHR(CMOCK_vkCreateSamplerYcbcrConversionKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); +void CMockExpectParameters_vkCreateSamplerYcbcrConversionKHR(CMOCK_vkCreateSamplerYcbcrConversionKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pYcbcrConversion = pYcbcrConversion; + cmock_call_instance->IgnoreArg_pYcbcrConversion = 0; + cmock_call_instance->ReturnThruPtr_pYcbcrConversion_Used = 0; +} + +void vkCreateSamplerYcbcrConversionKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateSamplerYcbcrConversionKHR_CALL_INSTANCE)); + CMOCK_vkCreateSamplerYcbcrConversionKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSamplerYcbcrConversionKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateSamplerYcbcrConversionKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateSamplerYcbcrConversionKHR_CallInstance, cmock_guts_index); + Mock.vkCreateSamplerYcbcrConversionKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateSamplerYcbcrConversionKHR_IgnoreBool = (char)1; +} + +void vkCreateSamplerYcbcrConversionKHR_CMockStopIgnore(void) +{ + if(Mock.vkCreateSamplerYcbcrConversionKHR_IgnoreBool) + Mock.vkCreateSamplerYcbcrConversionKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCreateSamplerYcbcrConversionKHR_CallInstance); + Mock.vkCreateSamplerYcbcrConversionKHR_IgnoreBool = (char)0; +} + +void vkCreateSamplerYcbcrConversionKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateSamplerYcbcrConversionKHR_CALL_INSTANCE)); + CMOCK_vkCreateSamplerYcbcrConversionKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSamplerYcbcrConversionKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateSamplerYcbcrConversionKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateSamplerYcbcrConversionKHR_CallInstance, cmock_guts_index); + Mock.vkCreateSamplerYcbcrConversionKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateSamplerYcbcrConversionKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateSamplerYcbcrConversionKHR_CALL_INSTANCE)); + CMOCK_vkCreateSamplerYcbcrConversionKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSamplerYcbcrConversionKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateSamplerYcbcrConversionKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateSamplerYcbcrConversionKHR_CallInstance, cmock_guts_index); + Mock.vkCreateSamplerYcbcrConversionKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateSamplerYcbcrConversionKHR(cmock_call_instance, device, pCreateInfo, pAllocator, pYcbcrConversion); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateSamplerYcbcrConversionKHR_AddCallback(CMOCK_vkCreateSamplerYcbcrConversionKHR_CALLBACK Callback) +{ + Mock.vkCreateSamplerYcbcrConversionKHR_IgnoreBool = (char)0; + Mock.vkCreateSamplerYcbcrConversionKHR_CallbackBool = (char)1; + Mock.vkCreateSamplerYcbcrConversionKHR_CallbackFunctionPointer = Callback; +} + +void vkCreateSamplerYcbcrConversionKHR_Stub(CMOCK_vkCreateSamplerYcbcrConversionKHR_CALLBACK Callback) +{ + Mock.vkCreateSamplerYcbcrConversionKHR_IgnoreBool = (char)0; + Mock.vkCreateSamplerYcbcrConversionKHR_CallbackBool = (char)0; + Mock.vkCreateSamplerYcbcrConversionKHR_CallbackFunctionPointer = Callback; +} + +void vkCreateSamplerYcbcrConversionKHR_CMockReturnMemThruPtr_pYcbcrConversion(UNITY_LINE_TYPE cmock_line, VkSamplerYcbcrConversion const* pYcbcrConversion, size_t cmock_size) +{ + CMOCK_vkCreateSamplerYcbcrConversionKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSamplerYcbcrConversionKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSamplerYcbcrConversionKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pYcbcrConversion_Used = 1; + cmock_call_instance->ReturnThruPtr_pYcbcrConversion_Val = pYcbcrConversion; + cmock_call_instance->ReturnThruPtr_pYcbcrConversion_Size = cmock_size; +} + +void vkCreateSamplerYcbcrConversionKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateSamplerYcbcrConversionKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSamplerYcbcrConversionKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSamplerYcbcrConversionKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateSamplerYcbcrConversionKHR_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateSamplerYcbcrConversionKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSamplerYcbcrConversionKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSamplerYcbcrConversionKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateSamplerYcbcrConversionKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateSamplerYcbcrConversionKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSamplerYcbcrConversionKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSamplerYcbcrConversionKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateSamplerYcbcrConversionKHR_CMockIgnoreArg_pYcbcrConversion(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateSamplerYcbcrConversionKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateSamplerYcbcrConversionKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateSamplerYcbcrConversionKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pYcbcrConversion = 1; +} + +void vkDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroySamplerYcbcrConversionKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroySamplerYcbcrConversionKHR); + cmock_call_instance = (CMOCK_vkDestroySamplerYcbcrConversionKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroySamplerYcbcrConversionKHR_CallInstance); + Mock.vkDestroySamplerYcbcrConversionKHR_CallInstance = CMock_Guts_MemNext(Mock.vkDestroySamplerYcbcrConversionKHR_CallInstance); + if (Mock.vkDestroySamplerYcbcrConversionKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroySamplerYcbcrConversionKHR_CallbackBool && + Mock.vkDestroySamplerYcbcrConversionKHR_CallbackFunctionPointer != NULL) + { + Mock.vkDestroySamplerYcbcrConversionKHR_CallbackFunctionPointer(device, ycbcrConversion, pAllocator, Mock.vkDestroySamplerYcbcrConversionKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroySamplerYcbcrConversionKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_ycbcrConversion) + { + UNITY_SET_DETAILS(CMockString_vkDestroySamplerYcbcrConversionKHR,CMockString_ycbcrConversion); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_ycbcrConversion), (void*)(&ycbcrConversion), sizeof(VkSamplerYcbcrConversion), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroySamplerYcbcrConversionKHR,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroySamplerYcbcrConversionKHR_CallbackFunctionPointer != NULL) + { + Mock.vkDestroySamplerYcbcrConversionKHR_CallbackFunctionPointer(device, ycbcrConversion, pAllocator, Mock.vkDestroySamplerYcbcrConversionKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroySamplerYcbcrConversionKHR(CMOCK_vkDestroySamplerYcbcrConversionKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroySamplerYcbcrConversionKHR(CMOCK_vkDestroySamplerYcbcrConversionKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_ycbcrConversion), (void*)(&ycbcrConversion), + sizeof(VkSamplerYcbcrConversion[sizeof(ycbcrConversion) == sizeof(VkSamplerYcbcrConversion) ? 1 : -1])); /* add VkSamplerYcbcrConversion to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_ycbcrConversion = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroySamplerYcbcrConversionKHR_CMockIgnore(void) +{ + Mock.vkDestroySamplerYcbcrConversionKHR_IgnoreBool = (char)1; +} + +void vkDestroySamplerYcbcrConversionKHR_CMockStopIgnore(void) +{ + Mock.vkDestroySamplerYcbcrConversionKHR_IgnoreBool = (char)0; +} + +void vkDestroySamplerYcbcrConversionKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroySamplerYcbcrConversionKHR_CALL_INSTANCE)); + CMOCK_vkDestroySamplerYcbcrConversionKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroySamplerYcbcrConversionKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroySamplerYcbcrConversionKHR_CallInstance = CMock_Guts_MemChain(Mock.vkDestroySamplerYcbcrConversionKHR_CallInstance, cmock_guts_index); + Mock.vkDestroySamplerYcbcrConversionKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroySamplerYcbcrConversionKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroySamplerYcbcrConversionKHR_CALL_INSTANCE)); + CMOCK_vkDestroySamplerYcbcrConversionKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroySamplerYcbcrConversionKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroySamplerYcbcrConversionKHR_CallInstance = CMock_Guts_MemChain(Mock.vkDestroySamplerYcbcrConversionKHR_CallInstance, cmock_guts_index); + Mock.vkDestroySamplerYcbcrConversionKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroySamplerYcbcrConversionKHR(cmock_call_instance, device, ycbcrConversion, pAllocator); +} + +void vkDestroySamplerYcbcrConversionKHR_AddCallback(CMOCK_vkDestroySamplerYcbcrConversionKHR_CALLBACK Callback) +{ + Mock.vkDestroySamplerYcbcrConversionKHR_IgnoreBool = (char)0; + Mock.vkDestroySamplerYcbcrConversionKHR_CallbackBool = (char)1; + Mock.vkDestroySamplerYcbcrConversionKHR_CallbackFunctionPointer = Callback; +} + +void vkDestroySamplerYcbcrConversionKHR_Stub(CMOCK_vkDestroySamplerYcbcrConversionKHR_CALLBACK Callback) +{ + Mock.vkDestroySamplerYcbcrConversionKHR_IgnoreBool = (char)0; + Mock.vkDestroySamplerYcbcrConversionKHR_CallbackBool = (char)0; + Mock.vkDestroySamplerYcbcrConversionKHR_CallbackFunctionPointer = Callback; +} + +void vkDestroySamplerYcbcrConversionKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroySamplerYcbcrConversionKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroySamplerYcbcrConversionKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroySamplerYcbcrConversionKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroySamplerYcbcrConversionKHR_CMockIgnoreArg_ycbcrConversion(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroySamplerYcbcrConversionKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroySamplerYcbcrConversionKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroySamplerYcbcrConversionKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_ycbcrConversion = 1; +} + +void vkDestroySamplerYcbcrConversionKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroySamplerYcbcrConversionKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroySamplerYcbcrConversionKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroySamplerYcbcrConversionKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +VkResult vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkBindBufferMemory2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkBindBufferMemory2KHR); + cmock_call_instance = (CMOCK_vkBindBufferMemory2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkBindBufferMemory2KHR_CallInstance); + Mock.vkBindBufferMemory2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkBindBufferMemory2KHR_CallInstance); + if (Mock.vkBindBufferMemory2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkBindBufferMemory2KHR_FinalReturn; + memcpy((void*)(&Mock.vkBindBufferMemory2KHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkBindBufferMemory2KHR_CallbackBool && + Mock.vkBindBufferMemory2KHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkBindBufferMemory2KHR_CallbackFunctionPointer(device, bindInfoCount, pBindInfos, Mock.vkBindBufferMemory2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkBindBufferMemory2KHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_bindInfoCount) + { + UNITY_SET_DETAILS(CMockString_vkBindBufferMemory2KHR,CMockString_bindInfoCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_bindInfoCount, bindInfoCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pBindInfos) + { + UNITY_SET_DETAILS(CMockString_vkBindBufferMemory2KHR,CMockString_pBindInfos); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pBindInfos), (void*)(pBindInfos), sizeof(const VkBindBufferMemoryInfo), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkBindBufferMemory2KHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkBindBufferMemory2KHR_CallbackFunctionPointer(device, bindInfoCount, pBindInfos, Mock.vkBindBufferMemory2KHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkBindBufferMemory2KHR(CMOCK_vkBindBufferMemory2KHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); +void CMockExpectParameters_vkBindBufferMemory2KHR(CMOCK_vkBindBufferMemory2KHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_bindInfoCount = bindInfoCount; + cmock_call_instance->IgnoreArg_bindInfoCount = 0; + cmock_call_instance->Expected_pBindInfos = pBindInfos; + cmock_call_instance->IgnoreArg_pBindInfos = 0; +} + +void vkBindBufferMemory2KHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBindBufferMemory2KHR_CALL_INSTANCE)); + CMOCK_vkBindBufferMemory2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindBufferMemory2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBindBufferMemory2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkBindBufferMemory2KHR_CallInstance, cmock_guts_index); + Mock.vkBindBufferMemory2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkBindBufferMemory2KHR_IgnoreBool = (char)1; +} + +void vkBindBufferMemory2KHR_CMockStopIgnore(void) +{ + if(Mock.vkBindBufferMemory2KHR_IgnoreBool) + Mock.vkBindBufferMemory2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkBindBufferMemory2KHR_CallInstance); + Mock.vkBindBufferMemory2KHR_IgnoreBool = (char)0; +} + +void vkBindBufferMemory2KHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBindBufferMemory2KHR_CALL_INSTANCE)); + CMOCK_vkBindBufferMemory2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindBufferMemory2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBindBufferMemory2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkBindBufferMemory2KHR_CallInstance, cmock_guts_index); + Mock.vkBindBufferMemory2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkBindBufferMemory2KHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBindBufferMemory2KHR_CALL_INSTANCE)); + CMOCK_vkBindBufferMemory2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindBufferMemory2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBindBufferMemory2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkBindBufferMemory2KHR_CallInstance, cmock_guts_index); + Mock.vkBindBufferMemory2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkBindBufferMemory2KHR(cmock_call_instance, device, bindInfoCount, pBindInfos); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkBindBufferMemory2KHR_AddCallback(CMOCK_vkBindBufferMemory2KHR_CALLBACK Callback) +{ + Mock.vkBindBufferMemory2KHR_IgnoreBool = (char)0; + Mock.vkBindBufferMemory2KHR_CallbackBool = (char)1; + Mock.vkBindBufferMemory2KHR_CallbackFunctionPointer = Callback; +} + +void vkBindBufferMemory2KHR_Stub(CMOCK_vkBindBufferMemory2KHR_CALLBACK Callback) +{ + Mock.vkBindBufferMemory2KHR_IgnoreBool = (char)0; + Mock.vkBindBufferMemory2KHR_CallbackBool = (char)0; + Mock.vkBindBufferMemory2KHR_CallbackFunctionPointer = Callback; +} + +void vkBindBufferMemory2KHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindBufferMemory2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindBufferMemory2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindBufferMemory2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkBindBufferMemory2KHR_CMockIgnoreArg_bindInfoCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindBufferMemory2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindBufferMemory2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindBufferMemory2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_bindInfoCount = 1; +} + +void vkBindBufferMemory2KHR_CMockIgnoreArg_pBindInfos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindBufferMemory2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindBufferMemory2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindBufferMemory2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pBindInfos = 1; +} + +VkResult vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkBindImageMemory2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkBindImageMemory2KHR); + cmock_call_instance = (CMOCK_vkBindImageMemory2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkBindImageMemory2KHR_CallInstance); + Mock.vkBindImageMemory2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkBindImageMemory2KHR_CallInstance); + if (Mock.vkBindImageMemory2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkBindImageMemory2KHR_FinalReturn; + memcpy((void*)(&Mock.vkBindImageMemory2KHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkBindImageMemory2KHR_CallbackBool && + Mock.vkBindImageMemory2KHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkBindImageMemory2KHR_CallbackFunctionPointer(device, bindInfoCount, pBindInfos, Mock.vkBindImageMemory2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkBindImageMemory2KHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_bindInfoCount) + { + UNITY_SET_DETAILS(CMockString_vkBindImageMemory2KHR,CMockString_bindInfoCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_bindInfoCount, bindInfoCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pBindInfos) + { + UNITY_SET_DETAILS(CMockString_vkBindImageMemory2KHR,CMockString_pBindInfos); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pBindInfos), (void*)(pBindInfos), sizeof(const VkBindImageMemoryInfo), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkBindImageMemory2KHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkBindImageMemory2KHR_CallbackFunctionPointer(device, bindInfoCount, pBindInfos, Mock.vkBindImageMemory2KHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkBindImageMemory2KHR(CMOCK_vkBindImageMemory2KHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); +void CMockExpectParameters_vkBindImageMemory2KHR(CMOCK_vkBindImageMemory2KHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_bindInfoCount = bindInfoCount; + cmock_call_instance->IgnoreArg_bindInfoCount = 0; + cmock_call_instance->Expected_pBindInfos = pBindInfos; + cmock_call_instance->IgnoreArg_pBindInfos = 0; +} + +void vkBindImageMemory2KHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBindImageMemory2KHR_CALL_INSTANCE)); + CMOCK_vkBindImageMemory2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindImageMemory2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBindImageMemory2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkBindImageMemory2KHR_CallInstance, cmock_guts_index); + Mock.vkBindImageMemory2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkBindImageMemory2KHR_IgnoreBool = (char)1; +} + +void vkBindImageMemory2KHR_CMockStopIgnore(void) +{ + if(Mock.vkBindImageMemory2KHR_IgnoreBool) + Mock.vkBindImageMemory2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkBindImageMemory2KHR_CallInstance); + Mock.vkBindImageMemory2KHR_IgnoreBool = (char)0; +} + +void vkBindImageMemory2KHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBindImageMemory2KHR_CALL_INSTANCE)); + CMOCK_vkBindImageMemory2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindImageMemory2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBindImageMemory2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkBindImageMemory2KHR_CallInstance, cmock_guts_index); + Mock.vkBindImageMemory2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkBindImageMemory2KHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBindImageMemory2KHR_CALL_INSTANCE)); + CMOCK_vkBindImageMemory2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindImageMemory2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBindImageMemory2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkBindImageMemory2KHR_CallInstance, cmock_guts_index); + Mock.vkBindImageMemory2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkBindImageMemory2KHR(cmock_call_instance, device, bindInfoCount, pBindInfos); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkBindImageMemory2KHR_AddCallback(CMOCK_vkBindImageMemory2KHR_CALLBACK Callback) +{ + Mock.vkBindImageMemory2KHR_IgnoreBool = (char)0; + Mock.vkBindImageMemory2KHR_CallbackBool = (char)1; + Mock.vkBindImageMemory2KHR_CallbackFunctionPointer = Callback; +} + +void vkBindImageMemory2KHR_Stub(CMOCK_vkBindImageMemory2KHR_CALLBACK Callback) +{ + Mock.vkBindImageMemory2KHR_IgnoreBool = (char)0; + Mock.vkBindImageMemory2KHR_CallbackBool = (char)0; + Mock.vkBindImageMemory2KHR_CallbackFunctionPointer = Callback; +} + +void vkBindImageMemory2KHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindImageMemory2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindImageMemory2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindImageMemory2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkBindImageMemory2KHR_CMockIgnoreArg_bindInfoCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindImageMemory2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindImageMemory2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindImageMemory2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_bindInfoCount = 1; +} + +void vkBindImageMemory2KHR_CMockIgnoreArg_pBindInfos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindImageMemory2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindImageMemory2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindImageMemory2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pBindInfos = 1; +} + +void vkGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDescriptorSetLayoutSupportKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDescriptorSetLayoutSupportKHR); + cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutSupportKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDescriptorSetLayoutSupportKHR_CallInstance); + Mock.vkGetDescriptorSetLayoutSupportKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetDescriptorSetLayoutSupportKHR_CallInstance); + if (Mock.vkGetDescriptorSetLayoutSupportKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetDescriptorSetLayoutSupportKHR_CallbackBool && + Mock.vkGetDescriptorSetLayoutSupportKHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetDescriptorSetLayoutSupportKHR_CallbackFunctionPointer(device, pCreateInfo, pSupport, Mock.vkGetDescriptorSetLayoutSupportKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetDescriptorSetLayoutSupportKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetDescriptorSetLayoutSupportKHR,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkDescriptorSetLayoutCreateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSupport) + { + UNITY_SET_DETAILS(CMockString_vkGetDescriptorSetLayoutSupportKHR,CMockString_pSupport); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSupport), (void*)(pSupport), sizeof(VkDescriptorSetLayoutSupport), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDescriptorSetLayoutSupportKHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetDescriptorSetLayoutSupportKHR_CallbackFunctionPointer(device, pCreateInfo, pSupport, Mock.vkGetDescriptorSetLayoutSupportKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pSupport_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSupport, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSupport, (const void*)cmock_call_instance->ReturnThruPtr_pSupport_Val, + cmock_call_instance->ReturnThruPtr_pSupport_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetDescriptorSetLayoutSupportKHR(CMOCK_vkGetDescriptorSetLayoutSupportKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); +void CMockExpectParameters_vkGetDescriptorSetLayoutSupportKHR(CMOCK_vkGetDescriptorSetLayoutSupportKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pSupport = pSupport; + cmock_call_instance->IgnoreArg_pSupport = 0; + cmock_call_instance->ReturnThruPtr_pSupport_Used = 0; +} + +void vkGetDescriptorSetLayoutSupportKHR_CMockIgnore(void) +{ + Mock.vkGetDescriptorSetLayoutSupportKHR_IgnoreBool = (char)1; +} + +void vkGetDescriptorSetLayoutSupportKHR_CMockStopIgnore(void) +{ + Mock.vkGetDescriptorSetLayoutSupportKHR_IgnoreBool = (char)0; +} + +void vkGetDescriptorSetLayoutSupportKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDescriptorSetLayoutSupportKHR_CALL_INSTANCE)); + CMOCK_vkGetDescriptorSetLayoutSupportKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutSupportKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDescriptorSetLayoutSupportKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDescriptorSetLayoutSupportKHR_CallInstance, cmock_guts_index); + Mock.vkGetDescriptorSetLayoutSupportKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDescriptorSetLayoutSupportKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDescriptorSetLayoutSupportKHR_CALL_INSTANCE)); + CMOCK_vkGetDescriptorSetLayoutSupportKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutSupportKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDescriptorSetLayoutSupportKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDescriptorSetLayoutSupportKHR_CallInstance, cmock_guts_index); + Mock.vkGetDescriptorSetLayoutSupportKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDescriptorSetLayoutSupportKHR(cmock_call_instance, device, pCreateInfo, pSupport); +} + +void vkGetDescriptorSetLayoutSupportKHR_AddCallback(CMOCK_vkGetDescriptorSetLayoutSupportKHR_CALLBACK Callback) +{ + Mock.vkGetDescriptorSetLayoutSupportKHR_IgnoreBool = (char)0; + Mock.vkGetDescriptorSetLayoutSupportKHR_CallbackBool = (char)1; + Mock.vkGetDescriptorSetLayoutSupportKHR_CallbackFunctionPointer = Callback; +} + +void vkGetDescriptorSetLayoutSupportKHR_Stub(CMOCK_vkGetDescriptorSetLayoutSupportKHR_CALLBACK Callback) +{ + Mock.vkGetDescriptorSetLayoutSupportKHR_IgnoreBool = (char)0; + Mock.vkGetDescriptorSetLayoutSupportKHR_CallbackBool = (char)0; + Mock.vkGetDescriptorSetLayoutSupportKHR_CallbackFunctionPointer = Callback; +} + +void vkGetDescriptorSetLayoutSupportKHR_CMockReturnMemThruPtr_pSupport(UNITY_LINE_TYPE cmock_line, VkDescriptorSetLayoutSupport const* pSupport, size_t cmock_size) +{ + CMOCK_vkGetDescriptorSetLayoutSupportKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutSupportKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDescriptorSetLayoutSupportKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSupport_Used = 1; + cmock_call_instance->ReturnThruPtr_pSupport_Val = pSupport; + cmock_call_instance->ReturnThruPtr_pSupport_Size = cmock_size; +} + +void vkGetDescriptorSetLayoutSupportKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDescriptorSetLayoutSupportKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutSupportKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDescriptorSetLayoutSupportKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetDescriptorSetLayoutSupportKHR_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDescriptorSetLayoutSupportKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutSupportKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDescriptorSetLayoutSupportKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkGetDescriptorSetLayoutSupportKHR_CMockIgnoreArg_pSupport(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDescriptorSetLayoutSupportKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutSupportKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDescriptorSetLayoutSupportKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSupport = 1; +} + +void vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDrawIndirectCountKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDrawIndirectCountKHR); + cmock_call_instance = (CMOCK_vkCmdDrawIndirectCountKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDrawIndirectCountKHR_CallInstance); + Mock.vkCmdDrawIndirectCountKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDrawIndirectCountKHR_CallInstance); + if (Mock.vkCmdDrawIndirectCountKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDrawIndirectCountKHR_CallbackBool && + Mock.vkCmdDrawIndirectCountKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawIndirectCountKHR_CallbackFunctionPointer(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, Mock.vkCmdDrawIndirectCountKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirectCountKHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_buffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirectCountKHR,CMockString_buffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_offset) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirectCountKHR,CMockString_offset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_countBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirectCountKHR,CMockString_countBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_countBuffer), (void*)(&countBuffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_countBufferOffset) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirectCountKHR,CMockString_countBufferOffset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_countBufferOffset), (void*)(&countBufferOffset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_maxDrawCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirectCountKHR,CMockString_maxDrawCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_maxDrawCount, maxDrawCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_stride) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirectCountKHR,CMockString_stride); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_stride, stride, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdDrawIndirectCountKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawIndirectCountKHR_CallbackFunctionPointer(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, Mock.vkCmdDrawIndirectCountKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDrawIndirectCountKHR(CMOCK_vkCmdDrawIndirectCountKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +void CMockExpectParameters_vkCmdDrawIndirectCountKHR(CMOCK_vkCmdDrawIndirectCountKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), + sizeof(VkBuffer[sizeof(buffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_buffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), + sizeof(VkDeviceSize[sizeof(offset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_offset = 0; + memcpy((void*)(&cmock_call_instance->Expected_countBuffer), (void*)(&countBuffer), + sizeof(VkBuffer[sizeof(countBuffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_countBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_countBufferOffset), (void*)(&countBufferOffset), + sizeof(VkDeviceSize[sizeof(countBufferOffset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_countBufferOffset = 0; + cmock_call_instance->Expected_maxDrawCount = maxDrawCount; + cmock_call_instance->IgnoreArg_maxDrawCount = 0; + cmock_call_instance->Expected_stride = stride; + cmock_call_instance->IgnoreArg_stride = 0; +} + +void vkCmdDrawIndirectCountKHR_CMockIgnore(void) +{ + Mock.vkCmdDrawIndirectCountKHR_IgnoreBool = (char)1; +} + +void vkCmdDrawIndirectCountKHR_CMockStopIgnore(void) +{ + Mock.vkCmdDrawIndirectCountKHR_IgnoreBool = (char)0; +} + +void vkCmdDrawIndirectCountKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawIndirectCountKHR_CALL_INSTANCE)); + CMOCK_vkCmdDrawIndirectCountKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectCountKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawIndirectCountKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawIndirectCountKHR_CallInstance, cmock_guts_index); + Mock.vkCmdDrawIndirectCountKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDrawIndirectCountKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawIndirectCountKHR_CALL_INSTANCE)); + CMOCK_vkCmdDrawIndirectCountKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectCountKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawIndirectCountKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawIndirectCountKHR_CallInstance, cmock_guts_index); + Mock.vkCmdDrawIndirectCountKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDrawIndirectCountKHR(cmock_call_instance, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); +} + +void vkCmdDrawIndirectCountKHR_AddCallback(CMOCK_vkCmdDrawIndirectCountKHR_CALLBACK Callback) +{ + Mock.vkCmdDrawIndirectCountKHR_IgnoreBool = (char)0; + Mock.vkCmdDrawIndirectCountKHR_CallbackBool = (char)1; + Mock.vkCmdDrawIndirectCountKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawIndirectCountKHR_Stub(CMOCK_vkCmdDrawIndirectCountKHR_CALLBACK Callback) +{ + Mock.vkCmdDrawIndirectCountKHR_IgnoreBool = (char)0; + Mock.vkCmdDrawIndirectCountKHR_CallbackBool = (char)0; + Mock.vkCmdDrawIndirectCountKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawIndirectCountKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirectCountKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectCountKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirectCountKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDrawIndirectCountKHR_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirectCountKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectCountKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirectCountKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_buffer = 1; +} + +void vkCmdDrawIndirectCountKHR_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirectCountKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectCountKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirectCountKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_offset = 1; +} + +void vkCmdDrawIndirectCountKHR_CMockIgnoreArg_countBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirectCountKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectCountKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirectCountKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_countBuffer = 1; +} + +void vkCmdDrawIndirectCountKHR_CMockIgnoreArg_countBufferOffset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirectCountKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectCountKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirectCountKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_countBufferOffset = 1; +} + +void vkCmdDrawIndirectCountKHR_CMockIgnoreArg_maxDrawCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirectCountKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectCountKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirectCountKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_maxDrawCount = 1; +} + +void vkCmdDrawIndirectCountKHR_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirectCountKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectCountKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirectCountKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stride = 1; +} + +void vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDrawIndexedIndirectCountKHR); + cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDrawIndexedIndirectCountKHR_CallInstance); + Mock.vkCmdDrawIndexedIndirectCountKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDrawIndexedIndirectCountKHR_CallInstance); + if (Mock.vkCmdDrawIndexedIndirectCountKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDrawIndexedIndirectCountKHR_CallbackBool && + Mock.vkCmdDrawIndexedIndirectCountKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawIndexedIndirectCountKHR_CallbackFunctionPointer(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, Mock.vkCmdDrawIndexedIndirectCountKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexedIndirectCountKHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_buffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexedIndirectCountKHR,CMockString_buffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_offset) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexedIndirectCountKHR,CMockString_offset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_countBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexedIndirectCountKHR,CMockString_countBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_countBuffer), (void*)(&countBuffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_countBufferOffset) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexedIndirectCountKHR,CMockString_countBufferOffset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_countBufferOffset), (void*)(&countBufferOffset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_maxDrawCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexedIndirectCountKHR,CMockString_maxDrawCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_maxDrawCount, maxDrawCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_stride) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexedIndirectCountKHR,CMockString_stride); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_stride, stride, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdDrawIndexedIndirectCountKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawIndexedIndirectCountKHR_CallbackFunctionPointer(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, Mock.vkCmdDrawIndexedIndirectCountKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDrawIndexedIndirectCountKHR(CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +void CMockExpectParameters_vkCmdDrawIndexedIndirectCountKHR(CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), + sizeof(VkBuffer[sizeof(buffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_buffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), + sizeof(VkDeviceSize[sizeof(offset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_offset = 0; + memcpy((void*)(&cmock_call_instance->Expected_countBuffer), (void*)(&countBuffer), + sizeof(VkBuffer[sizeof(countBuffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_countBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_countBufferOffset), (void*)(&countBufferOffset), + sizeof(VkDeviceSize[sizeof(countBufferOffset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_countBufferOffset = 0; + cmock_call_instance->Expected_maxDrawCount = maxDrawCount; + cmock_call_instance->IgnoreArg_maxDrawCount = 0; + cmock_call_instance->Expected_stride = stride; + cmock_call_instance->IgnoreArg_stride = 0; +} + +void vkCmdDrawIndexedIndirectCountKHR_CMockIgnore(void) +{ + Mock.vkCmdDrawIndexedIndirectCountKHR_IgnoreBool = (char)1; +} + +void vkCmdDrawIndexedIndirectCountKHR_CMockStopIgnore(void) +{ + Mock.vkCmdDrawIndexedIndirectCountKHR_IgnoreBool = (char)0; +} + +void vkCmdDrawIndexedIndirectCountKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALL_INSTANCE)); + CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawIndexedIndirectCountKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawIndexedIndirectCountKHR_CallInstance, cmock_guts_index); + Mock.vkCmdDrawIndexedIndirectCountKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDrawIndexedIndirectCountKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALL_INSTANCE)); + CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawIndexedIndirectCountKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawIndexedIndirectCountKHR_CallInstance, cmock_guts_index); + Mock.vkCmdDrawIndexedIndirectCountKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDrawIndexedIndirectCountKHR(cmock_call_instance, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); +} + +void vkCmdDrawIndexedIndirectCountKHR_AddCallback(CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALLBACK Callback) +{ + Mock.vkCmdDrawIndexedIndirectCountKHR_IgnoreBool = (char)0; + Mock.vkCmdDrawIndexedIndirectCountKHR_CallbackBool = (char)1; + Mock.vkCmdDrawIndexedIndirectCountKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawIndexedIndirectCountKHR_Stub(CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALLBACK Callback) +{ + Mock.vkCmdDrawIndexedIndirectCountKHR_IgnoreBool = (char)0; + Mock.vkCmdDrawIndexedIndirectCountKHR_CallbackBool = (char)0; + Mock.vkCmdDrawIndexedIndirectCountKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawIndexedIndirectCountKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexedIndirectCountKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDrawIndexedIndirectCountKHR_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexedIndirectCountKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_buffer = 1; +} + +void vkCmdDrawIndexedIndirectCountKHR_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexedIndirectCountKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_offset = 1; +} + +void vkCmdDrawIndexedIndirectCountKHR_CMockIgnoreArg_countBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexedIndirectCountKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_countBuffer = 1; +} + +void vkCmdDrawIndexedIndirectCountKHR_CMockIgnoreArg_countBufferOffset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexedIndirectCountKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_countBufferOffset = 1; +} + +void vkCmdDrawIndexedIndirectCountKHR_CMockIgnoreArg_maxDrawCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexedIndirectCountKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_maxDrawCount = 1; +} + +void vkCmdDrawIndexedIndirectCountKHR_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexedIndirectCountKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stride = 1; +} + +VkResult vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t* pValue) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetSemaphoreCounterValueKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetSemaphoreCounterValueKHR); + cmock_call_instance = (CMOCK_vkGetSemaphoreCounterValueKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetSemaphoreCounterValueKHR_CallInstance); + Mock.vkGetSemaphoreCounterValueKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetSemaphoreCounterValueKHR_CallInstance); + if (Mock.vkGetSemaphoreCounterValueKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetSemaphoreCounterValueKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetSemaphoreCounterValueKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetSemaphoreCounterValueKHR_CallbackBool && + Mock.vkGetSemaphoreCounterValueKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetSemaphoreCounterValueKHR_CallbackFunctionPointer(device, semaphore, pValue, Mock.vkGetSemaphoreCounterValueKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetSemaphoreCounterValueKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_semaphore) + { + UNITY_SET_DETAILS(CMockString_vkGetSemaphoreCounterValueKHR,CMockString_semaphore); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_semaphore), (void*)(&semaphore), sizeof(VkSemaphore), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pValue) + { + UNITY_SET_DETAILS(CMockString_vkGetSemaphoreCounterValueKHR,CMockString_pValue); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pValue), (void*)(pValue), sizeof(uint64_t), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetSemaphoreCounterValueKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetSemaphoreCounterValueKHR_CallbackFunctionPointer(device, semaphore, pValue, Mock.vkGetSemaphoreCounterValueKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pValue_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pValue, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pValue, (const void*)cmock_call_instance->ReturnThruPtr_pValue_Val, + cmock_call_instance->ReturnThruPtr_pValue_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetSemaphoreCounterValueKHR(CMOCK_vkGetSemaphoreCounterValueKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSemaphore semaphore, uint64_t* pValue); +void CMockExpectParameters_vkGetSemaphoreCounterValueKHR(CMOCK_vkGetSemaphoreCounterValueKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSemaphore semaphore, uint64_t* pValue) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_semaphore), (void*)(&semaphore), + sizeof(VkSemaphore[sizeof(semaphore) == sizeof(VkSemaphore) ? 1 : -1])); /* add VkSemaphore to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_semaphore = 0; + cmock_call_instance->Expected_pValue = pValue; + cmock_call_instance->IgnoreArg_pValue = 0; + cmock_call_instance->ReturnThruPtr_pValue_Used = 0; +} + +void vkGetSemaphoreCounterValueKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetSemaphoreCounterValueKHR_CALL_INSTANCE)); + CMOCK_vkGetSemaphoreCounterValueKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSemaphoreCounterValueKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetSemaphoreCounterValueKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetSemaphoreCounterValueKHR_CallInstance, cmock_guts_index); + Mock.vkGetSemaphoreCounterValueKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetSemaphoreCounterValueKHR_IgnoreBool = (char)1; +} + +void vkGetSemaphoreCounterValueKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetSemaphoreCounterValueKHR_IgnoreBool) + Mock.vkGetSemaphoreCounterValueKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetSemaphoreCounterValueKHR_CallInstance); + Mock.vkGetSemaphoreCounterValueKHR_IgnoreBool = (char)0; +} + +void vkGetSemaphoreCounterValueKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetSemaphoreCounterValueKHR_CALL_INSTANCE)); + CMOCK_vkGetSemaphoreCounterValueKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSemaphoreCounterValueKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetSemaphoreCounterValueKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetSemaphoreCounterValueKHR_CallInstance, cmock_guts_index); + Mock.vkGetSemaphoreCounterValueKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetSemaphoreCounterValueKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSemaphore semaphore, uint64_t* pValue, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetSemaphoreCounterValueKHR_CALL_INSTANCE)); + CMOCK_vkGetSemaphoreCounterValueKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSemaphoreCounterValueKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetSemaphoreCounterValueKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetSemaphoreCounterValueKHR_CallInstance, cmock_guts_index); + Mock.vkGetSemaphoreCounterValueKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetSemaphoreCounterValueKHR(cmock_call_instance, device, semaphore, pValue); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetSemaphoreCounterValueKHR_AddCallback(CMOCK_vkGetSemaphoreCounterValueKHR_CALLBACK Callback) +{ + Mock.vkGetSemaphoreCounterValueKHR_IgnoreBool = (char)0; + Mock.vkGetSemaphoreCounterValueKHR_CallbackBool = (char)1; + Mock.vkGetSemaphoreCounterValueKHR_CallbackFunctionPointer = Callback; +} + +void vkGetSemaphoreCounterValueKHR_Stub(CMOCK_vkGetSemaphoreCounterValueKHR_CALLBACK Callback) +{ + Mock.vkGetSemaphoreCounterValueKHR_IgnoreBool = (char)0; + Mock.vkGetSemaphoreCounterValueKHR_CallbackBool = (char)0; + Mock.vkGetSemaphoreCounterValueKHR_CallbackFunctionPointer = Callback; +} + +void vkGetSemaphoreCounterValueKHR_CMockReturnMemThruPtr_pValue(UNITY_LINE_TYPE cmock_line, uint64_t const* pValue, size_t cmock_size) +{ + CMOCK_vkGetSemaphoreCounterValueKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSemaphoreCounterValueKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetSemaphoreCounterValueKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pValue_Used = 1; + cmock_call_instance->ReturnThruPtr_pValue_Val = pValue; + cmock_call_instance->ReturnThruPtr_pValue_Size = cmock_size; +} + +void vkGetSemaphoreCounterValueKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetSemaphoreCounterValueKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSemaphoreCounterValueKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetSemaphoreCounterValueKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetSemaphoreCounterValueKHR_CMockIgnoreArg_semaphore(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetSemaphoreCounterValueKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSemaphoreCounterValueKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetSemaphoreCounterValueKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_semaphore = 1; +} + +void vkGetSemaphoreCounterValueKHR_CMockIgnoreArg_pValue(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetSemaphoreCounterValueKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSemaphoreCounterValueKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetSemaphoreCounterValueKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pValue = 1; +} + +VkResult vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkWaitSemaphoresKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkWaitSemaphoresKHR); + cmock_call_instance = (CMOCK_vkWaitSemaphoresKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkWaitSemaphoresKHR_CallInstance); + Mock.vkWaitSemaphoresKHR_CallInstance = CMock_Guts_MemNext(Mock.vkWaitSemaphoresKHR_CallInstance); + if (Mock.vkWaitSemaphoresKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkWaitSemaphoresKHR_FinalReturn; + memcpy((void*)(&Mock.vkWaitSemaphoresKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkWaitSemaphoresKHR_CallbackBool && + Mock.vkWaitSemaphoresKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkWaitSemaphoresKHR_CallbackFunctionPointer(device, pWaitInfo, timeout, Mock.vkWaitSemaphoresKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkWaitSemaphoresKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pWaitInfo) + { + UNITY_SET_DETAILS(CMockString_vkWaitSemaphoresKHR,CMockString_pWaitInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pWaitInfo), (void*)(pWaitInfo), sizeof(const VkSemaphoreWaitInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_timeout) + { + UNITY_SET_DETAILS(CMockString_vkWaitSemaphoresKHR,CMockString_timeout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_timeout), (void*)(&timeout), sizeof(uint64_t), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkWaitSemaphoresKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkWaitSemaphoresKHR_CallbackFunctionPointer(device, pWaitInfo, timeout, Mock.vkWaitSemaphoresKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkWaitSemaphoresKHR(CMOCK_vkWaitSemaphoresKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout); +void CMockExpectParameters_vkWaitSemaphoresKHR(CMOCK_vkWaitSemaphoresKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pWaitInfo = pWaitInfo; + cmock_call_instance->IgnoreArg_pWaitInfo = 0; + memcpy((void*)(&cmock_call_instance->Expected_timeout), (void*)(&timeout), + sizeof(uint64_t[sizeof(timeout) == sizeof(uint64_t) ? 1 : -1])); /* add uint64_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_timeout = 0; +} + +void vkWaitSemaphoresKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkWaitSemaphoresKHR_CALL_INSTANCE)); + CMOCK_vkWaitSemaphoresKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWaitSemaphoresKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkWaitSemaphoresKHR_CallInstance = CMock_Guts_MemChain(Mock.vkWaitSemaphoresKHR_CallInstance, cmock_guts_index); + Mock.vkWaitSemaphoresKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkWaitSemaphoresKHR_IgnoreBool = (char)1; +} + +void vkWaitSemaphoresKHR_CMockStopIgnore(void) +{ + if(Mock.vkWaitSemaphoresKHR_IgnoreBool) + Mock.vkWaitSemaphoresKHR_CallInstance = CMock_Guts_MemNext(Mock.vkWaitSemaphoresKHR_CallInstance); + Mock.vkWaitSemaphoresKHR_IgnoreBool = (char)0; +} + +void vkWaitSemaphoresKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkWaitSemaphoresKHR_CALL_INSTANCE)); + CMOCK_vkWaitSemaphoresKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWaitSemaphoresKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkWaitSemaphoresKHR_CallInstance = CMock_Guts_MemChain(Mock.vkWaitSemaphoresKHR_CallInstance, cmock_guts_index); + Mock.vkWaitSemaphoresKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkWaitSemaphoresKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkWaitSemaphoresKHR_CALL_INSTANCE)); + CMOCK_vkWaitSemaphoresKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWaitSemaphoresKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkWaitSemaphoresKHR_CallInstance = CMock_Guts_MemChain(Mock.vkWaitSemaphoresKHR_CallInstance, cmock_guts_index); + Mock.vkWaitSemaphoresKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkWaitSemaphoresKHR(cmock_call_instance, device, pWaitInfo, timeout); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkWaitSemaphoresKHR_AddCallback(CMOCK_vkWaitSemaphoresKHR_CALLBACK Callback) +{ + Mock.vkWaitSemaphoresKHR_IgnoreBool = (char)0; + Mock.vkWaitSemaphoresKHR_CallbackBool = (char)1; + Mock.vkWaitSemaphoresKHR_CallbackFunctionPointer = Callback; +} + +void vkWaitSemaphoresKHR_Stub(CMOCK_vkWaitSemaphoresKHR_CALLBACK Callback) +{ + Mock.vkWaitSemaphoresKHR_IgnoreBool = (char)0; + Mock.vkWaitSemaphoresKHR_CallbackBool = (char)0; + Mock.vkWaitSemaphoresKHR_CallbackFunctionPointer = Callback; +} + +void vkWaitSemaphoresKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkWaitSemaphoresKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWaitSemaphoresKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWaitSemaphoresKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkWaitSemaphoresKHR_CMockIgnoreArg_pWaitInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkWaitSemaphoresKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWaitSemaphoresKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWaitSemaphoresKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pWaitInfo = 1; +} + +void vkWaitSemaphoresKHR_CMockIgnoreArg_timeout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkWaitSemaphoresKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWaitSemaphoresKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWaitSemaphoresKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_timeout = 1; +} + +VkResult vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkSignalSemaphoreKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkSignalSemaphoreKHR); + cmock_call_instance = (CMOCK_vkSignalSemaphoreKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkSignalSemaphoreKHR_CallInstance); + Mock.vkSignalSemaphoreKHR_CallInstance = CMock_Guts_MemNext(Mock.vkSignalSemaphoreKHR_CallInstance); + if (Mock.vkSignalSemaphoreKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkSignalSemaphoreKHR_FinalReturn; + memcpy((void*)(&Mock.vkSignalSemaphoreKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkSignalSemaphoreKHR_CallbackBool && + Mock.vkSignalSemaphoreKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkSignalSemaphoreKHR_CallbackFunctionPointer(device, pSignalInfo, Mock.vkSignalSemaphoreKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkSignalSemaphoreKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSignalInfo) + { + UNITY_SET_DETAILS(CMockString_vkSignalSemaphoreKHR,CMockString_pSignalInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSignalInfo), (void*)(pSignalInfo), sizeof(const VkSemaphoreSignalInfo), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkSignalSemaphoreKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkSignalSemaphoreKHR_CallbackFunctionPointer(device, pSignalInfo, Mock.vkSignalSemaphoreKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkSignalSemaphoreKHR(CMOCK_vkSignalSemaphoreKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo); +void CMockExpectParameters_vkSignalSemaphoreKHR(CMOCK_vkSignalSemaphoreKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pSignalInfo = pSignalInfo; + cmock_call_instance->IgnoreArg_pSignalInfo = 0; +} + +void vkSignalSemaphoreKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkSignalSemaphoreKHR_CALL_INSTANCE)); + CMOCK_vkSignalSemaphoreKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSignalSemaphoreKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkSignalSemaphoreKHR_CallInstance = CMock_Guts_MemChain(Mock.vkSignalSemaphoreKHR_CallInstance, cmock_guts_index); + Mock.vkSignalSemaphoreKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkSignalSemaphoreKHR_IgnoreBool = (char)1; +} + +void vkSignalSemaphoreKHR_CMockStopIgnore(void) +{ + if(Mock.vkSignalSemaphoreKHR_IgnoreBool) + Mock.vkSignalSemaphoreKHR_CallInstance = CMock_Guts_MemNext(Mock.vkSignalSemaphoreKHR_CallInstance); + Mock.vkSignalSemaphoreKHR_IgnoreBool = (char)0; +} + +void vkSignalSemaphoreKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkSignalSemaphoreKHR_CALL_INSTANCE)); + CMOCK_vkSignalSemaphoreKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSignalSemaphoreKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkSignalSemaphoreKHR_CallInstance = CMock_Guts_MemChain(Mock.vkSignalSemaphoreKHR_CallInstance, cmock_guts_index); + Mock.vkSignalSemaphoreKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkSignalSemaphoreKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkSignalSemaphoreKHR_CALL_INSTANCE)); + CMOCK_vkSignalSemaphoreKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSignalSemaphoreKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkSignalSemaphoreKHR_CallInstance = CMock_Guts_MemChain(Mock.vkSignalSemaphoreKHR_CallInstance, cmock_guts_index); + Mock.vkSignalSemaphoreKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkSignalSemaphoreKHR(cmock_call_instance, device, pSignalInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkSignalSemaphoreKHR_AddCallback(CMOCK_vkSignalSemaphoreKHR_CALLBACK Callback) +{ + Mock.vkSignalSemaphoreKHR_IgnoreBool = (char)0; + Mock.vkSignalSemaphoreKHR_CallbackBool = (char)1; + Mock.vkSignalSemaphoreKHR_CallbackFunctionPointer = Callback; +} + +void vkSignalSemaphoreKHR_Stub(CMOCK_vkSignalSemaphoreKHR_CALLBACK Callback) +{ + Mock.vkSignalSemaphoreKHR_IgnoreBool = (char)0; + Mock.vkSignalSemaphoreKHR_CallbackBool = (char)0; + Mock.vkSignalSemaphoreKHR_CallbackFunctionPointer = Callback; +} + +void vkSignalSemaphoreKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSignalSemaphoreKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSignalSemaphoreKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSignalSemaphoreKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkSignalSemaphoreKHR_CMockIgnoreArg_pSignalInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSignalSemaphoreKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSignalSemaphoreKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSignalSemaphoreKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSignalInfo = 1; +} + +VkResult vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceFragmentShadingRatesKHR); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_CallInstance); + Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_CallInstance); + if (Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_CallbackBool && + Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_CallbackFunctionPointer(physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates, Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceFragmentShadingRatesKHR,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pFragmentShadingRateCount) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceFragmentShadingRatesKHR,CMockString_pFragmentShadingRateCount); + if (cmock_call_instance->Expected_pFragmentShadingRateCount == NULL) + { UNITY_TEST_ASSERT_NULL(pFragmentShadingRateCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pFragmentShadingRateCount, pFragmentShadingRateCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pFragmentShadingRates) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceFragmentShadingRatesKHR,CMockString_pFragmentShadingRates); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pFragmentShadingRates), (void*)(pFragmentShadingRates), sizeof(VkPhysicalDeviceFragmentShadingRateKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_CallbackFunctionPointer(physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates, Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pFragmentShadingRateCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pFragmentShadingRateCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pFragmentShadingRateCount, (const void*)cmock_call_instance->ReturnThruPtr_pFragmentShadingRateCount_Val, + cmock_call_instance->ReturnThruPtr_pFragmentShadingRateCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pFragmentShadingRates_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pFragmentShadingRates, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pFragmentShadingRates, (const void*)cmock_call_instance->ReturnThruPtr_pFragmentShadingRates_Val, + cmock_call_instance->ReturnThruPtr_pFragmentShadingRates_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPhysicalDeviceFragmentShadingRatesKHR(CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates); +void CMockExpectParameters_vkGetPhysicalDeviceFragmentShadingRatesKHR(CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pFragmentShadingRateCount = pFragmentShadingRateCount; + cmock_call_instance->IgnoreArg_pFragmentShadingRateCount = 0; + cmock_call_instance->ReturnThruPtr_pFragmentShadingRateCount_Used = 0; + cmock_call_instance->Expected_pFragmentShadingRates = pFragmentShadingRates; + cmock_call_instance->IgnoreArg_pFragmentShadingRates = 0; + cmock_call_instance->ReturnThruPtr_pFragmentShadingRates_Used = 0; +} + +void vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_IgnoreBool) + Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_CallInstance); + Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceFragmentShadingRatesKHR(cmock_call_instance, physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPhysicalDeviceFragmentShadingRatesKHR_AddCallback(CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceFragmentShadingRatesKHR_Stub(CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockReturnMemThruPtr_pFragmentShadingRateCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pFragmentShadingRateCount, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pFragmentShadingRateCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pFragmentShadingRateCount_Val = pFragmentShadingRateCount; + cmock_call_instance->ReturnThruPtr_pFragmentShadingRateCount_Size = cmock_size; +} + +void vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockReturnMemThruPtr_pFragmentShadingRates(UNITY_LINE_TYPE cmock_line, VkPhysicalDeviceFragmentShadingRateKHR const* pFragmentShadingRates, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pFragmentShadingRates_Used = 1; + cmock_call_instance->ReturnThruPtr_pFragmentShadingRates_Val = pFragmentShadingRates; + cmock_call_instance->ReturnThruPtr_pFragmentShadingRates_Size = cmock_size; +} + +void vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockIgnoreArg_pFragmentShadingRateCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pFragmentShadingRateCount = 1; +} + +void vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockIgnoreArg_pFragmentShadingRates(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceFragmentShadingRatesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pFragmentShadingRates = 1; +} + +void vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetFragmentShadingRateKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetFragmentShadingRateKHR); + cmock_call_instance = (CMOCK_vkCmdSetFragmentShadingRateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetFragmentShadingRateKHR_CallInstance); + Mock.vkCmdSetFragmentShadingRateKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetFragmentShadingRateKHR_CallInstance); + if (Mock.vkCmdSetFragmentShadingRateKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetFragmentShadingRateKHR_CallbackBool && + Mock.vkCmdSetFragmentShadingRateKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetFragmentShadingRateKHR_CallbackFunctionPointer(commandBuffer, pFragmentSize, combinerOps, Mock.vkCmdSetFragmentShadingRateKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetFragmentShadingRateKHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pFragmentSize) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetFragmentShadingRateKHR,CMockString_pFragmentSize); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pFragmentSize), (void*)(pFragmentSize), sizeof(const VkExtent2D), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_combinerOps) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetFragmentShadingRateKHR,CMockString_combinerOps); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_combinerOps), (void*)(combinerOps), sizeof(const VkFragmentShadingRateCombinerOpKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetFragmentShadingRateKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetFragmentShadingRateKHR_CallbackFunctionPointer(commandBuffer, pFragmentSize, combinerOps, Mock.vkCmdSetFragmentShadingRateKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetFragmentShadingRateKHR(CMOCK_vkCmdSetFragmentShadingRateKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR* combinerOps); +void CMockExpectParameters_vkCmdSetFragmentShadingRateKHR(CMOCK_vkCmdSetFragmentShadingRateKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR* combinerOps) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pFragmentSize = pFragmentSize; + cmock_call_instance->IgnoreArg_pFragmentSize = 0; + cmock_call_instance->Expected_combinerOps = combinerOps; + cmock_call_instance->IgnoreArg_combinerOps = 0; +} + +void vkCmdSetFragmentShadingRateKHR_CMockIgnore(void) +{ + Mock.vkCmdSetFragmentShadingRateKHR_IgnoreBool = (char)1; +} + +void vkCmdSetFragmentShadingRateKHR_CMockStopIgnore(void) +{ + Mock.vkCmdSetFragmentShadingRateKHR_IgnoreBool = (char)0; +} + +void vkCmdSetFragmentShadingRateKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetFragmentShadingRateKHR_CALL_INSTANCE)); + CMOCK_vkCmdSetFragmentShadingRateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetFragmentShadingRateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetFragmentShadingRateKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetFragmentShadingRateKHR_CallInstance, cmock_guts_index); + Mock.vkCmdSetFragmentShadingRateKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetFragmentShadingRateKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR* combinerOps) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetFragmentShadingRateKHR_CALL_INSTANCE)); + CMOCK_vkCmdSetFragmentShadingRateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetFragmentShadingRateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetFragmentShadingRateKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetFragmentShadingRateKHR_CallInstance, cmock_guts_index); + Mock.vkCmdSetFragmentShadingRateKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetFragmentShadingRateKHR(cmock_call_instance, commandBuffer, pFragmentSize, combinerOps); +} + +void vkCmdSetFragmentShadingRateKHR_AddCallback(CMOCK_vkCmdSetFragmentShadingRateKHR_CALLBACK Callback) +{ + Mock.vkCmdSetFragmentShadingRateKHR_IgnoreBool = (char)0; + Mock.vkCmdSetFragmentShadingRateKHR_CallbackBool = (char)1; + Mock.vkCmdSetFragmentShadingRateKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdSetFragmentShadingRateKHR_Stub(CMOCK_vkCmdSetFragmentShadingRateKHR_CALLBACK Callback) +{ + Mock.vkCmdSetFragmentShadingRateKHR_IgnoreBool = (char)0; + Mock.vkCmdSetFragmentShadingRateKHR_CallbackBool = (char)0; + Mock.vkCmdSetFragmentShadingRateKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdSetFragmentShadingRateKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetFragmentShadingRateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetFragmentShadingRateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetFragmentShadingRateKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetFragmentShadingRateKHR_CMockIgnoreArg_pFragmentSize(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetFragmentShadingRateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetFragmentShadingRateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetFragmentShadingRateKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pFragmentSize = 1; +} + +void vkCmdSetFragmentShadingRateKHR_CMockIgnoreArg_combinerOps(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetFragmentShadingRateKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetFragmentShadingRateKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetFragmentShadingRateKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_combinerOps = 1; +} + +VkResult vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkWaitForPresentKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkWaitForPresentKHR); + cmock_call_instance = (CMOCK_vkWaitForPresentKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkWaitForPresentKHR_CallInstance); + Mock.vkWaitForPresentKHR_CallInstance = CMock_Guts_MemNext(Mock.vkWaitForPresentKHR_CallInstance); + if (Mock.vkWaitForPresentKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkWaitForPresentKHR_FinalReturn; + memcpy((void*)(&Mock.vkWaitForPresentKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkWaitForPresentKHR_CallbackBool && + Mock.vkWaitForPresentKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkWaitForPresentKHR_CallbackFunctionPointer(device, swapchain, presentId, timeout, Mock.vkWaitForPresentKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkWaitForPresentKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_swapchain) + { + UNITY_SET_DETAILS(CMockString_vkWaitForPresentKHR,CMockString_swapchain); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_swapchain), (void*)(&swapchain), sizeof(VkSwapchainKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_presentId) + { + UNITY_SET_DETAILS(CMockString_vkWaitForPresentKHR,CMockString_presentId); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_presentId), (void*)(&presentId), sizeof(uint64_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_timeout) + { + UNITY_SET_DETAILS(CMockString_vkWaitForPresentKHR,CMockString_timeout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_timeout), (void*)(&timeout), sizeof(uint64_t), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkWaitForPresentKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkWaitForPresentKHR_CallbackFunctionPointer(device, swapchain, presentId, timeout, Mock.vkWaitForPresentKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkWaitForPresentKHR(CMOCK_vkWaitForPresentKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout); +void CMockExpectParameters_vkWaitForPresentKHR(CMOCK_vkWaitForPresentKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_swapchain), (void*)(&swapchain), + sizeof(VkSwapchainKHR[sizeof(swapchain) == sizeof(VkSwapchainKHR) ? 1 : -1])); /* add VkSwapchainKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_swapchain = 0; + memcpy((void*)(&cmock_call_instance->Expected_presentId), (void*)(&presentId), + sizeof(uint64_t[sizeof(presentId) == sizeof(uint64_t) ? 1 : -1])); /* add uint64_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_presentId = 0; + memcpy((void*)(&cmock_call_instance->Expected_timeout), (void*)(&timeout), + sizeof(uint64_t[sizeof(timeout) == sizeof(uint64_t) ? 1 : -1])); /* add uint64_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_timeout = 0; +} + +void vkWaitForPresentKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkWaitForPresentKHR_CALL_INSTANCE)); + CMOCK_vkWaitForPresentKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWaitForPresentKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkWaitForPresentKHR_CallInstance = CMock_Guts_MemChain(Mock.vkWaitForPresentKHR_CallInstance, cmock_guts_index); + Mock.vkWaitForPresentKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkWaitForPresentKHR_IgnoreBool = (char)1; +} + +void vkWaitForPresentKHR_CMockStopIgnore(void) +{ + if(Mock.vkWaitForPresentKHR_IgnoreBool) + Mock.vkWaitForPresentKHR_CallInstance = CMock_Guts_MemNext(Mock.vkWaitForPresentKHR_CallInstance); + Mock.vkWaitForPresentKHR_IgnoreBool = (char)0; +} + +void vkWaitForPresentKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkWaitForPresentKHR_CALL_INSTANCE)); + CMOCK_vkWaitForPresentKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWaitForPresentKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkWaitForPresentKHR_CallInstance = CMock_Guts_MemChain(Mock.vkWaitForPresentKHR_CallInstance, cmock_guts_index); + Mock.vkWaitForPresentKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkWaitForPresentKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkWaitForPresentKHR_CALL_INSTANCE)); + CMOCK_vkWaitForPresentKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWaitForPresentKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkWaitForPresentKHR_CallInstance = CMock_Guts_MemChain(Mock.vkWaitForPresentKHR_CallInstance, cmock_guts_index); + Mock.vkWaitForPresentKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkWaitForPresentKHR(cmock_call_instance, device, swapchain, presentId, timeout); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkWaitForPresentKHR_AddCallback(CMOCK_vkWaitForPresentKHR_CALLBACK Callback) +{ + Mock.vkWaitForPresentKHR_IgnoreBool = (char)0; + Mock.vkWaitForPresentKHR_CallbackBool = (char)1; + Mock.vkWaitForPresentKHR_CallbackFunctionPointer = Callback; +} + +void vkWaitForPresentKHR_Stub(CMOCK_vkWaitForPresentKHR_CALLBACK Callback) +{ + Mock.vkWaitForPresentKHR_IgnoreBool = (char)0; + Mock.vkWaitForPresentKHR_CallbackBool = (char)0; + Mock.vkWaitForPresentKHR_CallbackFunctionPointer = Callback; +} + +void vkWaitForPresentKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkWaitForPresentKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWaitForPresentKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWaitForPresentKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkWaitForPresentKHR_CMockIgnoreArg_swapchain(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkWaitForPresentKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWaitForPresentKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWaitForPresentKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_swapchain = 1; +} + +void vkWaitForPresentKHR_CMockIgnoreArg_presentId(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkWaitForPresentKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWaitForPresentKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWaitForPresentKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_presentId = 1; +} + +void vkWaitForPresentKHR_CMockIgnoreArg_timeout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkWaitForPresentKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWaitForPresentKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWaitForPresentKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_timeout = 1; +} + +VkDeviceAddress vkGetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetBufferDeviceAddressKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetBufferDeviceAddressKHR); + cmock_call_instance = (CMOCK_vkGetBufferDeviceAddressKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetBufferDeviceAddressKHR_CallInstance); + Mock.vkGetBufferDeviceAddressKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetBufferDeviceAddressKHR_CallInstance); + if (Mock.vkGetBufferDeviceAddressKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetBufferDeviceAddressKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetBufferDeviceAddressKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkDeviceAddress[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkDeviceAddress) ? 1 : -1])); /* add VkDeviceAddress to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetBufferDeviceAddressKHR_CallbackBool && + Mock.vkGetBufferDeviceAddressKHR_CallbackFunctionPointer != NULL) + { + VkDeviceAddress cmock_cb_ret = Mock.vkGetBufferDeviceAddressKHR_CallbackFunctionPointer(device, pInfo, Mock.vkGetBufferDeviceAddressKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetBufferDeviceAddressKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetBufferDeviceAddressKHR,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkBufferDeviceAddressInfo), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetBufferDeviceAddressKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetBufferDeviceAddressKHR_CallbackFunctionPointer(device, pInfo, Mock.vkGetBufferDeviceAddressKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetBufferDeviceAddressKHR(CMOCK_vkGetBufferDeviceAddressKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkBufferDeviceAddressInfo* pInfo); +void CMockExpectParameters_vkGetBufferDeviceAddressKHR(CMOCK_vkGetBufferDeviceAddressKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkBufferDeviceAddressInfo* pInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; +} + +void vkGetBufferDeviceAddressKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkDeviceAddress cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetBufferDeviceAddressKHR_CALL_INSTANCE)); + CMOCK_vkGetBufferDeviceAddressKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferDeviceAddressKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetBufferDeviceAddressKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetBufferDeviceAddressKHR_CallInstance, cmock_guts_index); + Mock.vkGetBufferDeviceAddressKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetBufferDeviceAddressKHR_IgnoreBool = (char)1; +} + +void vkGetBufferDeviceAddressKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetBufferDeviceAddressKHR_IgnoreBool) + Mock.vkGetBufferDeviceAddressKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetBufferDeviceAddressKHR_CallInstance); + Mock.vkGetBufferDeviceAddressKHR_IgnoreBool = (char)0; +} + +void vkGetBufferDeviceAddressKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkDeviceAddress cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetBufferDeviceAddressKHR_CALL_INSTANCE)); + CMOCK_vkGetBufferDeviceAddressKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferDeviceAddressKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetBufferDeviceAddressKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetBufferDeviceAddressKHR_CallInstance, cmock_guts_index); + Mock.vkGetBufferDeviceAddressKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetBufferDeviceAddressKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkBufferDeviceAddressInfo* pInfo, VkDeviceAddress cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetBufferDeviceAddressKHR_CALL_INSTANCE)); + CMOCK_vkGetBufferDeviceAddressKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferDeviceAddressKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetBufferDeviceAddressKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetBufferDeviceAddressKHR_CallInstance, cmock_guts_index); + Mock.vkGetBufferDeviceAddressKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetBufferDeviceAddressKHR(cmock_call_instance, device, pInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkDeviceAddress[sizeof(cmock_to_return) == sizeof(VkDeviceAddress) ? 1 : -1])); /* add VkDeviceAddress to :treat_as_array if this causes an error */ +} + +void vkGetBufferDeviceAddressKHR_AddCallback(CMOCK_vkGetBufferDeviceAddressKHR_CALLBACK Callback) +{ + Mock.vkGetBufferDeviceAddressKHR_IgnoreBool = (char)0; + Mock.vkGetBufferDeviceAddressKHR_CallbackBool = (char)1; + Mock.vkGetBufferDeviceAddressKHR_CallbackFunctionPointer = Callback; +} + +void vkGetBufferDeviceAddressKHR_Stub(CMOCK_vkGetBufferDeviceAddressKHR_CALLBACK Callback) +{ + Mock.vkGetBufferDeviceAddressKHR_IgnoreBool = (char)0; + Mock.vkGetBufferDeviceAddressKHR_CallbackBool = (char)0; + Mock.vkGetBufferDeviceAddressKHR_CallbackFunctionPointer = Callback; +} + +void vkGetBufferDeviceAddressKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetBufferDeviceAddressKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferDeviceAddressKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetBufferDeviceAddressKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetBufferDeviceAddressKHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetBufferDeviceAddressKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferDeviceAddressKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetBufferDeviceAddressKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +uint64_t vkGetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetBufferOpaqueCaptureAddressKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetBufferOpaqueCaptureAddressKHR); + cmock_call_instance = (CMOCK_vkGetBufferOpaqueCaptureAddressKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetBufferOpaqueCaptureAddressKHR_CallInstance); + Mock.vkGetBufferOpaqueCaptureAddressKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetBufferOpaqueCaptureAddressKHR_CallInstance); + if (Mock.vkGetBufferOpaqueCaptureAddressKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetBufferOpaqueCaptureAddressKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetBufferOpaqueCaptureAddressKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(uint64_t[sizeof(cmock_call_instance->ReturnVal) == sizeof(uint64_t) ? 1 : -1])); /* add uint64_t to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetBufferOpaqueCaptureAddressKHR_CallbackBool && + Mock.vkGetBufferOpaqueCaptureAddressKHR_CallbackFunctionPointer != NULL) + { + uint64_t cmock_cb_ret = Mock.vkGetBufferOpaqueCaptureAddressKHR_CallbackFunctionPointer(device, pInfo, Mock.vkGetBufferOpaqueCaptureAddressKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetBufferOpaqueCaptureAddressKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetBufferOpaqueCaptureAddressKHR,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkBufferDeviceAddressInfo), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetBufferOpaqueCaptureAddressKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetBufferOpaqueCaptureAddressKHR_CallbackFunctionPointer(device, pInfo, Mock.vkGetBufferOpaqueCaptureAddressKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetBufferOpaqueCaptureAddressKHR(CMOCK_vkGetBufferOpaqueCaptureAddressKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkBufferDeviceAddressInfo* pInfo); +void CMockExpectParameters_vkGetBufferOpaqueCaptureAddressKHR(CMOCK_vkGetBufferOpaqueCaptureAddressKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkBufferDeviceAddressInfo* pInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; +} + +void vkGetBufferOpaqueCaptureAddressKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, uint64_t cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetBufferOpaqueCaptureAddressKHR_CALL_INSTANCE)); + CMOCK_vkGetBufferOpaqueCaptureAddressKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferOpaqueCaptureAddressKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetBufferOpaqueCaptureAddressKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetBufferOpaqueCaptureAddressKHR_CallInstance, cmock_guts_index); + Mock.vkGetBufferOpaqueCaptureAddressKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetBufferOpaqueCaptureAddressKHR_IgnoreBool = (char)1; +} + +void vkGetBufferOpaqueCaptureAddressKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetBufferOpaqueCaptureAddressKHR_IgnoreBool) + Mock.vkGetBufferOpaqueCaptureAddressKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetBufferOpaqueCaptureAddressKHR_CallInstance); + Mock.vkGetBufferOpaqueCaptureAddressKHR_IgnoreBool = (char)0; +} + +void vkGetBufferOpaqueCaptureAddressKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, uint64_t cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetBufferOpaqueCaptureAddressKHR_CALL_INSTANCE)); + CMOCK_vkGetBufferOpaqueCaptureAddressKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferOpaqueCaptureAddressKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetBufferOpaqueCaptureAddressKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetBufferOpaqueCaptureAddressKHR_CallInstance, cmock_guts_index); + Mock.vkGetBufferOpaqueCaptureAddressKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetBufferOpaqueCaptureAddressKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkBufferDeviceAddressInfo* pInfo, uint64_t cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetBufferOpaqueCaptureAddressKHR_CALL_INSTANCE)); + CMOCK_vkGetBufferOpaqueCaptureAddressKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferOpaqueCaptureAddressKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetBufferOpaqueCaptureAddressKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetBufferOpaqueCaptureAddressKHR_CallInstance, cmock_guts_index); + Mock.vkGetBufferOpaqueCaptureAddressKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetBufferOpaqueCaptureAddressKHR(cmock_call_instance, device, pInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(uint64_t[sizeof(cmock_to_return) == sizeof(uint64_t) ? 1 : -1])); /* add uint64_t to :treat_as_array if this causes an error */ +} + +void vkGetBufferOpaqueCaptureAddressKHR_AddCallback(CMOCK_vkGetBufferOpaqueCaptureAddressKHR_CALLBACK Callback) +{ + Mock.vkGetBufferOpaqueCaptureAddressKHR_IgnoreBool = (char)0; + Mock.vkGetBufferOpaqueCaptureAddressKHR_CallbackBool = (char)1; + Mock.vkGetBufferOpaqueCaptureAddressKHR_CallbackFunctionPointer = Callback; +} + +void vkGetBufferOpaqueCaptureAddressKHR_Stub(CMOCK_vkGetBufferOpaqueCaptureAddressKHR_CALLBACK Callback) +{ + Mock.vkGetBufferOpaqueCaptureAddressKHR_IgnoreBool = (char)0; + Mock.vkGetBufferOpaqueCaptureAddressKHR_CallbackBool = (char)0; + Mock.vkGetBufferOpaqueCaptureAddressKHR_CallbackFunctionPointer = Callback; +} + +void vkGetBufferOpaqueCaptureAddressKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetBufferOpaqueCaptureAddressKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferOpaqueCaptureAddressKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetBufferOpaqueCaptureAddressKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetBufferOpaqueCaptureAddressKHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetBufferOpaqueCaptureAddressKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferOpaqueCaptureAddressKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetBufferOpaqueCaptureAddressKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDeviceMemoryOpaqueCaptureAddressKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDeviceMemoryOpaqueCaptureAddressKHR); + cmock_call_instance = (CMOCK_vkGetDeviceMemoryOpaqueCaptureAddressKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_CallInstance); + Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_CallInstance); + if (Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(uint64_t[sizeof(cmock_call_instance->ReturnVal) == sizeof(uint64_t) ? 1 : -1])); /* add uint64_t to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_CallbackBool && + Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_CallbackFunctionPointer != NULL) + { + uint64_t cmock_cb_ret = Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_CallbackFunctionPointer(device, pInfo, Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceMemoryOpaqueCaptureAddressKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceMemoryOpaqueCaptureAddressKHR,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkDeviceMemoryOpaqueCaptureAddressInfo), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_CallbackFunctionPointer(device, pInfo, Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetDeviceMemoryOpaqueCaptureAddressKHR(CMOCK_vkGetDeviceMemoryOpaqueCaptureAddressKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); +void CMockExpectParameters_vkGetDeviceMemoryOpaqueCaptureAddressKHR(CMOCK_vkGetDeviceMemoryOpaqueCaptureAddressKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; +} + +void vkGetDeviceMemoryOpaqueCaptureAddressKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, uint64_t cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceMemoryOpaqueCaptureAddressKHR_CALL_INSTANCE)); + CMOCK_vkGetDeviceMemoryOpaqueCaptureAddressKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceMemoryOpaqueCaptureAddressKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_CallInstance, cmock_guts_index); + Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_IgnoreBool = (char)1; +} + +void vkGetDeviceMemoryOpaqueCaptureAddressKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_IgnoreBool) + Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_CallInstance); + Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_IgnoreBool = (char)0; +} + +void vkGetDeviceMemoryOpaqueCaptureAddressKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, uint64_t cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceMemoryOpaqueCaptureAddressKHR_CALL_INSTANCE)); + CMOCK_vkGetDeviceMemoryOpaqueCaptureAddressKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceMemoryOpaqueCaptureAddressKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_CallInstance, cmock_guts_index); + Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDeviceMemoryOpaqueCaptureAddressKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo, uint64_t cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceMemoryOpaqueCaptureAddressKHR_CALL_INSTANCE)); + CMOCK_vkGetDeviceMemoryOpaqueCaptureAddressKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceMemoryOpaqueCaptureAddressKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_CallInstance, cmock_guts_index); + Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDeviceMemoryOpaqueCaptureAddressKHR(cmock_call_instance, device, pInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(uint64_t[sizeof(cmock_to_return) == sizeof(uint64_t) ? 1 : -1])); /* add uint64_t to :treat_as_array if this causes an error */ +} + +void vkGetDeviceMemoryOpaqueCaptureAddressKHR_AddCallback(CMOCK_vkGetDeviceMemoryOpaqueCaptureAddressKHR_CALLBACK Callback) +{ + Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_IgnoreBool = (char)0; + Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_CallbackBool = (char)1; + Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceMemoryOpaqueCaptureAddressKHR_Stub(CMOCK_vkGetDeviceMemoryOpaqueCaptureAddressKHR_CALLBACK Callback) +{ + Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_IgnoreBool = (char)0; + Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_CallbackBool = (char)0; + Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceMemoryOpaqueCaptureAddressKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceMemoryOpaqueCaptureAddressKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceMemoryOpaqueCaptureAddressKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetDeviceMemoryOpaqueCaptureAddressKHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceMemoryOpaqueCaptureAddressKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceMemoryOpaqueCaptureAddressKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceMemoryOpaqueCaptureAddressKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +VkResult vkCreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateDeferredOperationKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateDeferredOperationKHR); + cmock_call_instance = (CMOCK_vkCreateDeferredOperationKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateDeferredOperationKHR_CallInstance); + Mock.vkCreateDeferredOperationKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCreateDeferredOperationKHR_CallInstance); + if (Mock.vkCreateDeferredOperationKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateDeferredOperationKHR_FinalReturn; + memcpy((void*)(&Mock.vkCreateDeferredOperationKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateDeferredOperationKHR_CallbackBool && + Mock.vkCreateDeferredOperationKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateDeferredOperationKHR_CallbackFunctionPointer(device, pAllocator, pDeferredOperation, Mock.vkCreateDeferredOperationKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateDeferredOperationKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateDeferredOperationKHR,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDeferredOperation) + { + UNITY_SET_DETAILS(CMockString_vkCreateDeferredOperationKHR,CMockString_pDeferredOperation); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDeferredOperation), (void*)(pDeferredOperation), sizeof(VkDeferredOperationKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateDeferredOperationKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateDeferredOperationKHR_CallbackFunctionPointer(device, pAllocator, pDeferredOperation, Mock.vkCreateDeferredOperationKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pDeferredOperation_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pDeferredOperation, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pDeferredOperation, (const void*)cmock_call_instance->ReturnThruPtr_pDeferredOperation_Val, + cmock_call_instance->ReturnThruPtr_pDeferredOperation_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateDeferredOperationKHR(CMOCK_vkCreateDeferredOperationKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation); +void CMockExpectParameters_vkCreateDeferredOperationKHR(CMOCK_vkCreateDeferredOperationKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pDeferredOperation = pDeferredOperation; + cmock_call_instance->IgnoreArg_pDeferredOperation = 0; + cmock_call_instance->ReturnThruPtr_pDeferredOperation_Used = 0; +} + +void vkCreateDeferredOperationKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateDeferredOperationKHR_CALL_INSTANCE)); + CMOCK_vkCreateDeferredOperationKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDeferredOperationKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateDeferredOperationKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateDeferredOperationKHR_CallInstance, cmock_guts_index); + Mock.vkCreateDeferredOperationKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateDeferredOperationKHR_IgnoreBool = (char)1; +} + +void vkCreateDeferredOperationKHR_CMockStopIgnore(void) +{ + if(Mock.vkCreateDeferredOperationKHR_IgnoreBool) + Mock.vkCreateDeferredOperationKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCreateDeferredOperationKHR_CallInstance); + Mock.vkCreateDeferredOperationKHR_IgnoreBool = (char)0; +} + +void vkCreateDeferredOperationKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateDeferredOperationKHR_CALL_INSTANCE)); + CMOCK_vkCreateDeferredOperationKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDeferredOperationKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateDeferredOperationKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateDeferredOperationKHR_CallInstance, cmock_guts_index); + Mock.vkCreateDeferredOperationKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateDeferredOperationKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateDeferredOperationKHR_CALL_INSTANCE)); + CMOCK_vkCreateDeferredOperationKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDeferredOperationKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateDeferredOperationKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateDeferredOperationKHR_CallInstance, cmock_guts_index); + Mock.vkCreateDeferredOperationKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateDeferredOperationKHR(cmock_call_instance, device, pAllocator, pDeferredOperation); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateDeferredOperationKHR_AddCallback(CMOCK_vkCreateDeferredOperationKHR_CALLBACK Callback) +{ + Mock.vkCreateDeferredOperationKHR_IgnoreBool = (char)0; + Mock.vkCreateDeferredOperationKHR_CallbackBool = (char)1; + Mock.vkCreateDeferredOperationKHR_CallbackFunctionPointer = Callback; +} + +void vkCreateDeferredOperationKHR_Stub(CMOCK_vkCreateDeferredOperationKHR_CALLBACK Callback) +{ + Mock.vkCreateDeferredOperationKHR_IgnoreBool = (char)0; + Mock.vkCreateDeferredOperationKHR_CallbackBool = (char)0; + Mock.vkCreateDeferredOperationKHR_CallbackFunctionPointer = Callback; +} + +void vkCreateDeferredOperationKHR_CMockReturnMemThruPtr_pDeferredOperation(UNITY_LINE_TYPE cmock_line, VkDeferredOperationKHR const* pDeferredOperation, size_t cmock_size) +{ + CMOCK_vkCreateDeferredOperationKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDeferredOperationKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDeferredOperationKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pDeferredOperation_Used = 1; + cmock_call_instance->ReturnThruPtr_pDeferredOperation_Val = pDeferredOperation; + cmock_call_instance->ReturnThruPtr_pDeferredOperation_Size = cmock_size; +} + +void vkCreateDeferredOperationKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDeferredOperationKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDeferredOperationKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDeferredOperationKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateDeferredOperationKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDeferredOperationKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDeferredOperationKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDeferredOperationKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateDeferredOperationKHR_CMockIgnoreArg_pDeferredOperation(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDeferredOperationKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDeferredOperationKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDeferredOperationKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDeferredOperation = 1; +} + +void vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyDeferredOperationKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyDeferredOperationKHR); + cmock_call_instance = (CMOCK_vkDestroyDeferredOperationKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyDeferredOperationKHR_CallInstance); + Mock.vkDestroyDeferredOperationKHR_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyDeferredOperationKHR_CallInstance); + if (Mock.vkDestroyDeferredOperationKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyDeferredOperationKHR_CallbackBool && + Mock.vkDestroyDeferredOperationKHR_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyDeferredOperationKHR_CallbackFunctionPointer(device, operation, pAllocator, Mock.vkDestroyDeferredOperationKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyDeferredOperationKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_operation) + { + UNITY_SET_DETAILS(CMockString_vkDestroyDeferredOperationKHR,CMockString_operation); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_operation), (void*)(&operation), sizeof(VkDeferredOperationKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyDeferredOperationKHR,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyDeferredOperationKHR_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyDeferredOperationKHR_CallbackFunctionPointer(device, operation, pAllocator, Mock.vkDestroyDeferredOperationKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyDeferredOperationKHR(CMOCK_vkDestroyDeferredOperationKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyDeferredOperationKHR(CMOCK_vkDestroyDeferredOperationKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_operation), (void*)(&operation), + sizeof(VkDeferredOperationKHR[sizeof(operation) == sizeof(VkDeferredOperationKHR) ? 1 : -1])); /* add VkDeferredOperationKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_operation = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyDeferredOperationKHR_CMockIgnore(void) +{ + Mock.vkDestroyDeferredOperationKHR_IgnoreBool = (char)1; +} + +void vkDestroyDeferredOperationKHR_CMockStopIgnore(void) +{ + Mock.vkDestroyDeferredOperationKHR_IgnoreBool = (char)0; +} + +void vkDestroyDeferredOperationKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyDeferredOperationKHR_CALL_INSTANCE)); + CMOCK_vkDestroyDeferredOperationKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDeferredOperationKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyDeferredOperationKHR_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyDeferredOperationKHR_CallInstance, cmock_guts_index); + Mock.vkDestroyDeferredOperationKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyDeferredOperationKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyDeferredOperationKHR_CALL_INSTANCE)); + CMOCK_vkDestroyDeferredOperationKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDeferredOperationKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyDeferredOperationKHR_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyDeferredOperationKHR_CallInstance, cmock_guts_index); + Mock.vkDestroyDeferredOperationKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyDeferredOperationKHR(cmock_call_instance, device, operation, pAllocator); +} + +void vkDestroyDeferredOperationKHR_AddCallback(CMOCK_vkDestroyDeferredOperationKHR_CALLBACK Callback) +{ + Mock.vkDestroyDeferredOperationKHR_IgnoreBool = (char)0; + Mock.vkDestroyDeferredOperationKHR_CallbackBool = (char)1; + Mock.vkDestroyDeferredOperationKHR_CallbackFunctionPointer = Callback; +} + +void vkDestroyDeferredOperationKHR_Stub(CMOCK_vkDestroyDeferredOperationKHR_CALLBACK Callback) +{ + Mock.vkDestroyDeferredOperationKHR_IgnoreBool = (char)0; + Mock.vkDestroyDeferredOperationKHR_CallbackBool = (char)0; + Mock.vkDestroyDeferredOperationKHR_CallbackFunctionPointer = Callback; +} + +void vkDestroyDeferredOperationKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyDeferredOperationKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDeferredOperationKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyDeferredOperationKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyDeferredOperationKHR_CMockIgnoreArg_operation(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyDeferredOperationKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDeferredOperationKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyDeferredOperationKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_operation = 1; +} + +void vkDestroyDeferredOperationKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyDeferredOperationKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDeferredOperationKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyDeferredOperationKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +uint32_t vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDeferredOperationMaxConcurrencyKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDeferredOperationMaxConcurrencyKHR); + cmock_call_instance = (CMOCK_vkGetDeferredOperationMaxConcurrencyKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDeferredOperationMaxConcurrencyKHR_CallInstance); + Mock.vkGetDeferredOperationMaxConcurrencyKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeferredOperationMaxConcurrencyKHR_CallInstance); + if (Mock.vkGetDeferredOperationMaxConcurrencyKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetDeferredOperationMaxConcurrencyKHR_FinalReturn; + Mock.vkGetDeferredOperationMaxConcurrencyKHR_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetDeferredOperationMaxConcurrencyKHR_CallbackBool && + Mock.vkGetDeferredOperationMaxConcurrencyKHR_CallbackFunctionPointer != NULL) + { + uint32_t cmock_cb_ret = Mock.vkGetDeferredOperationMaxConcurrencyKHR_CallbackFunctionPointer(device, operation, Mock.vkGetDeferredOperationMaxConcurrencyKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetDeferredOperationMaxConcurrencyKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_operation) + { + UNITY_SET_DETAILS(CMockString_vkGetDeferredOperationMaxConcurrencyKHR,CMockString_operation); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_operation), (void*)(&operation), sizeof(VkDeferredOperationKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDeferredOperationMaxConcurrencyKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetDeferredOperationMaxConcurrencyKHR_CallbackFunctionPointer(device, operation, Mock.vkGetDeferredOperationMaxConcurrencyKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetDeferredOperationMaxConcurrencyKHR(CMOCK_vkGetDeferredOperationMaxConcurrencyKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeferredOperationKHR operation); +void CMockExpectParameters_vkGetDeferredOperationMaxConcurrencyKHR(CMOCK_vkGetDeferredOperationMaxConcurrencyKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeferredOperationKHR operation) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_operation), (void*)(&operation), + sizeof(VkDeferredOperationKHR[sizeof(operation) == sizeof(VkDeferredOperationKHR) ? 1 : -1])); /* add VkDeferredOperationKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_operation = 0; +} + +void vkGetDeferredOperationMaxConcurrencyKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, uint32_t cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeferredOperationMaxConcurrencyKHR_CALL_INSTANCE)); + CMOCK_vkGetDeferredOperationMaxConcurrencyKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeferredOperationMaxConcurrencyKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeferredOperationMaxConcurrencyKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeferredOperationMaxConcurrencyKHR_CallInstance, cmock_guts_index); + Mock.vkGetDeferredOperationMaxConcurrencyKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetDeferredOperationMaxConcurrencyKHR_IgnoreBool = (char)1; +} + +void vkGetDeferredOperationMaxConcurrencyKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetDeferredOperationMaxConcurrencyKHR_IgnoreBool) + Mock.vkGetDeferredOperationMaxConcurrencyKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeferredOperationMaxConcurrencyKHR_CallInstance); + Mock.vkGetDeferredOperationMaxConcurrencyKHR_IgnoreBool = (char)0; +} + +void vkGetDeferredOperationMaxConcurrencyKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, uint32_t cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeferredOperationMaxConcurrencyKHR_CALL_INSTANCE)); + CMOCK_vkGetDeferredOperationMaxConcurrencyKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeferredOperationMaxConcurrencyKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeferredOperationMaxConcurrencyKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeferredOperationMaxConcurrencyKHR_CallInstance, cmock_guts_index); + Mock.vkGetDeferredOperationMaxConcurrencyKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDeferredOperationMaxConcurrencyKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeferredOperationKHR operation, uint32_t cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeferredOperationMaxConcurrencyKHR_CALL_INSTANCE)); + CMOCK_vkGetDeferredOperationMaxConcurrencyKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeferredOperationMaxConcurrencyKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeferredOperationMaxConcurrencyKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeferredOperationMaxConcurrencyKHR_CallInstance, cmock_guts_index); + Mock.vkGetDeferredOperationMaxConcurrencyKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDeferredOperationMaxConcurrencyKHR(cmock_call_instance, device, operation); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void vkGetDeferredOperationMaxConcurrencyKHR_AddCallback(CMOCK_vkGetDeferredOperationMaxConcurrencyKHR_CALLBACK Callback) +{ + Mock.vkGetDeferredOperationMaxConcurrencyKHR_IgnoreBool = (char)0; + Mock.vkGetDeferredOperationMaxConcurrencyKHR_CallbackBool = (char)1; + Mock.vkGetDeferredOperationMaxConcurrencyKHR_CallbackFunctionPointer = Callback; +} + +void vkGetDeferredOperationMaxConcurrencyKHR_Stub(CMOCK_vkGetDeferredOperationMaxConcurrencyKHR_CALLBACK Callback) +{ + Mock.vkGetDeferredOperationMaxConcurrencyKHR_IgnoreBool = (char)0; + Mock.vkGetDeferredOperationMaxConcurrencyKHR_CallbackBool = (char)0; + Mock.vkGetDeferredOperationMaxConcurrencyKHR_CallbackFunctionPointer = Callback; +} + +void vkGetDeferredOperationMaxConcurrencyKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeferredOperationMaxConcurrencyKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeferredOperationMaxConcurrencyKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeferredOperationMaxConcurrencyKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetDeferredOperationMaxConcurrencyKHR_CMockIgnoreArg_operation(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeferredOperationMaxConcurrencyKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeferredOperationMaxConcurrencyKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeferredOperationMaxConcurrencyKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_operation = 1; +} + +VkResult vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDeferredOperationResultKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDeferredOperationResultKHR); + cmock_call_instance = (CMOCK_vkGetDeferredOperationResultKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDeferredOperationResultKHR_CallInstance); + Mock.vkGetDeferredOperationResultKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeferredOperationResultKHR_CallInstance); + if (Mock.vkGetDeferredOperationResultKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetDeferredOperationResultKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetDeferredOperationResultKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetDeferredOperationResultKHR_CallbackBool && + Mock.vkGetDeferredOperationResultKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetDeferredOperationResultKHR_CallbackFunctionPointer(device, operation, Mock.vkGetDeferredOperationResultKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetDeferredOperationResultKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_operation) + { + UNITY_SET_DETAILS(CMockString_vkGetDeferredOperationResultKHR,CMockString_operation); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_operation), (void*)(&operation), sizeof(VkDeferredOperationKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDeferredOperationResultKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetDeferredOperationResultKHR_CallbackFunctionPointer(device, operation, Mock.vkGetDeferredOperationResultKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetDeferredOperationResultKHR(CMOCK_vkGetDeferredOperationResultKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeferredOperationKHR operation); +void CMockExpectParameters_vkGetDeferredOperationResultKHR(CMOCK_vkGetDeferredOperationResultKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeferredOperationKHR operation) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_operation), (void*)(&operation), + sizeof(VkDeferredOperationKHR[sizeof(operation) == sizeof(VkDeferredOperationKHR) ? 1 : -1])); /* add VkDeferredOperationKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_operation = 0; +} + +void vkGetDeferredOperationResultKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeferredOperationResultKHR_CALL_INSTANCE)); + CMOCK_vkGetDeferredOperationResultKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeferredOperationResultKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeferredOperationResultKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeferredOperationResultKHR_CallInstance, cmock_guts_index); + Mock.vkGetDeferredOperationResultKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetDeferredOperationResultKHR_IgnoreBool = (char)1; +} + +void vkGetDeferredOperationResultKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetDeferredOperationResultKHR_IgnoreBool) + Mock.vkGetDeferredOperationResultKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeferredOperationResultKHR_CallInstance); + Mock.vkGetDeferredOperationResultKHR_IgnoreBool = (char)0; +} + +void vkGetDeferredOperationResultKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeferredOperationResultKHR_CALL_INSTANCE)); + CMOCK_vkGetDeferredOperationResultKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeferredOperationResultKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeferredOperationResultKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeferredOperationResultKHR_CallInstance, cmock_guts_index); + Mock.vkGetDeferredOperationResultKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDeferredOperationResultKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeferredOperationKHR operation, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeferredOperationResultKHR_CALL_INSTANCE)); + CMOCK_vkGetDeferredOperationResultKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeferredOperationResultKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeferredOperationResultKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeferredOperationResultKHR_CallInstance, cmock_guts_index); + Mock.vkGetDeferredOperationResultKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDeferredOperationResultKHR(cmock_call_instance, device, operation); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetDeferredOperationResultKHR_AddCallback(CMOCK_vkGetDeferredOperationResultKHR_CALLBACK Callback) +{ + Mock.vkGetDeferredOperationResultKHR_IgnoreBool = (char)0; + Mock.vkGetDeferredOperationResultKHR_CallbackBool = (char)1; + Mock.vkGetDeferredOperationResultKHR_CallbackFunctionPointer = Callback; +} + +void vkGetDeferredOperationResultKHR_Stub(CMOCK_vkGetDeferredOperationResultKHR_CALLBACK Callback) +{ + Mock.vkGetDeferredOperationResultKHR_IgnoreBool = (char)0; + Mock.vkGetDeferredOperationResultKHR_CallbackBool = (char)0; + Mock.vkGetDeferredOperationResultKHR_CallbackFunctionPointer = Callback; +} + +void vkGetDeferredOperationResultKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeferredOperationResultKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeferredOperationResultKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeferredOperationResultKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetDeferredOperationResultKHR_CMockIgnoreArg_operation(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeferredOperationResultKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeferredOperationResultKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeferredOperationResultKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_operation = 1; +} + +VkResult vkDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDeferredOperationJoinKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDeferredOperationJoinKHR); + cmock_call_instance = (CMOCK_vkDeferredOperationJoinKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDeferredOperationJoinKHR_CallInstance); + Mock.vkDeferredOperationJoinKHR_CallInstance = CMock_Guts_MemNext(Mock.vkDeferredOperationJoinKHR_CallInstance); + if (Mock.vkDeferredOperationJoinKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkDeferredOperationJoinKHR_FinalReturn; + memcpy((void*)(&Mock.vkDeferredOperationJoinKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkDeferredOperationJoinKHR_CallbackBool && + Mock.vkDeferredOperationJoinKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkDeferredOperationJoinKHR_CallbackFunctionPointer(device, operation, Mock.vkDeferredOperationJoinKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDeferredOperationJoinKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_operation) + { + UNITY_SET_DETAILS(CMockString_vkDeferredOperationJoinKHR,CMockString_operation); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_operation), (void*)(&operation), sizeof(VkDeferredOperationKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDeferredOperationJoinKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkDeferredOperationJoinKHR_CallbackFunctionPointer(device, operation, Mock.vkDeferredOperationJoinKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkDeferredOperationJoinKHR(CMOCK_vkDeferredOperationJoinKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeferredOperationKHR operation); +void CMockExpectParameters_vkDeferredOperationJoinKHR(CMOCK_vkDeferredOperationJoinKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeferredOperationKHR operation) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_operation), (void*)(&operation), + sizeof(VkDeferredOperationKHR[sizeof(operation) == sizeof(VkDeferredOperationKHR) ? 1 : -1])); /* add VkDeferredOperationKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_operation = 0; +} + +void vkDeferredOperationJoinKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDeferredOperationJoinKHR_CALL_INSTANCE)); + CMOCK_vkDeferredOperationJoinKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDeferredOperationJoinKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDeferredOperationJoinKHR_CallInstance = CMock_Guts_MemChain(Mock.vkDeferredOperationJoinKHR_CallInstance, cmock_guts_index); + Mock.vkDeferredOperationJoinKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkDeferredOperationJoinKHR_IgnoreBool = (char)1; +} + +void vkDeferredOperationJoinKHR_CMockStopIgnore(void) +{ + if(Mock.vkDeferredOperationJoinKHR_IgnoreBool) + Mock.vkDeferredOperationJoinKHR_CallInstance = CMock_Guts_MemNext(Mock.vkDeferredOperationJoinKHR_CallInstance); + Mock.vkDeferredOperationJoinKHR_IgnoreBool = (char)0; +} + +void vkDeferredOperationJoinKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDeferredOperationJoinKHR_CALL_INSTANCE)); + CMOCK_vkDeferredOperationJoinKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDeferredOperationJoinKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDeferredOperationJoinKHR_CallInstance = CMock_Guts_MemChain(Mock.vkDeferredOperationJoinKHR_CallInstance, cmock_guts_index); + Mock.vkDeferredOperationJoinKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDeferredOperationJoinKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeferredOperationKHR operation, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDeferredOperationJoinKHR_CALL_INSTANCE)); + CMOCK_vkDeferredOperationJoinKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDeferredOperationJoinKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDeferredOperationJoinKHR_CallInstance = CMock_Guts_MemChain(Mock.vkDeferredOperationJoinKHR_CallInstance, cmock_guts_index); + Mock.vkDeferredOperationJoinKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDeferredOperationJoinKHR(cmock_call_instance, device, operation); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkDeferredOperationJoinKHR_AddCallback(CMOCK_vkDeferredOperationJoinKHR_CALLBACK Callback) +{ + Mock.vkDeferredOperationJoinKHR_IgnoreBool = (char)0; + Mock.vkDeferredOperationJoinKHR_CallbackBool = (char)1; + Mock.vkDeferredOperationJoinKHR_CallbackFunctionPointer = Callback; +} + +void vkDeferredOperationJoinKHR_Stub(CMOCK_vkDeferredOperationJoinKHR_CALLBACK Callback) +{ + Mock.vkDeferredOperationJoinKHR_IgnoreBool = (char)0; + Mock.vkDeferredOperationJoinKHR_CallbackBool = (char)0; + Mock.vkDeferredOperationJoinKHR_CallbackFunctionPointer = Callback; +} + +void vkDeferredOperationJoinKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDeferredOperationJoinKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDeferredOperationJoinKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDeferredOperationJoinKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDeferredOperationJoinKHR_CMockIgnoreArg_operation(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDeferredOperationJoinKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDeferredOperationJoinKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDeferredOperationJoinKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_operation = 1; +} + +VkResult vkGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPipelineExecutablePropertiesKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPipelineExecutablePropertiesKHR); + cmock_call_instance = (CMOCK_vkGetPipelineExecutablePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPipelineExecutablePropertiesKHR_CallInstance); + Mock.vkGetPipelineExecutablePropertiesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPipelineExecutablePropertiesKHR_CallInstance); + if (Mock.vkGetPipelineExecutablePropertiesKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPipelineExecutablePropertiesKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetPipelineExecutablePropertiesKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPipelineExecutablePropertiesKHR_CallbackBool && + Mock.vkGetPipelineExecutablePropertiesKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPipelineExecutablePropertiesKHR_CallbackFunctionPointer(device, pPipelineInfo, pExecutableCount, pProperties, Mock.vkGetPipelineExecutablePropertiesKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetPipelineExecutablePropertiesKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPipelineInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetPipelineExecutablePropertiesKHR,CMockString_pPipelineInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pPipelineInfo), (void*)(pPipelineInfo), sizeof(const VkPipelineInfoKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pExecutableCount) + { + UNITY_SET_DETAILS(CMockString_vkGetPipelineExecutablePropertiesKHR,CMockString_pExecutableCount); + if (cmock_call_instance->Expected_pExecutableCount == NULL) + { UNITY_TEST_ASSERT_NULL(pExecutableCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pExecutableCount, pExecutableCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPipelineExecutablePropertiesKHR,CMockString_pProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pProperties), (void*)(pProperties), sizeof(VkPipelineExecutablePropertiesKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPipelineExecutablePropertiesKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPipelineExecutablePropertiesKHR_CallbackFunctionPointer(device, pPipelineInfo, pExecutableCount, pProperties, Mock.vkGetPipelineExecutablePropertiesKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pExecutableCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pExecutableCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pExecutableCount, (const void*)cmock_call_instance->ReturnThruPtr_pExecutableCount_Val, + cmock_call_instance->ReturnThruPtr_pExecutableCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pProperties, (const void*)cmock_call_instance->ReturnThruPtr_pProperties_Val, + cmock_call_instance->ReturnThruPtr_pProperties_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPipelineExecutablePropertiesKHR(CMOCK_vkGetPipelineExecutablePropertiesKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties); +void CMockExpectParameters_vkGetPipelineExecutablePropertiesKHR(CMOCK_vkGetPipelineExecutablePropertiesKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pPipelineInfo = pPipelineInfo; + cmock_call_instance->IgnoreArg_pPipelineInfo = 0; + cmock_call_instance->Expected_pExecutableCount = pExecutableCount; + cmock_call_instance->IgnoreArg_pExecutableCount = 0; + cmock_call_instance->ReturnThruPtr_pExecutableCount_Used = 0; + cmock_call_instance->Expected_pProperties = pProperties; + cmock_call_instance->IgnoreArg_pProperties = 0; + cmock_call_instance->ReturnThruPtr_pProperties_Used = 0; +} + +void vkGetPipelineExecutablePropertiesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPipelineExecutablePropertiesKHR_CALL_INSTANCE)); + CMOCK_vkGetPipelineExecutablePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineExecutablePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPipelineExecutablePropertiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPipelineExecutablePropertiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPipelineExecutablePropertiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPipelineExecutablePropertiesKHR_IgnoreBool = (char)1; +} + +void vkGetPipelineExecutablePropertiesKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetPipelineExecutablePropertiesKHR_IgnoreBool) + Mock.vkGetPipelineExecutablePropertiesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPipelineExecutablePropertiesKHR_CallInstance); + Mock.vkGetPipelineExecutablePropertiesKHR_IgnoreBool = (char)0; +} + +void vkGetPipelineExecutablePropertiesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPipelineExecutablePropertiesKHR_CALL_INSTANCE)); + CMOCK_vkGetPipelineExecutablePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineExecutablePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPipelineExecutablePropertiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPipelineExecutablePropertiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPipelineExecutablePropertiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPipelineExecutablePropertiesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPipelineExecutablePropertiesKHR_CALL_INSTANCE)); + CMOCK_vkGetPipelineExecutablePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineExecutablePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPipelineExecutablePropertiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPipelineExecutablePropertiesKHR_CallInstance, cmock_guts_index); + Mock.vkGetPipelineExecutablePropertiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPipelineExecutablePropertiesKHR(cmock_call_instance, device, pPipelineInfo, pExecutableCount, pProperties); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPipelineExecutablePropertiesKHR_AddCallback(CMOCK_vkGetPipelineExecutablePropertiesKHR_CALLBACK Callback) +{ + Mock.vkGetPipelineExecutablePropertiesKHR_IgnoreBool = (char)0; + Mock.vkGetPipelineExecutablePropertiesKHR_CallbackBool = (char)1; + Mock.vkGetPipelineExecutablePropertiesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPipelineExecutablePropertiesKHR_Stub(CMOCK_vkGetPipelineExecutablePropertiesKHR_CALLBACK Callback) +{ + Mock.vkGetPipelineExecutablePropertiesKHR_IgnoreBool = (char)0; + Mock.vkGetPipelineExecutablePropertiesKHR_CallbackBool = (char)0; + Mock.vkGetPipelineExecutablePropertiesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPipelineExecutablePropertiesKHR_CMockReturnMemThruPtr_pExecutableCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pExecutableCount, size_t cmock_size) +{ + CMOCK_vkGetPipelineExecutablePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineExecutablePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPipelineExecutablePropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pExecutableCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pExecutableCount_Val = pExecutableCount; + cmock_call_instance->ReturnThruPtr_pExecutableCount_Size = cmock_size; +} + +void vkGetPipelineExecutablePropertiesKHR_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkPipelineExecutablePropertiesKHR const* pProperties, size_t cmock_size) +{ + CMOCK_vkGetPipelineExecutablePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineExecutablePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPipelineExecutablePropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pProperties_Val = pProperties; + cmock_call_instance->ReturnThruPtr_pProperties_Size = cmock_size; +} + +void vkGetPipelineExecutablePropertiesKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPipelineExecutablePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineExecutablePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPipelineExecutablePropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetPipelineExecutablePropertiesKHR_CMockIgnoreArg_pPipelineInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPipelineExecutablePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineExecutablePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPipelineExecutablePropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPipelineInfo = 1; +} + +void vkGetPipelineExecutablePropertiesKHR_CMockIgnoreArg_pExecutableCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPipelineExecutablePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineExecutablePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPipelineExecutablePropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pExecutableCount = 1; +} + +void vkGetPipelineExecutablePropertiesKHR_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPipelineExecutablePropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineExecutablePropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPipelineExecutablePropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pProperties = 1; +} + +VkResult vkGetPipelineExecutableStatisticsKHR(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPipelineExecutableStatisticsKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPipelineExecutableStatisticsKHR); + cmock_call_instance = (CMOCK_vkGetPipelineExecutableStatisticsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPipelineExecutableStatisticsKHR_CallInstance); + Mock.vkGetPipelineExecutableStatisticsKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPipelineExecutableStatisticsKHR_CallInstance); + if (Mock.vkGetPipelineExecutableStatisticsKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPipelineExecutableStatisticsKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetPipelineExecutableStatisticsKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPipelineExecutableStatisticsKHR_CallbackBool && + Mock.vkGetPipelineExecutableStatisticsKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPipelineExecutableStatisticsKHR_CallbackFunctionPointer(device, pExecutableInfo, pStatisticCount, pStatistics, Mock.vkGetPipelineExecutableStatisticsKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetPipelineExecutableStatisticsKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pExecutableInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetPipelineExecutableStatisticsKHR,CMockString_pExecutableInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pExecutableInfo), (void*)(pExecutableInfo), sizeof(const VkPipelineExecutableInfoKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pStatisticCount) + { + UNITY_SET_DETAILS(CMockString_vkGetPipelineExecutableStatisticsKHR,CMockString_pStatisticCount); + if (cmock_call_instance->Expected_pStatisticCount == NULL) + { UNITY_TEST_ASSERT_NULL(pStatisticCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pStatisticCount, pStatisticCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pStatistics) + { + UNITY_SET_DETAILS(CMockString_vkGetPipelineExecutableStatisticsKHR,CMockString_pStatistics); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pStatistics), (void*)(pStatistics), sizeof(VkPipelineExecutableStatisticKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPipelineExecutableStatisticsKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPipelineExecutableStatisticsKHR_CallbackFunctionPointer(device, pExecutableInfo, pStatisticCount, pStatistics, Mock.vkGetPipelineExecutableStatisticsKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pStatisticCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pStatisticCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pStatisticCount, (const void*)cmock_call_instance->ReturnThruPtr_pStatisticCount_Val, + cmock_call_instance->ReturnThruPtr_pStatisticCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pStatistics_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pStatistics, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pStatistics, (const void*)cmock_call_instance->ReturnThruPtr_pStatistics_Val, + cmock_call_instance->ReturnThruPtr_pStatistics_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPipelineExecutableStatisticsKHR(CMOCK_vkGetPipelineExecutableStatisticsKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics); +void CMockExpectParameters_vkGetPipelineExecutableStatisticsKHR(CMOCK_vkGetPipelineExecutableStatisticsKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pExecutableInfo = pExecutableInfo; + cmock_call_instance->IgnoreArg_pExecutableInfo = 0; + cmock_call_instance->Expected_pStatisticCount = pStatisticCount; + cmock_call_instance->IgnoreArg_pStatisticCount = 0; + cmock_call_instance->ReturnThruPtr_pStatisticCount_Used = 0; + cmock_call_instance->Expected_pStatistics = pStatistics; + cmock_call_instance->IgnoreArg_pStatistics = 0; + cmock_call_instance->ReturnThruPtr_pStatistics_Used = 0; +} + +void vkGetPipelineExecutableStatisticsKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPipelineExecutableStatisticsKHR_CALL_INSTANCE)); + CMOCK_vkGetPipelineExecutableStatisticsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineExecutableStatisticsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPipelineExecutableStatisticsKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPipelineExecutableStatisticsKHR_CallInstance, cmock_guts_index); + Mock.vkGetPipelineExecutableStatisticsKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPipelineExecutableStatisticsKHR_IgnoreBool = (char)1; +} + +void vkGetPipelineExecutableStatisticsKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetPipelineExecutableStatisticsKHR_IgnoreBool) + Mock.vkGetPipelineExecutableStatisticsKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPipelineExecutableStatisticsKHR_CallInstance); + Mock.vkGetPipelineExecutableStatisticsKHR_IgnoreBool = (char)0; +} + +void vkGetPipelineExecutableStatisticsKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPipelineExecutableStatisticsKHR_CALL_INSTANCE)); + CMOCK_vkGetPipelineExecutableStatisticsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineExecutableStatisticsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPipelineExecutableStatisticsKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPipelineExecutableStatisticsKHR_CallInstance, cmock_guts_index); + Mock.vkGetPipelineExecutableStatisticsKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPipelineExecutableStatisticsKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPipelineExecutableStatisticsKHR_CALL_INSTANCE)); + CMOCK_vkGetPipelineExecutableStatisticsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineExecutableStatisticsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPipelineExecutableStatisticsKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPipelineExecutableStatisticsKHR_CallInstance, cmock_guts_index); + Mock.vkGetPipelineExecutableStatisticsKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPipelineExecutableStatisticsKHR(cmock_call_instance, device, pExecutableInfo, pStatisticCount, pStatistics); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPipelineExecutableStatisticsKHR_AddCallback(CMOCK_vkGetPipelineExecutableStatisticsKHR_CALLBACK Callback) +{ + Mock.vkGetPipelineExecutableStatisticsKHR_IgnoreBool = (char)0; + Mock.vkGetPipelineExecutableStatisticsKHR_CallbackBool = (char)1; + Mock.vkGetPipelineExecutableStatisticsKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPipelineExecutableStatisticsKHR_Stub(CMOCK_vkGetPipelineExecutableStatisticsKHR_CALLBACK Callback) +{ + Mock.vkGetPipelineExecutableStatisticsKHR_IgnoreBool = (char)0; + Mock.vkGetPipelineExecutableStatisticsKHR_CallbackBool = (char)0; + Mock.vkGetPipelineExecutableStatisticsKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPipelineExecutableStatisticsKHR_CMockReturnMemThruPtr_pStatisticCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pStatisticCount, size_t cmock_size) +{ + CMOCK_vkGetPipelineExecutableStatisticsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineExecutableStatisticsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPipelineExecutableStatisticsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pStatisticCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pStatisticCount_Val = pStatisticCount; + cmock_call_instance->ReturnThruPtr_pStatisticCount_Size = cmock_size; +} + +void vkGetPipelineExecutableStatisticsKHR_CMockReturnMemThruPtr_pStatistics(UNITY_LINE_TYPE cmock_line, VkPipelineExecutableStatisticKHR const* pStatistics, size_t cmock_size) +{ + CMOCK_vkGetPipelineExecutableStatisticsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineExecutableStatisticsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPipelineExecutableStatisticsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pStatistics_Used = 1; + cmock_call_instance->ReturnThruPtr_pStatistics_Val = pStatistics; + cmock_call_instance->ReturnThruPtr_pStatistics_Size = cmock_size; +} + +void vkGetPipelineExecutableStatisticsKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPipelineExecutableStatisticsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineExecutableStatisticsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPipelineExecutableStatisticsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetPipelineExecutableStatisticsKHR_CMockIgnoreArg_pExecutableInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPipelineExecutableStatisticsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineExecutableStatisticsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPipelineExecutableStatisticsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pExecutableInfo = 1; +} + +void vkGetPipelineExecutableStatisticsKHR_CMockIgnoreArg_pStatisticCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPipelineExecutableStatisticsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineExecutableStatisticsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPipelineExecutableStatisticsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pStatisticCount = 1; +} + +void vkGetPipelineExecutableStatisticsKHR_CMockIgnoreArg_pStatistics(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPipelineExecutableStatisticsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineExecutableStatisticsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPipelineExecutableStatisticsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pStatistics = 1; +} + +VkResult vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPipelineExecutableInternalRepresentationsKHR); + cmock_call_instance = (CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPipelineExecutableInternalRepresentationsKHR_CallInstance); + Mock.vkGetPipelineExecutableInternalRepresentationsKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPipelineExecutableInternalRepresentationsKHR_CallInstance); + if (Mock.vkGetPipelineExecutableInternalRepresentationsKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPipelineExecutableInternalRepresentationsKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetPipelineExecutableInternalRepresentationsKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPipelineExecutableInternalRepresentationsKHR_CallbackBool && + Mock.vkGetPipelineExecutableInternalRepresentationsKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPipelineExecutableInternalRepresentationsKHR_CallbackFunctionPointer(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations, Mock.vkGetPipelineExecutableInternalRepresentationsKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetPipelineExecutableInternalRepresentationsKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pExecutableInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetPipelineExecutableInternalRepresentationsKHR,CMockString_pExecutableInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pExecutableInfo), (void*)(pExecutableInfo), sizeof(const VkPipelineExecutableInfoKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInternalRepresentationCount) + { + UNITY_SET_DETAILS(CMockString_vkGetPipelineExecutableInternalRepresentationsKHR,CMockString_pInternalRepresentationCount); + if (cmock_call_instance->Expected_pInternalRepresentationCount == NULL) + { UNITY_TEST_ASSERT_NULL(pInternalRepresentationCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pInternalRepresentationCount, pInternalRepresentationCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pInternalRepresentations) + { + UNITY_SET_DETAILS(CMockString_vkGetPipelineExecutableInternalRepresentationsKHR,CMockString_pInternalRepresentations); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInternalRepresentations), (void*)(pInternalRepresentations), sizeof(VkPipelineExecutableInternalRepresentationKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPipelineExecutableInternalRepresentationsKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPipelineExecutableInternalRepresentationsKHR_CallbackFunctionPointer(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations, Mock.vkGetPipelineExecutableInternalRepresentationsKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pInternalRepresentationCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pInternalRepresentationCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pInternalRepresentationCount, (const void*)cmock_call_instance->ReturnThruPtr_pInternalRepresentationCount_Val, + cmock_call_instance->ReturnThruPtr_pInternalRepresentationCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pInternalRepresentations_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pInternalRepresentations, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pInternalRepresentations, (const void*)cmock_call_instance->ReturnThruPtr_pInternalRepresentations_Val, + cmock_call_instance->ReturnThruPtr_pInternalRepresentations_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPipelineExecutableInternalRepresentationsKHR(CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations); +void CMockExpectParameters_vkGetPipelineExecutableInternalRepresentationsKHR(CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pExecutableInfo = pExecutableInfo; + cmock_call_instance->IgnoreArg_pExecutableInfo = 0; + cmock_call_instance->Expected_pInternalRepresentationCount = pInternalRepresentationCount; + cmock_call_instance->IgnoreArg_pInternalRepresentationCount = 0; + cmock_call_instance->ReturnThruPtr_pInternalRepresentationCount_Used = 0; + cmock_call_instance->Expected_pInternalRepresentations = pInternalRepresentations; + cmock_call_instance->IgnoreArg_pInternalRepresentations = 0; + cmock_call_instance->ReturnThruPtr_pInternalRepresentations_Used = 0; +} + +void vkGetPipelineExecutableInternalRepresentationsKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALL_INSTANCE)); + CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPipelineExecutableInternalRepresentationsKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPipelineExecutableInternalRepresentationsKHR_CallInstance, cmock_guts_index); + Mock.vkGetPipelineExecutableInternalRepresentationsKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPipelineExecutableInternalRepresentationsKHR_IgnoreBool = (char)1; +} + +void vkGetPipelineExecutableInternalRepresentationsKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetPipelineExecutableInternalRepresentationsKHR_IgnoreBool) + Mock.vkGetPipelineExecutableInternalRepresentationsKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetPipelineExecutableInternalRepresentationsKHR_CallInstance); + Mock.vkGetPipelineExecutableInternalRepresentationsKHR_IgnoreBool = (char)0; +} + +void vkGetPipelineExecutableInternalRepresentationsKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALL_INSTANCE)); + CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPipelineExecutableInternalRepresentationsKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPipelineExecutableInternalRepresentationsKHR_CallInstance, cmock_guts_index); + Mock.vkGetPipelineExecutableInternalRepresentationsKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPipelineExecutableInternalRepresentationsKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALL_INSTANCE)); + CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPipelineExecutableInternalRepresentationsKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetPipelineExecutableInternalRepresentationsKHR_CallInstance, cmock_guts_index); + Mock.vkGetPipelineExecutableInternalRepresentationsKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPipelineExecutableInternalRepresentationsKHR(cmock_call_instance, device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPipelineExecutableInternalRepresentationsKHR_AddCallback(CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALLBACK Callback) +{ + Mock.vkGetPipelineExecutableInternalRepresentationsKHR_IgnoreBool = (char)0; + Mock.vkGetPipelineExecutableInternalRepresentationsKHR_CallbackBool = (char)1; + Mock.vkGetPipelineExecutableInternalRepresentationsKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPipelineExecutableInternalRepresentationsKHR_Stub(CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALLBACK Callback) +{ + Mock.vkGetPipelineExecutableInternalRepresentationsKHR_IgnoreBool = (char)0; + Mock.vkGetPipelineExecutableInternalRepresentationsKHR_CallbackBool = (char)0; + Mock.vkGetPipelineExecutableInternalRepresentationsKHR_CallbackFunctionPointer = Callback; +} + +void vkGetPipelineExecutableInternalRepresentationsKHR_CMockReturnMemThruPtr_pInternalRepresentationCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pInternalRepresentationCount, size_t cmock_size) +{ + CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPipelineExecutableInternalRepresentationsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pInternalRepresentationCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pInternalRepresentationCount_Val = pInternalRepresentationCount; + cmock_call_instance->ReturnThruPtr_pInternalRepresentationCount_Size = cmock_size; +} + +void vkGetPipelineExecutableInternalRepresentationsKHR_CMockReturnMemThruPtr_pInternalRepresentations(UNITY_LINE_TYPE cmock_line, VkPipelineExecutableInternalRepresentationKHR const* pInternalRepresentations, size_t cmock_size) +{ + CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPipelineExecutableInternalRepresentationsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pInternalRepresentations_Used = 1; + cmock_call_instance->ReturnThruPtr_pInternalRepresentations_Val = pInternalRepresentations; + cmock_call_instance->ReturnThruPtr_pInternalRepresentations_Size = cmock_size; +} + +void vkGetPipelineExecutableInternalRepresentationsKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPipelineExecutableInternalRepresentationsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetPipelineExecutableInternalRepresentationsKHR_CMockIgnoreArg_pExecutableInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPipelineExecutableInternalRepresentationsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pExecutableInfo = 1; +} + +void vkGetPipelineExecutableInternalRepresentationsKHR_CMockIgnoreArg_pInternalRepresentationCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPipelineExecutableInternalRepresentationsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInternalRepresentationCount = 1; +} + +void vkGetPipelineExecutableInternalRepresentationsKHR_CMockIgnoreArg_pInternalRepresentations(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPipelineExecutableInternalRepresentationsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInternalRepresentations = 1; +} + +VkResult vkMapMemory2KHR(VkDevice device, const VkMemoryMapInfoKHR* pMemoryMapInfo, void** ppData) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkMapMemory2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkMapMemory2KHR); + cmock_call_instance = (CMOCK_vkMapMemory2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkMapMemory2KHR_CallInstance); + Mock.vkMapMemory2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkMapMemory2KHR_CallInstance); + if (Mock.vkMapMemory2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkMapMemory2KHR_FinalReturn; + memcpy((void*)(&Mock.vkMapMemory2KHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkMapMemory2KHR_CallbackBool && + Mock.vkMapMemory2KHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkMapMemory2KHR_CallbackFunctionPointer(device, pMemoryMapInfo, ppData, Mock.vkMapMemory2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkMapMemory2KHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMemoryMapInfo) + { + UNITY_SET_DETAILS(CMockString_vkMapMemory2KHR,CMockString_pMemoryMapInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMemoryMapInfo), (void*)(pMemoryMapInfo), sizeof(const VkMemoryMapInfoKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_ppData) + { + UNITY_SET_DETAILS(CMockString_vkMapMemory2KHR,CMockString_ppData); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_ppData, ppData, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkMapMemory2KHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkMapMemory2KHR_CallbackFunctionPointer(device, pMemoryMapInfo, ppData, Mock.vkMapMemory2KHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_ppData_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(ppData, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)ppData, (const void*)cmock_call_instance->ReturnThruPtr_ppData_Val, + cmock_call_instance->ReturnThruPtr_ppData_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkMapMemory2KHR(CMOCK_vkMapMemory2KHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkMemoryMapInfoKHR* pMemoryMapInfo, void** ppData); +void CMockExpectParameters_vkMapMemory2KHR(CMOCK_vkMapMemory2KHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkMemoryMapInfoKHR* pMemoryMapInfo, void** ppData) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pMemoryMapInfo = pMemoryMapInfo; + cmock_call_instance->IgnoreArg_pMemoryMapInfo = 0; + cmock_call_instance->Expected_ppData = ppData; + cmock_call_instance->IgnoreArg_ppData = 0; + cmock_call_instance->ReturnThruPtr_ppData_Used = 0; +} + +void vkMapMemory2KHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkMapMemory2KHR_CALL_INSTANCE)); + CMOCK_vkMapMemory2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMapMemory2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkMapMemory2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkMapMemory2KHR_CallInstance, cmock_guts_index); + Mock.vkMapMemory2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkMapMemory2KHR_IgnoreBool = (char)1; +} + +void vkMapMemory2KHR_CMockStopIgnore(void) +{ + if(Mock.vkMapMemory2KHR_IgnoreBool) + Mock.vkMapMemory2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkMapMemory2KHR_CallInstance); + Mock.vkMapMemory2KHR_IgnoreBool = (char)0; +} + +void vkMapMemory2KHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkMapMemory2KHR_CALL_INSTANCE)); + CMOCK_vkMapMemory2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMapMemory2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkMapMemory2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkMapMemory2KHR_CallInstance, cmock_guts_index); + Mock.vkMapMemory2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkMapMemory2KHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkMemoryMapInfoKHR* pMemoryMapInfo, void** ppData, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkMapMemory2KHR_CALL_INSTANCE)); + CMOCK_vkMapMemory2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMapMemory2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkMapMemory2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkMapMemory2KHR_CallInstance, cmock_guts_index); + Mock.vkMapMemory2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkMapMemory2KHR(cmock_call_instance, device, pMemoryMapInfo, ppData); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkMapMemory2KHR_AddCallback(CMOCK_vkMapMemory2KHR_CALLBACK Callback) +{ + Mock.vkMapMemory2KHR_IgnoreBool = (char)0; + Mock.vkMapMemory2KHR_CallbackBool = (char)1; + Mock.vkMapMemory2KHR_CallbackFunctionPointer = Callback; +} + +void vkMapMemory2KHR_Stub(CMOCK_vkMapMemory2KHR_CALLBACK Callback) +{ + Mock.vkMapMemory2KHR_IgnoreBool = (char)0; + Mock.vkMapMemory2KHR_CallbackBool = (char)0; + Mock.vkMapMemory2KHR_CallbackFunctionPointer = Callback; +} + +void vkMapMemory2KHR_CMockReturnMemThruPtr_ppData(UNITY_LINE_TYPE cmock_line, void* const* ppData, size_t cmock_size) +{ + CMOCK_vkMapMemory2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMapMemory2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkMapMemory2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_ppData_Used = 1; + cmock_call_instance->ReturnThruPtr_ppData_Val = ppData; + cmock_call_instance->ReturnThruPtr_ppData_Size = cmock_size; +} + +void vkMapMemory2KHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkMapMemory2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMapMemory2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkMapMemory2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkMapMemory2KHR_CMockIgnoreArg_pMemoryMapInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkMapMemory2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMapMemory2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkMapMemory2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMemoryMapInfo = 1; +} + +void vkMapMemory2KHR_CMockIgnoreArg_ppData(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkMapMemory2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMapMemory2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkMapMemory2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_ppData = 1; +} + +VkResult vkUnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkUnmapMemory2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkUnmapMemory2KHR); + cmock_call_instance = (CMOCK_vkUnmapMemory2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkUnmapMemory2KHR_CallInstance); + Mock.vkUnmapMemory2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkUnmapMemory2KHR_CallInstance); + if (Mock.vkUnmapMemory2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkUnmapMemory2KHR_FinalReturn; + memcpy((void*)(&Mock.vkUnmapMemory2KHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkUnmapMemory2KHR_CallbackBool && + Mock.vkUnmapMemory2KHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkUnmapMemory2KHR_CallbackFunctionPointer(device, pMemoryUnmapInfo, Mock.vkUnmapMemory2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkUnmapMemory2KHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMemoryUnmapInfo) + { + UNITY_SET_DETAILS(CMockString_vkUnmapMemory2KHR,CMockString_pMemoryUnmapInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMemoryUnmapInfo), (void*)(pMemoryUnmapInfo), sizeof(const VkMemoryUnmapInfoKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkUnmapMemory2KHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkUnmapMemory2KHR_CallbackFunctionPointer(device, pMemoryUnmapInfo, Mock.vkUnmapMemory2KHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkUnmapMemory2KHR(CMOCK_vkUnmapMemory2KHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo); +void CMockExpectParameters_vkUnmapMemory2KHR(CMOCK_vkUnmapMemory2KHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pMemoryUnmapInfo = pMemoryUnmapInfo; + cmock_call_instance->IgnoreArg_pMemoryUnmapInfo = 0; +} + +void vkUnmapMemory2KHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkUnmapMemory2KHR_CALL_INSTANCE)); + CMOCK_vkUnmapMemory2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUnmapMemory2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkUnmapMemory2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkUnmapMemory2KHR_CallInstance, cmock_guts_index); + Mock.vkUnmapMemory2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkUnmapMemory2KHR_IgnoreBool = (char)1; +} + +void vkUnmapMemory2KHR_CMockStopIgnore(void) +{ + if(Mock.vkUnmapMemory2KHR_IgnoreBool) + Mock.vkUnmapMemory2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkUnmapMemory2KHR_CallInstance); + Mock.vkUnmapMemory2KHR_IgnoreBool = (char)0; +} + +void vkUnmapMemory2KHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkUnmapMemory2KHR_CALL_INSTANCE)); + CMOCK_vkUnmapMemory2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUnmapMemory2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkUnmapMemory2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkUnmapMemory2KHR_CallInstance, cmock_guts_index); + Mock.vkUnmapMemory2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkUnmapMemory2KHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkUnmapMemory2KHR_CALL_INSTANCE)); + CMOCK_vkUnmapMemory2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUnmapMemory2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkUnmapMemory2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkUnmapMemory2KHR_CallInstance, cmock_guts_index); + Mock.vkUnmapMemory2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkUnmapMemory2KHR(cmock_call_instance, device, pMemoryUnmapInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkUnmapMemory2KHR_AddCallback(CMOCK_vkUnmapMemory2KHR_CALLBACK Callback) +{ + Mock.vkUnmapMemory2KHR_IgnoreBool = (char)0; + Mock.vkUnmapMemory2KHR_CallbackBool = (char)1; + Mock.vkUnmapMemory2KHR_CallbackFunctionPointer = Callback; +} + +void vkUnmapMemory2KHR_Stub(CMOCK_vkUnmapMemory2KHR_CALLBACK Callback) +{ + Mock.vkUnmapMemory2KHR_IgnoreBool = (char)0; + Mock.vkUnmapMemory2KHR_CallbackBool = (char)0; + Mock.vkUnmapMemory2KHR_CallbackFunctionPointer = Callback; +} + +void vkUnmapMemory2KHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkUnmapMemory2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUnmapMemory2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkUnmapMemory2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkUnmapMemory2KHR_CMockIgnoreArg_pMemoryUnmapInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkUnmapMemory2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUnmapMemory2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkUnmapMemory2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMemoryUnmapInfo = 1; +} + +void vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetEvent2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetEvent2KHR); + cmock_call_instance = (CMOCK_vkCmdSetEvent2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetEvent2KHR_CallInstance); + Mock.vkCmdSetEvent2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetEvent2KHR_CallInstance); + if (Mock.vkCmdSetEvent2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetEvent2KHR_CallbackBool && + Mock.vkCmdSetEvent2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetEvent2KHR_CallbackFunctionPointer(commandBuffer, event, pDependencyInfo, Mock.vkCmdSetEvent2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetEvent2KHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_event) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetEvent2KHR,CMockString_event); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_event), (void*)(&event), sizeof(VkEvent), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDependencyInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetEvent2KHR,CMockString_pDependencyInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDependencyInfo), (void*)(pDependencyInfo), sizeof(const VkDependencyInfo), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetEvent2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetEvent2KHR_CallbackFunctionPointer(commandBuffer, event, pDependencyInfo, Mock.vkCmdSetEvent2KHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetEvent2KHR(CMOCK_vkCmdSetEvent2KHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo); +void CMockExpectParameters_vkCmdSetEvent2KHR(CMOCK_vkCmdSetEvent2KHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_event), (void*)(&event), + sizeof(VkEvent[sizeof(event) == sizeof(VkEvent) ? 1 : -1])); /* add VkEvent to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_event = 0; + cmock_call_instance->Expected_pDependencyInfo = pDependencyInfo; + cmock_call_instance->IgnoreArg_pDependencyInfo = 0; +} + +void vkCmdSetEvent2KHR_CMockIgnore(void) +{ + Mock.vkCmdSetEvent2KHR_IgnoreBool = (char)1; +} + +void vkCmdSetEvent2KHR_CMockStopIgnore(void) +{ + Mock.vkCmdSetEvent2KHR_IgnoreBool = (char)0; +} + +void vkCmdSetEvent2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetEvent2KHR_CALL_INSTANCE)); + CMOCK_vkCmdSetEvent2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetEvent2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetEvent2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetEvent2KHR_CallInstance, cmock_guts_index); + Mock.vkCmdSetEvent2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetEvent2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetEvent2KHR_CALL_INSTANCE)); + CMOCK_vkCmdSetEvent2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetEvent2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetEvent2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetEvent2KHR_CallInstance, cmock_guts_index); + Mock.vkCmdSetEvent2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetEvent2KHR(cmock_call_instance, commandBuffer, event, pDependencyInfo); +} + +void vkCmdSetEvent2KHR_AddCallback(CMOCK_vkCmdSetEvent2KHR_CALLBACK Callback) +{ + Mock.vkCmdSetEvent2KHR_IgnoreBool = (char)0; + Mock.vkCmdSetEvent2KHR_CallbackBool = (char)1; + Mock.vkCmdSetEvent2KHR_CallbackFunctionPointer = Callback; +} + +void vkCmdSetEvent2KHR_Stub(CMOCK_vkCmdSetEvent2KHR_CALLBACK Callback) +{ + Mock.vkCmdSetEvent2KHR_IgnoreBool = (char)0; + Mock.vkCmdSetEvent2KHR_CallbackBool = (char)0; + Mock.vkCmdSetEvent2KHR_CallbackFunctionPointer = Callback; +} + +void vkCmdSetEvent2KHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetEvent2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetEvent2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetEvent2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetEvent2KHR_CMockIgnoreArg_event(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetEvent2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetEvent2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetEvent2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_event = 1; +} + +void vkCmdSetEvent2KHR_CMockIgnoreArg_pDependencyInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetEvent2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetEvent2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetEvent2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDependencyInfo = 1; +} + +void vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdResetEvent2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdResetEvent2KHR); + cmock_call_instance = (CMOCK_vkCmdResetEvent2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdResetEvent2KHR_CallInstance); + Mock.vkCmdResetEvent2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdResetEvent2KHR_CallInstance); + if (Mock.vkCmdResetEvent2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdResetEvent2KHR_CallbackBool && + Mock.vkCmdResetEvent2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdResetEvent2KHR_CallbackFunctionPointer(commandBuffer, event, stageMask, Mock.vkCmdResetEvent2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdResetEvent2KHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_event) + { + UNITY_SET_DETAILS(CMockString_vkCmdResetEvent2KHR,CMockString_event); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_event), (void*)(&event), sizeof(VkEvent), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_stageMask) + { + UNITY_SET_DETAILS(CMockString_vkCmdResetEvent2KHR,CMockString_stageMask); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_stageMask), (void*)(&stageMask), sizeof(VkPipelineStageFlags2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdResetEvent2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdResetEvent2KHR_CallbackFunctionPointer(commandBuffer, event, stageMask, Mock.vkCmdResetEvent2KHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdResetEvent2KHR(CMOCK_vkCmdResetEvent2KHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask); +void CMockExpectParameters_vkCmdResetEvent2KHR(CMOCK_vkCmdResetEvent2KHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_event), (void*)(&event), + sizeof(VkEvent[sizeof(event) == sizeof(VkEvent) ? 1 : -1])); /* add VkEvent to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_event = 0; + memcpy((void*)(&cmock_call_instance->Expected_stageMask), (void*)(&stageMask), + sizeof(VkPipelineStageFlags2[sizeof(stageMask) == sizeof(VkPipelineStageFlags2) ? 1 : -1])); /* add VkPipelineStageFlags2 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_stageMask = 0; +} + +void vkCmdResetEvent2KHR_CMockIgnore(void) +{ + Mock.vkCmdResetEvent2KHR_IgnoreBool = (char)1; +} + +void vkCmdResetEvent2KHR_CMockStopIgnore(void) +{ + Mock.vkCmdResetEvent2KHR_IgnoreBool = (char)0; +} + +void vkCmdResetEvent2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdResetEvent2KHR_CALL_INSTANCE)); + CMOCK_vkCmdResetEvent2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResetEvent2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdResetEvent2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdResetEvent2KHR_CallInstance, cmock_guts_index); + Mock.vkCmdResetEvent2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdResetEvent2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdResetEvent2KHR_CALL_INSTANCE)); + CMOCK_vkCmdResetEvent2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResetEvent2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdResetEvent2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdResetEvent2KHR_CallInstance, cmock_guts_index); + Mock.vkCmdResetEvent2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdResetEvent2KHR(cmock_call_instance, commandBuffer, event, stageMask); +} + +void vkCmdResetEvent2KHR_AddCallback(CMOCK_vkCmdResetEvent2KHR_CALLBACK Callback) +{ + Mock.vkCmdResetEvent2KHR_IgnoreBool = (char)0; + Mock.vkCmdResetEvent2KHR_CallbackBool = (char)1; + Mock.vkCmdResetEvent2KHR_CallbackFunctionPointer = Callback; +} + +void vkCmdResetEvent2KHR_Stub(CMOCK_vkCmdResetEvent2KHR_CALLBACK Callback) +{ + Mock.vkCmdResetEvent2KHR_IgnoreBool = (char)0; + Mock.vkCmdResetEvent2KHR_CallbackBool = (char)0; + Mock.vkCmdResetEvent2KHR_CallbackFunctionPointer = Callback; +} + +void vkCmdResetEvent2KHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdResetEvent2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResetEvent2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdResetEvent2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdResetEvent2KHR_CMockIgnoreArg_event(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdResetEvent2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResetEvent2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdResetEvent2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_event = 1; +} + +void vkCmdResetEvent2KHR_CMockIgnoreArg_stageMask(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdResetEvent2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResetEvent2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdResetEvent2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stageMask = 1; +} + +void vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdWaitEvents2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdWaitEvents2KHR); + cmock_call_instance = (CMOCK_vkCmdWaitEvents2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdWaitEvents2KHR_CallInstance); + Mock.vkCmdWaitEvents2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdWaitEvents2KHR_CallInstance); + if (Mock.vkCmdWaitEvents2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdWaitEvents2KHR_CallbackBool && + Mock.vkCmdWaitEvents2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdWaitEvents2KHR_CallbackFunctionPointer(commandBuffer, eventCount, pEvents, pDependencyInfos, Mock.vkCmdWaitEvents2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdWaitEvents2KHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_eventCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdWaitEvents2KHR,CMockString_eventCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_eventCount, eventCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pEvents) + { + UNITY_SET_DETAILS(CMockString_vkCmdWaitEvents2KHR,CMockString_pEvents); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pEvents), (void*)(pEvents), sizeof(const VkEvent), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDependencyInfos) + { + UNITY_SET_DETAILS(CMockString_vkCmdWaitEvents2KHR,CMockString_pDependencyInfos); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDependencyInfos), (void*)(pDependencyInfos), sizeof(const VkDependencyInfo), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdWaitEvents2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdWaitEvents2KHR_CallbackFunctionPointer(commandBuffer, eventCount, pEvents, pDependencyInfos, Mock.vkCmdWaitEvents2KHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdWaitEvents2KHR(CMOCK_vkCmdWaitEvents2KHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos); +void CMockExpectParameters_vkCmdWaitEvents2KHR(CMOCK_vkCmdWaitEvents2KHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_eventCount = eventCount; + cmock_call_instance->IgnoreArg_eventCount = 0; + cmock_call_instance->Expected_pEvents = pEvents; + cmock_call_instance->IgnoreArg_pEvents = 0; + cmock_call_instance->Expected_pDependencyInfos = pDependencyInfos; + cmock_call_instance->IgnoreArg_pDependencyInfos = 0; +} + +void vkCmdWaitEvents2KHR_CMockIgnore(void) +{ + Mock.vkCmdWaitEvents2KHR_IgnoreBool = (char)1; +} + +void vkCmdWaitEvents2KHR_CMockStopIgnore(void) +{ + Mock.vkCmdWaitEvents2KHR_IgnoreBool = (char)0; +} + +void vkCmdWaitEvents2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdWaitEvents2KHR_CALL_INSTANCE)); + CMOCK_vkCmdWaitEvents2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWaitEvents2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdWaitEvents2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdWaitEvents2KHR_CallInstance, cmock_guts_index); + Mock.vkCmdWaitEvents2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdWaitEvents2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdWaitEvents2KHR_CALL_INSTANCE)); + CMOCK_vkCmdWaitEvents2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWaitEvents2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdWaitEvents2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdWaitEvents2KHR_CallInstance, cmock_guts_index); + Mock.vkCmdWaitEvents2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdWaitEvents2KHR(cmock_call_instance, commandBuffer, eventCount, pEvents, pDependencyInfos); +} + +void vkCmdWaitEvents2KHR_AddCallback(CMOCK_vkCmdWaitEvents2KHR_CALLBACK Callback) +{ + Mock.vkCmdWaitEvents2KHR_IgnoreBool = (char)0; + Mock.vkCmdWaitEvents2KHR_CallbackBool = (char)1; + Mock.vkCmdWaitEvents2KHR_CallbackFunctionPointer = Callback; +} + +void vkCmdWaitEvents2KHR_Stub(CMOCK_vkCmdWaitEvents2KHR_CALLBACK Callback) +{ + Mock.vkCmdWaitEvents2KHR_IgnoreBool = (char)0; + Mock.vkCmdWaitEvents2KHR_CallbackBool = (char)0; + Mock.vkCmdWaitEvents2KHR_CallbackFunctionPointer = Callback; +} + +void vkCmdWaitEvents2KHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWaitEvents2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWaitEvents2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWaitEvents2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdWaitEvents2KHR_CMockIgnoreArg_eventCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWaitEvents2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWaitEvents2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWaitEvents2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_eventCount = 1; +} + +void vkCmdWaitEvents2KHR_CMockIgnoreArg_pEvents(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWaitEvents2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWaitEvents2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWaitEvents2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pEvents = 1; +} + +void vkCmdWaitEvents2KHR_CMockIgnoreArg_pDependencyInfos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWaitEvents2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWaitEvents2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWaitEvents2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDependencyInfos = 1; +} + +void vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdPipelineBarrier2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdPipelineBarrier2KHR); + cmock_call_instance = (CMOCK_vkCmdPipelineBarrier2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdPipelineBarrier2KHR_CallInstance); + Mock.vkCmdPipelineBarrier2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdPipelineBarrier2KHR_CallInstance); + if (Mock.vkCmdPipelineBarrier2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdPipelineBarrier2KHR_CallbackBool && + Mock.vkCmdPipelineBarrier2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdPipelineBarrier2KHR_CallbackFunctionPointer(commandBuffer, pDependencyInfo, Mock.vkCmdPipelineBarrier2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdPipelineBarrier2KHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDependencyInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdPipelineBarrier2KHR,CMockString_pDependencyInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDependencyInfo), (void*)(pDependencyInfo), sizeof(const VkDependencyInfo), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdPipelineBarrier2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdPipelineBarrier2KHR_CallbackFunctionPointer(commandBuffer, pDependencyInfo, Mock.vkCmdPipelineBarrier2KHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdPipelineBarrier2KHR(CMOCK_vkCmdPipelineBarrier2KHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo); +void CMockExpectParameters_vkCmdPipelineBarrier2KHR(CMOCK_vkCmdPipelineBarrier2KHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pDependencyInfo = pDependencyInfo; + cmock_call_instance->IgnoreArg_pDependencyInfo = 0; +} + +void vkCmdPipelineBarrier2KHR_CMockIgnore(void) +{ + Mock.vkCmdPipelineBarrier2KHR_IgnoreBool = (char)1; +} + +void vkCmdPipelineBarrier2KHR_CMockStopIgnore(void) +{ + Mock.vkCmdPipelineBarrier2KHR_IgnoreBool = (char)0; +} + +void vkCmdPipelineBarrier2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdPipelineBarrier2KHR_CALL_INSTANCE)); + CMOCK_vkCmdPipelineBarrier2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPipelineBarrier2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdPipelineBarrier2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdPipelineBarrier2KHR_CallInstance, cmock_guts_index); + Mock.vkCmdPipelineBarrier2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdPipelineBarrier2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdPipelineBarrier2KHR_CALL_INSTANCE)); + CMOCK_vkCmdPipelineBarrier2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPipelineBarrier2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdPipelineBarrier2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdPipelineBarrier2KHR_CallInstance, cmock_guts_index); + Mock.vkCmdPipelineBarrier2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdPipelineBarrier2KHR(cmock_call_instance, commandBuffer, pDependencyInfo); +} + +void vkCmdPipelineBarrier2KHR_AddCallback(CMOCK_vkCmdPipelineBarrier2KHR_CALLBACK Callback) +{ + Mock.vkCmdPipelineBarrier2KHR_IgnoreBool = (char)0; + Mock.vkCmdPipelineBarrier2KHR_CallbackBool = (char)1; + Mock.vkCmdPipelineBarrier2KHR_CallbackFunctionPointer = Callback; +} + +void vkCmdPipelineBarrier2KHR_Stub(CMOCK_vkCmdPipelineBarrier2KHR_CALLBACK Callback) +{ + Mock.vkCmdPipelineBarrier2KHR_IgnoreBool = (char)0; + Mock.vkCmdPipelineBarrier2KHR_CallbackBool = (char)0; + Mock.vkCmdPipelineBarrier2KHR_CallbackFunctionPointer = Callback; +} + +void vkCmdPipelineBarrier2KHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPipelineBarrier2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPipelineBarrier2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPipelineBarrier2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdPipelineBarrier2KHR_CMockIgnoreArg_pDependencyInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPipelineBarrier2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPipelineBarrier2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPipelineBarrier2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDependencyInfo = 1; +} + +void vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdWriteTimestamp2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdWriteTimestamp2KHR); + cmock_call_instance = (CMOCK_vkCmdWriteTimestamp2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdWriteTimestamp2KHR_CallInstance); + Mock.vkCmdWriteTimestamp2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdWriteTimestamp2KHR_CallInstance); + if (Mock.vkCmdWriteTimestamp2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdWriteTimestamp2KHR_CallbackBool && + Mock.vkCmdWriteTimestamp2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdWriteTimestamp2KHR_CallbackFunctionPointer(commandBuffer, stage, queryPool, query, Mock.vkCmdWriteTimestamp2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteTimestamp2KHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_stage) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteTimestamp2KHR,CMockString_stage); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_stage), (void*)(&stage), sizeof(VkPipelineStageFlags2), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queryPool) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteTimestamp2KHR,CMockString_queryPool); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), sizeof(VkQueryPool), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_query) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteTimestamp2KHR,CMockString_query); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_query, query, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdWriteTimestamp2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdWriteTimestamp2KHR_CallbackFunctionPointer(commandBuffer, stage, queryPool, query, Mock.vkCmdWriteTimestamp2KHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdWriteTimestamp2KHR(CMOCK_vkCmdWriteTimestamp2KHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query); +void CMockExpectParameters_vkCmdWriteTimestamp2KHR(CMOCK_vkCmdWriteTimestamp2KHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_stage), (void*)(&stage), + sizeof(VkPipelineStageFlags2[sizeof(stage) == sizeof(VkPipelineStageFlags2) ? 1 : -1])); /* add VkPipelineStageFlags2 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_stage = 0; + memcpy((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), + sizeof(VkQueryPool[sizeof(queryPool) == sizeof(VkQueryPool) ? 1 : -1])); /* add VkQueryPool to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queryPool = 0; + cmock_call_instance->Expected_query = query; + cmock_call_instance->IgnoreArg_query = 0; +} + +void vkCmdWriteTimestamp2KHR_CMockIgnore(void) +{ + Mock.vkCmdWriteTimestamp2KHR_IgnoreBool = (char)1; +} + +void vkCmdWriteTimestamp2KHR_CMockStopIgnore(void) +{ + Mock.vkCmdWriteTimestamp2KHR_IgnoreBool = (char)0; +} + +void vkCmdWriteTimestamp2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdWriteTimestamp2KHR_CALL_INSTANCE)); + CMOCK_vkCmdWriteTimestamp2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteTimestamp2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdWriteTimestamp2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdWriteTimestamp2KHR_CallInstance, cmock_guts_index); + Mock.vkCmdWriteTimestamp2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdWriteTimestamp2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdWriteTimestamp2KHR_CALL_INSTANCE)); + CMOCK_vkCmdWriteTimestamp2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteTimestamp2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdWriteTimestamp2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdWriteTimestamp2KHR_CallInstance, cmock_guts_index); + Mock.vkCmdWriteTimestamp2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdWriteTimestamp2KHR(cmock_call_instance, commandBuffer, stage, queryPool, query); +} + +void vkCmdWriteTimestamp2KHR_AddCallback(CMOCK_vkCmdWriteTimestamp2KHR_CALLBACK Callback) +{ + Mock.vkCmdWriteTimestamp2KHR_IgnoreBool = (char)0; + Mock.vkCmdWriteTimestamp2KHR_CallbackBool = (char)1; + Mock.vkCmdWriteTimestamp2KHR_CallbackFunctionPointer = Callback; +} + +void vkCmdWriteTimestamp2KHR_Stub(CMOCK_vkCmdWriteTimestamp2KHR_CALLBACK Callback) +{ + Mock.vkCmdWriteTimestamp2KHR_IgnoreBool = (char)0; + Mock.vkCmdWriteTimestamp2KHR_CallbackBool = (char)0; + Mock.vkCmdWriteTimestamp2KHR_CallbackFunctionPointer = Callback; +} + +void vkCmdWriteTimestamp2KHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteTimestamp2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteTimestamp2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteTimestamp2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdWriteTimestamp2KHR_CMockIgnoreArg_stage(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteTimestamp2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteTimestamp2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteTimestamp2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stage = 1; +} + +void vkCmdWriteTimestamp2KHR_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteTimestamp2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteTimestamp2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteTimestamp2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queryPool = 1; +} + +void vkCmdWriteTimestamp2KHR_CMockIgnoreArg_query(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteTimestamp2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteTimestamp2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteTimestamp2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_query = 1; +} + +VkResult vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkQueueSubmit2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkQueueSubmit2KHR); + cmock_call_instance = (CMOCK_vkQueueSubmit2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkQueueSubmit2KHR_CallInstance); + Mock.vkQueueSubmit2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkQueueSubmit2KHR_CallInstance); + if (Mock.vkQueueSubmit2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkQueueSubmit2KHR_FinalReturn; + memcpy((void*)(&Mock.vkQueueSubmit2KHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkQueueSubmit2KHR_CallbackBool && + Mock.vkQueueSubmit2KHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkQueueSubmit2KHR_CallbackFunctionPointer(queue, submitCount, pSubmits, fence, Mock.vkQueueSubmit2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_queue) + { + UNITY_SET_DETAILS(CMockString_vkQueueSubmit2KHR,CMockString_queue); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queue), (void*)(&queue), sizeof(VkQueue), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_submitCount) + { + UNITY_SET_DETAILS(CMockString_vkQueueSubmit2KHR,CMockString_submitCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_submitCount, submitCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSubmits) + { + UNITY_SET_DETAILS(CMockString_vkQueueSubmit2KHR,CMockString_pSubmits); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSubmits), (void*)(pSubmits), sizeof(const VkSubmitInfo2), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_fence) + { + UNITY_SET_DETAILS(CMockString_vkQueueSubmit2KHR,CMockString_fence); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_fence), (void*)(&fence), sizeof(VkFence), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkQueueSubmit2KHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkQueueSubmit2KHR_CallbackFunctionPointer(queue, submitCount, pSubmits, fence, Mock.vkQueueSubmit2KHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkQueueSubmit2KHR(CMOCK_vkQueueSubmit2KHR_CALL_INSTANCE* cmock_call_instance, VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence); +void CMockExpectParameters_vkQueueSubmit2KHR(CMOCK_vkQueueSubmit2KHR_CALL_INSTANCE* cmock_call_instance, VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) +{ + memcpy((void*)(&cmock_call_instance->Expected_queue), (void*)(&queue), + sizeof(VkQueue[sizeof(queue) == sizeof(VkQueue) ? 1 : -1])); /* add VkQueue to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queue = 0; + cmock_call_instance->Expected_submitCount = submitCount; + cmock_call_instance->IgnoreArg_submitCount = 0; + cmock_call_instance->Expected_pSubmits = pSubmits; + cmock_call_instance->IgnoreArg_pSubmits = 0; + memcpy((void*)(&cmock_call_instance->Expected_fence), (void*)(&fence), + sizeof(VkFence[sizeof(fence) == sizeof(VkFence) ? 1 : -1])); /* add VkFence to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_fence = 0; +} + +void vkQueueSubmit2KHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkQueueSubmit2KHR_CALL_INSTANCE)); + CMOCK_vkQueueSubmit2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueSubmit2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkQueueSubmit2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkQueueSubmit2KHR_CallInstance, cmock_guts_index); + Mock.vkQueueSubmit2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkQueueSubmit2KHR_IgnoreBool = (char)1; +} + +void vkQueueSubmit2KHR_CMockStopIgnore(void) +{ + if(Mock.vkQueueSubmit2KHR_IgnoreBool) + Mock.vkQueueSubmit2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkQueueSubmit2KHR_CallInstance); + Mock.vkQueueSubmit2KHR_IgnoreBool = (char)0; +} + +void vkQueueSubmit2KHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkQueueSubmit2KHR_CALL_INSTANCE)); + CMOCK_vkQueueSubmit2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueSubmit2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkQueueSubmit2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkQueueSubmit2KHR_CallInstance, cmock_guts_index); + Mock.vkQueueSubmit2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkQueueSubmit2KHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkQueueSubmit2KHR_CALL_INSTANCE)); + CMOCK_vkQueueSubmit2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueSubmit2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkQueueSubmit2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkQueueSubmit2KHR_CallInstance, cmock_guts_index); + Mock.vkQueueSubmit2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkQueueSubmit2KHR(cmock_call_instance, queue, submitCount, pSubmits, fence); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkQueueSubmit2KHR_AddCallback(CMOCK_vkQueueSubmit2KHR_CALLBACK Callback) +{ + Mock.vkQueueSubmit2KHR_IgnoreBool = (char)0; + Mock.vkQueueSubmit2KHR_CallbackBool = (char)1; + Mock.vkQueueSubmit2KHR_CallbackFunctionPointer = Callback; +} + +void vkQueueSubmit2KHR_Stub(CMOCK_vkQueueSubmit2KHR_CALLBACK Callback) +{ + Mock.vkQueueSubmit2KHR_IgnoreBool = (char)0; + Mock.vkQueueSubmit2KHR_CallbackBool = (char)0; + Mock.vkQueueSubmit2KHR_CallbackFunctionPointer = Callback; +} + +void vkQueueSubmit2KHR_CMockIgnoreArg_queue(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkQueueSubmit2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueSubmit2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkQueueSubmit2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queue = 1; +} + +void vkQueueSubmit2KHR_CMockIgnoreArg_submitCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkQueueSubmit2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueSubmit2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkQueueSubmit2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_submitCount = 1; +} + +void vkQueueSubmit2KHR_CMockIgnoreArg_pSubmits(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkQueueSubmit2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueSubmit2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkQueueSubmit2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSubmits = 1; +} + +void vkQueueSubmit2KHR_CMockIgnoreArg_fence(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkQueueSubmit2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueSubmit2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkQueueSubmit2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_fence = 1; +} + +void vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdWriteBufferMarker2AMD_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdWriteBufferMarker2AMD); + cmock_call_instance = (CMOCK_vkCmdWriteBufferMarker2AMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdWriteBufferMarker2AMD_CallInstance); + Mock.vkCmdWriteBufferMarker2AMD_CallInstance = CMock_Guts_MemNext(Mock.vkCmdWriteBufferMarker2AMD_CallInstance); + if (Mock.vkCmdWriteBufferMarker2AMD_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdWriteBufferMarker2AMD_CallbackBool && + Mock.vkCmdWriteBufferMarker2AMD_CallbackFunctionPointer != NULL) + { + Mock.vkCmdWriteBufferMarker2AMD_CallbackFunctionPointer(commandBuffer, stage, dstBuffer, dstOffset, marker, Mock.vkCmdWriteBufferMarker2AMD_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteBufferMarker2AMD,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_stage) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteBufferMarker2AMD,CMockString_stage); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_stage), (void*)(&stage), sizeof(VkPipelineStageFlags2), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dstBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteBufferMarker2AMD,CMockString_dstBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dstBuffer), (void*)(&dstBuffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dstOffset) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteBufferMarker2AMD,CMockString_dstOffset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dstOffset), (void*)(&dstOffset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_marker) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteBufferMarker2AMD,CMockString_marker); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_marker, marker, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdWriteBufferMarker2AMD_CallbackFunctionPointer != NULL) + { + Mock.vkCmdWriteBufferMarker2AMD_CallbackFunctionPointer(commandBuffer, stage, dstBuffer, dstOffset, marker, Mock.vkCmdWriteBufferMarker2AMD_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdWriteBufferMarker2AMD(CMOCK_vkCmdWriteBufferMarker2AMD_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker); +void CMockExpectParameters_vkCmdWriteBufferMarker2AMD(CMOCK_vkCmdWriteBufferMarker2AMD_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_stage), (void*)(&stage), + sizeof(VkPipelineStageFlags2[sizeof(stage) == sizeof(VkPipelineStageFlags2) ? 1 : -1])); /* add VkPipelineStageFlags2 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_stage = 0; + memcpy((void*)(&cmock_call_instance->Expected_dstBuffer), (void*)(&dstBuffer), + sizeof(VkBuffer[sizeof(dstBuffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dstBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_dstOffset), (void*)(&dstOffset), + sizeof(VkDeviceSize[sizeof(dstOffset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dstOffset = 0; + cmock_call_instance->Expected_marker = marker; + cmock_call_instance->IgnoreArg_marker = 0; +} + +void vkCmdWriteBufferMarker2AMD_CMockIgnore(void) +{ + Mock.vkCmdWriteBufferMarker2AMD_IgnoreBool = (char)1; +} + +void vkCmdWriteBufferMarker2AMD_CMockStopIgnore(void) +{ + Mock.vkCmdWriteBufferMarker2AMD_IgnoreBool = (char)0; +} + +void vkCmdWriteBufferMarker2AMD_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdWriteBufferMarker2AMD_CALL_INSTANCE)); + CMOCK_vkCmdWriteBufferMarker2AMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteBufferMarker2AMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdWriteBufferMarker2AMD_CallInstance = CMock_Guts_MemChain(Mock.vkCmdWriteBufferMarker2AMD_CallInstance, cmock_guts_index); + Mock.vkCmdWriteBufferMarker2AMD_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdWriteBufferMarker2AMD_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdWriteBufferMarker2AMD_CALL_INSTANCE)); + CMOCK_vkCmdWriteBufferMarker2AMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteBufferMarker2AMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdWriteBufferMarker2AMD_CallInstance = CMock_Guts_MemChain(Mock.vkCmdWriteBufferMarker2AMD_CallInstance, cmock_guts_index); + Mock.vkCmdWriteBufferMarker2AMD_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdWriteBufferMarker2AMD(cmock_call_instance, commandBuffer, stage, dstBuffer, dstOffset, marker); +} + +void vkCmdWriteBufferMarker2AMD_AddCallback(CMOCK_vkCmdWriteBufferMarker2AMD_CALLBACK Callback) +{ + Mock.vkCmdWriteBufferMarker2AMD_IgnoreBool = (char)0; + Mock.vkCmdWriteBufferMarker2AMD_CallbackBool = (char)1; + Mock.vkCmdWriteBufferMarker2AMD_CallbackFunctionPointer = Callback; +} + +void vkCmdWriteBufferMarker2AMD_Stub(CMOCK_vkCmdWriteBufferMarker2AMD_CALLBACK Callback) +{ + Mock.vkCmdWriteBufferMarker2AMD_IgnoreBool = (char)0; + Mock.vkCmdWriteBufferMarker2AMD_CallbackBool = (char)0; + Mock.vkCmdWriteBufferMarker2AMD_CallbackFunctionPointer = Callback; +} + +void vkCmdWriteBufferMarker2AMD_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteBufferMarker2AMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteBufferMarker2AMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteBufferMarker2AMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdWriteBufferMarker2AMD_CMockIgnoreArg_stage(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteBufferMarker2AMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteBufferMarker2AMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteBufferMarker2AMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stage = 1; +} + +void vkCmdWriteBufferMarker2AMD_CMockIgnoreArg_dstBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteBufferMarker2AMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteBufferMarker2AMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteBufferMarker2AMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dstBuffer = 1; +} + +void vkCmdWriteBufferMarker2AMD_CMockIgnoreArg_dstOffset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteBufferMarker2AMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteBufferMarker2AMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteBufferMarker2AMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dstOffset = 1; +} + +void vkCmdWriteBufferMarker2AMD_CMockIgnoreArg_marker(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteBufferMarker2AMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteBufferMarker2AMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteBufferMarker2AMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_marker = 1; +} + +void vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetQueueCheckpointData2NV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetQueueCheckpointData2NV); + cmock_call_instance = (CMOCK_vkGetQueueCheckpointData2NV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetQueueCheckpointData2NV_CallInstance); + Mock.vkGetQueueCheckpointData2NV_CallInstance = CMock_Guts_MemNext(Mock.vkGetQueueCheckpointData2NV_CallInstance); + if (Mock.vkGetQueueCheckpointData2NV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetQueueCheckpointData2NV_CallbackBool && + Mock.vkGetQueueCheckpointData2NV_CallbackFunctionPointer != NULL) + { + Mock.vkGetQueueCheckpointData2NV_CallbackFunctionPointer(queue, pCheckpointDataCount, pCheckpointData, Mock.vkGetQueueCheckpointData2NV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_queue) + { + UNITY_SET_DETAILS(CMockString_vkGetQueueCheckpointData2NV,CMockString_queue); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queue), (void*)(&queue), sizeof(VkQueue), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCheckpointDataCount) + { + UNITY_SET_DETAILS(CMockString_vkGetQueueCheckpointData2NV,CMockString_pCheckpointDataCount); + if (cmock_call_instance->Expected_pCheckpointDataCount == NULL) + { UNITY_TEST_ASSERT_NULL(pCheckpointDataCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pCheckpointDataCount, pCheckpointDataCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pCheckpointData) + { + UNITY_SET_DETAILS(CMockString_vkGetQueueCheckpointData2NV,CMockString_pCheckpointData); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCheckpointData), (void*)(pCheckpointData), sizeof(VkCheckpointData2NV), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetQueueCheckpointData2NV_CallbackFunctionPointer != NULL) + { + Mock.vkGetQueueCheckpointData2NV_CallbackFunctionPointer(queue, pCheckpointDataCount, pCheckpointData, Mock.vkGetQueueCheckpointData2NV_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pCheckpointDataCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pCheckpointDataCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pCheckpointDataCount, (const void*)cmock_call_instance->ReturnThruPtr_pCheckpointDataCount_Val, + cmock_call_instance->ReturnThruPtr_pCheckpointDataCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pCheckpointData_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pCheckpointData, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pCheckpointData, (const void*)cmock_call_instance->ReturnThruPtr_pCheckpointData_Val, + cmock_call_instance->ReturnThruPtr_pCheckpointData_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetQueueCheckpointData2NV(CMOCK_vkGetQueueCheckpointData2NV_CALL_INSTANCE* cmock_call_instance, VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData); +void CMockExpectParameters_vkGetQueueCheckpointData2NV(CMOCK_vkGetQueueCheckpointData2NV_CALL_INSTANCE* cmock_call_instance, VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData) +{ + memcpy((void*)(&cmock_call_instance->Expected_queue), (void*)(&queue), + sizeof(VkQueue[sizeof(queue) == sizeof(VkQueue) ? 1 : -1])); /* add VkQueue to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queue = 0; + cmock_call_instance->Expected_pCheckpointDataCount = pCheckpointDataCount; + cmock_call_instance->IgnoreArg_pCheckpointDataCount = 0; + cmock_call_instance->ReturnThruPtr_pCheckpointDataCount_Used = 0; + cmock_call_instance->Expected_pCheckpointData = pCheckpointData; + cmock_call_instance->IgnoreArg_pCheckpointData = 0; + cmock_call_instance->ReturnThruPtr_pCheckpointData_Used = 0; +} + +void vkGetQueueCheckpointData2NV_CMockIgnore(void) +{ + Mock.vkGetQueueCheckpointData2NV_IgnoreBool = (char)1; +} + +void vkGetQueueCheckpointData2NV_CMockStopIgnore(void) +{ + Mock.vkGetQueueCheckpointData2NV_IgnoreBool = (char)0; +} + +void vkGetQueueCheckpointData2NV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetQueueCheckpointData2NV_CALL_INSTANCE)); + CMOCK_vkGetQueueCheckpointData2NV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetQueueCheckpointData2NV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetQueueCheckpointData2NV_CallInstance = CMock_Guts_MemChain(Mock.vkGetQueueCheckpointData2NV_CallInstance, cmock_guts_index); + Mock.vkGetQueueCheckpointData2NV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetQueueCheckpointData2NV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetQueueCheckpointData2NV_CALL_INSTANCE)); + CMOCK_vkGetQueueCheckpointData2NV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetQueueCheckpointData2NV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetQueueCheckpointData2NV_CallInstance = CMock_Guts_MemChain(Mock.vkGetQueueCheckpointData2NV_CallInstance, cmock_guts_index); + Mock.vkGetQueueCheckpointData2NV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetQueueCheckpointData2NV(cmock_call_instance, queue, pCheckpointDataCount, pCheckpointData); +} + +void vkGetQueueCheckpointData2NV_AddCallback(CMOCK_vkGetQueueCheckpointData2NV_CALLBACK Callback) +{ + Mock.vkGetQueueCheckpointData2NV_IgnoreBool = (char)0; + Mock.vkGetQueueCheckpointData2NV_CallbackBool = (char)1; + Mock.vkGetQueueCheckpointData2NV_CallbackFunctionPointer = Callback; +} + +void vkGetQueueCheckpointData2NV_Stub(CMOCK_vkGetQueueCheckpointData2NV_CALLBACK Callback) +{ + Mock.vkGetQueueCheckpointData2NV_IgnoreBool = (char)0; + Mock.vkGetQueueCheckpointData2NV_CallbackBool = (char)0; + Mock.vkGetQueueCheckpointData2NV_CallbackFunctionPointer = Callback; +} + +void vkGetQueueCheckpointData2NV_CMockReturnMemThruPtr_pCheckpointDataCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pCheckpointDataCount, size_t cmock_size) +{ + CMOCK_vkGetQueueCheckpointData2NV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetQueueCheckpointData2NV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetQueueCheckpointData2NV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pCheckpointDataCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pCheckpointDataCount_Val = pCheckpointDataCount; + cmock_call_instance->ReturnThruPtr_pCheckpointDataCount_Size = cmock_size; +} + +void vkGetQueueCheckpointData2NV_CMockReturnMemThruPtr_pCheckpointData(UNITY_LINE_TYPE cmock_line, VkCheckpointData2NV const* pCheckpointData, size_t cmock_size) +{ + CMOCK_vkGetQueueCheckpointData2NV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetQueueCheckpointData2NV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetQueueCheckpointData2NV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pCheckpointData_Used = 1; + cmock_call_instance->ReturnThruPtr_pCheckpointData_Val = pCheckpointData; + cmock_call_instance->ReturnThruPtr_pCheckpointData_Size = cmock_size; +} + +void vkGetQueueCheckpointData2NV_CMockIgnoreArg_queue(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetQueueCheckpointData2NV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetQueueCheckpointData2NV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetQueueCheckpointData2NV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queue = 1; +} + +void vkGetQueueCheckpointData2NV_CMockIgnoreArg_pCheckpointDataCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetQueueCheckpointData2NV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetQueueCheckpointData2NV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetQueueCheckpointData2NV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCheckpointDataCount = 1; +} + +void vkGetQueueCheckpointData2NV_CMockIgnoreArg_pCheckpointData(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetQueueCheckpointData2NV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetQueueCheckpointData2NV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetQueueCheckpointData2NV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCheckpointData = 1; +} + +void vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdCopyBuffer2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdCopyBuffer2KHR); + cmock_call_instance = (CMOCK_vkCmdCopyBuffer2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdCopyBuffer2KHR_CallInstance); + Mock.vkCmdCopyBuffer2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdCopyBuffer2KHR_CallInstance); + if (Mock.vkCmdCopyBuffer2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdCopyBuffer2KHR_CallbackBool && + Mock.vkCmdCopyBuffer2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyBuffer2KHR_CallbackFunctionPointer(commandBuffer, pCopyBufferInfo, Mock.vkCmdCopyBuffer2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyBuffer2KHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCopyBufferInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyBuffer2KHR,CMockString_pCopyBufferInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCopyBufferInfo), (void*)(pCopyBufferInfo), sizeof(const VkCopyBufferInfo2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdCopyBuffer2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyBuffer2KHR_CallbackFunctionPointer(commandBuffer, pCopyBufferInfo, Mock.vkCmdCopyBuffer2KHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdCopyBuffer2KHR(CMOCK_vkCmdCopyBuffer2KHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo); +void CMockExpectParameters_vkCmdCopyBuffer2KHR(CMOCK_vkCmdCopyBuffer2KHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pCopyBufferInfo = pCopyBufferInfo; + cmock_call_instance->IgnoreArg_pCopyBufferInfo = 0; +} + +void vkCmdCopyBuffer2KHR_CMockIgnore(void) +{ + Mock.vkCmdCopyBuffer2KHR_IgnoreBool = (char)1; +} + +void vkCmdCopyBuffer2KHR_CMockStopIgnore(void) +{ + Mock.vkCmdCopyBuffer2KHR_IgnoreBool = (char)0; +} + +void vkCmdCopyBuffer2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyBuffer2KHR_CALL_INSTANCE)); + CMOCK_vkCmdCopyBuffer2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBuffer2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyBuffer2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyBuffer2KHR_CallInstance, cmock_guts_index); + Mock.vkCmdCopyBuffer2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdCopyBuffer2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyBuffer2KHR_CALL_INSTANCE)); + CMOCK_vkCmdCopyBuffer2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBuffer2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyBuffer2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyBuffer2KHR_CallInstance, cmock_guts_index); + Mock.vkCmdCopyBuffer2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdCopyBuffer2KHR(cmock_call_instance, commandBuffer, pCopyBufferInfo); +} + +void vkCmdCopyBuffer2KHR_AddCallback(CMOCK_vkCmdCopyBuffer2KHR_CALLBACK Callback) +{ + Mock.vkCmdCopyBuffer2KHR_IgnoreBool = (char)0; + Mock.vkCmdCopyBuffer2KHR_CallbackBool = (char)1; + Mock.vkCmdCopyBuffer2KHR_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyBuffer2KHR_Stub(CMOCK_vkCmdCopyBuffer2KHR_CALLBACK Callback) +{ + Mock.vkCmdCopyBuffer2KHR_IgnoreBool = (char)0; + Mock.vkCmdCopyBuffer2KHR_CallbackBool = (char)0; + Mock.vkCmdCopyBuffer2KHR_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyBuffer2KHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyBuffer2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBuffer2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyBuffer2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdCopyBuffer2KHR_CMockIgnoreArg_pCopyBufferInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyBuffer2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBuffer2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyBuffer2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCopyBufferInfo = 1; +} + +void vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdCopyImage2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdCopyImage2KHR); + cmock_call_instance = (CMOCK_vkCmdCopyImage2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdCopyImage2KHR_CallInstance); + Mock.vkCmdCopyImage2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdCopyImage2KHR_CallInstance); + if (Mock.vkCmdCopyImage2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdCopyImage2KHR_CallbackBool && + Mock.vkCmdCopyImage2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyImage2KHR_CallbackFunctionPointer(commandBuffer, pCopyImageInfo, Mock.vkCmdCopyImage2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyImage2KHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCopyImageInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyImage2KHR,CMockString_pCopyImageInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCopyImageInfo), (void*)(pCopyImageInfo), sizeof(const VkCopyImageInfo2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdCopyImage2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyImage2KHR_CallbackFunctionPointer(commandBuffer, pCopyImageInfo, Mock.vkCmdCopyImage2KHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdCopyImage2KHR(CMOCK_vkCmdCopyImage2KHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo); +void CMockExpectParameters_vkCmdCopyImage2KHR(CMOCK_vkCmdCopyImage2KHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pCopyImageInfo = pCopyImageInfo; + cmock_call_instance->IgnoreArg_pCopyImageInfo = 0; +} + +void vkCmdCopyImage2KHR_CMockIgnore(void) +{ + Mock.vkCmdCopyImage2KHR_IgnoreBool = (char)1; +} + +void vkCmdCopyImage2KHR_CMockStopIgnore(void) +{ + Mock.vkCmdCopyImage2KHR_IgnoreBool = (char)0; +} + +void vkCmdCopyImage2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyImage2KHR_CALL_INSTANCE)); + CMOCK_vkCmdCopyImage2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImage2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyImage2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyImage2KHR_CallInstance, cmock_guts_index); + Mock.vkCmdCopyImage2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdCopyImage2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyImage2KHR_CALL_INSTANCE)); + CMOCK_vkCmdCopyImage2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImage2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyImage2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyImage2KHR_CallInstance, cmock_guts_index); + Mock.vkCmdCopyImage2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdCopyImage2KHR(cmock_call_instance, commandBuffer, pCopyImageInfo); +} + +void vkCmdCopyImage2KHR_AddCallback(CMOCK_vkCmdCopyImage2KHR_CALLBACK Callback) +{ + Mock.vkCmdCopyImage2KHR_IgnoreBool = (char)0; + Mock.vkCmdCopyImage2KHR_CallbackBool = (char)1; + Mock.vkCmdCopyImage2KHR_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyImage2KHR_Stub(CMOCK_vkCmdCopyImage2KHR_CALLBACK Callback) +{ + Mock.vkCmdCopyImage2KHR_IgnoreBool = (char)0; + Mock.vkCmdCopyImage2KHR_CallbackBool = (char)0; + Mock.vkCmdCopyImage2KHR_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyImage2KHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyImage2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImage2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyImage2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdCopyImage2KHR_CMockIgnoreArg_pCopyImageInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyImage2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImage2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyImage2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCopyImageInfo = 1; +} + +void vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdCopyBufferToImage2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdCopyBufferToImage2KHR); + cmock_call_instance = (CMOCK_vkCmdCopyBufferToImage2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdCopyBufferToImage2KHR_CallInstance); + Mock.vkCmdCopyBufferToImage2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdCopyBufferToImage2KHR_CallInstance); + if (Mock.vkCmdCopyBufferToImage2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdCopyBufferToImage2KHR_CallbackBool && + Mock.vkCmdCopyBufferToImage2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyBufferToImage2KHR_CallbackFunctionPointer(commandBuffer, pCopyBufferToImageInfo, Mock.vkCmdCopyBufferToImage2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyBufferToImage2KHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCopyBufferToImageInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyBufferToImage2KHR,CMockString_pCopyBufferToImageInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCopyBufferToImageInfo), (void*)(pCopyBufferToImageInfo), sizeof(const VkCopyBufferToImageInfo2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdCopyBufferToImage2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyBufferToImage2KHR_CallbackFunctionPointer(commandBuffer, pCopyBufferToImageInfo, Mock.vkCmdCopyBufferToImage2KHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdCopyBufferToImage2KHR(CMOCK_vkCmdCopyBufferToImage2KHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); +void CMockExpectParameters_vkCmdCopyBufferToImage2KHR(CMOCK_vkCmdCopyBufferToImage2KHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pCopyBufferToImageInfo = pCopyBufferToImageInfo; + cmock_call_instance->IgnoreArg_pCopyBufferToImageInfo = 0; +} + +void vkCmdCopyBufferToImage2KHR_CMockIgnore(void) +{ + Mock.vkCmdCopyBufferToImage2KHR_IgnoreBool = (char)1; +} + +void vkCmdCopyBufferToImage2KHR_CMockStopIgnore(void) +{ + Mock.vkCmdCopyBufferToImage2KHR_IgnoreBool = (char)0; +} + +void vkCmdCopyBufferToImage2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyBufferToImage2KHR_CALL_INSTANCE)); + CMOCK_vkCmdCopyBufferToImage2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBufferToImage2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyBufferToImage2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyBufferToImage2KHR_CallInstance, cmock_guts_index); + Mock.vkCmdCopyBufferToImage2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdCopyBufferToImage2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyBufferToImage2KHR_CALL_INSTANCE)); + CMOCK_vkCmdCopyBufferToImage2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBufferToImage2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyBufferToImage2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyBufferToImage2KHR_CallInstance, cmock_guts_index); + Mock.vkCmdCopyBufferToImage2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdCopyBufferToImage2KHR(cmock_call_instance, commandBuffer, pCopyBufferToImageInfo); +} + +void vkCmdCopyBufferToImage2KHR_AddCallback(CMOCK_vkCmdCopyBufferToImage2KHR_CALLBACK Callback) +{ + Mock.vkCmdCopyBufferToImage2KHR_IgnoreBool = (char)0; + Mock.vkCmdCopyBufferToImage2KHR_CallbackBool = (char)1; + Mock.vkCmdCopyBufferToImage2KHR_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyBufferToImage2KHR_Stub(CMOCK_vkCmdCopyBufferToImage2KHR_CALLBACK Callback) +{ + Mock.vkCmdCopyBufferToImage2KHR_IgnoreBool = (char)0; + Mock.vkCmdCopyBufferToImage2KHR_CallbackBool = (char)0; + Mock.vkCmdCopyBufferToImage2KHR_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyBufferToImage2KHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyBufferToImage2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBufferToImage2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyBufferToImage2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdCopyBufferToImage2KHR_CMockIgnoreArg_pCopyBufferToImageInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyBufferToImage2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyBufferToImage2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyBufferToImage2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCopyBufferToImageInfo = 1; +} + +void vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdCopyImageToBuffer2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdCopyImageToBuffer2KHR); + cmock_call_instance = (CMOCK_vkCmdCopyImageToBuffer2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdCopyImageToBuffer2KHR_CallInstance); + Mock.vkCmdCopyImageToBuffer2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdCopyImageToBuffer2KHR_CallInstance); + if (Mock.vkCmdCopyImageToBuffer2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdCopyImageToBuffer2KHR_CallbackBool && + Mock.vkCmdCopyImageToBuffer2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyImageToBuffer2KHR_CallbackFunctionPointer(commandBuffer, pCopyImageToBufferInfo, Mock.vkCmdCopyImageToBuffer2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyImageToBuffer2KHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCopyImageToBufferInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyImageToBuffer2KHR,CMockString_pCopyImageToBufferInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCopyImageToBufferInfo), (void*)(pCopyImageToBufferInfo), sizeof(const VkCopyImageToBufferInfo2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdCopyImageToBuffer2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyImageToBuffer2KHR_CallbackFunctionPointer(commandBuffer, pCopyImageToBufferInfo, Mock.vkCmdCopyImageToBuffer2KHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdCopyImageToBuffer2KHR(CMOCK_vkCmdCopyImageToBuffer2KHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); +void CMockExpectParameters_vkCmdCopyImageToBuffer2KHR(CMOCK_vkCmdCopyImageToBuffer2KHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pCopyImageToBufferInfo = pCopyImageToBufferInfo; + cmock_call_instance->IgnoreArg_pCopyImageToBufferInfo = 0; +} + +void vkCmdCopyImageToBuffer2KHR_CMockIgnore(void) +{ + Mock.vkCmdCopyImageToBuffer2KHR_IgnoreBool = (char)1; +} + +void vkCmdCopyImageToBuffer2KHR_CMockStopIgnore(void) +{ + Mock.vkCmdCopyImageToBuffer2KHR_IgnoreBool = (char)0; +} + +void vkCmdCopyImageToBuffer2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyImageToBuffer2KHR_CALL_INSTANCE)); + CMOCK_vkCmdCopyImageToBuffer2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImageToBuffer2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyImageToBuffer2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyImageToBuffer2KHR_CallInstance, cmock_guts_index); + Mock.vkCmdCopyImageToBuffer2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdCopyImageToBuffer2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyImageToBuffer2KHR_CALL_INSTANCE)); + CMOCK_vkCmdCopyImageToBuffer2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImageToBuffer2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyImageToBuffer2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyImageToBuffer2KHR_CallInstance, cmock_guts_index); + Mock.vkCmdCopyImageToBuffer2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdCopyImageToBuffer2KHR(cmock_call_instance, commandBuffer, pCopyImageToBufferInfo); +} + +void vkCmdCopyImageToBuffer2KHR_AddCallback(CMOCK_vkCmdCopyImageToBuffer2KHR_CALLBACK Callback) +{ + Mock.vkCmdCopyImageToBuffer2KHR_IgnoreBool = (char)0; + Mock.vkCmdCopyImageToBuffer2KHR_CallbackBool = (char)1; + Mock.vkCmdCopyImageToBuffer2KHR_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyImageToBuffer2KHR_Stub(CMOCK_vkCmdCopyImageToBuffer2KHR_CALLBACK Callback) +{ + Mock.vkCmdCopyImageToBuffer2KHR_IgnoreBool = (char)0; + Mock.vkCmdCopyImageToBuffer2KHR_CallbackBool = (char)0; + Mock.vkCmdCopyImageToBuffer2KHR_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyImageToBuffer2KHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyImageToBuffer2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImageToBuffer2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyImageToBuffer2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdCopyImageToBuffer2KHR_CMockIgnoreArg_pCopyImageToBufferInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyImageToBuffer2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyImageToBuffer2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyImageToBuffer2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCopyImageToBufferInfo = 1; +} + +void vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBlitImage2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBlitImage2KHR); + cmock_call_instance = (CMOCK_vkCmdBlitImage2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBlitImage2KHR_CallInstance); + Mock.vkCmdBlitImage2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBlitImage2KHR_CallInstance); + if (Mock.vkCmdBlitImage2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBlitImage2KHR_CallbackBool && + Mock.vkCmdBlitImage2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBlitImage2KHR_CallbackFunctionPointer(commandBuffer, pBlitImageInfo, Mock.vkCmdBlitImage2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBlitImage2KHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pBlitImageInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdBlitImage2KHR,CMockString_pBlitImageInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pBlitImageInfo), (void*)(pBlitImageInfo), sizeof(const VkBlitImageInfo2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdBlitImage2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBlitImage2KHR_CallbackFunctionPointer(commandBuffer, pBlitImageInfo, Mock.vkCmdBlitImage2KHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBlitImage2KHR(CMOCK_vkCmdBlitImage2KHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo); +void CMockExpectParameters_vkCmdBlitImage2KHR(CMOCK_vkCmdBlitImage2KHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pBlitImageInfo = pBlitImageInfo; + cmock_call_instance->IgnoreArg_pBlitImageInfo = 0; +} + +void vkCmdBlitImage2KHR_CMockIgnore(void) +{ + Mock.vkCmdBlitImage2KHR_IgnoreBool = (char)1; +} + +void vkCmdBlitImage2KHR_CMockStopIgnore(void) +{ + Mock.vkCmdBlitImage2KHR_IgnoreBool = (char)0; +} + +void vkCmdBlitImage2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBlitImage2KHR_CALL_INSTANCE)); + CMOCK_vkCmdBlitImage2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBlitImage2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBlitImage2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBlitImage2KHR_CallInstance, cmock_guts_index); + Mock.vkCmdBlitImage2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBlitImage2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBlitImage2KHR_CALL_INSTANCE)); + CMOCK_vkCmdBlitImage2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBlitImage2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBlitImage2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBlitImage2KHR_CallInstance, cmock_guts_index); + Mock.vkCmdBlitImage2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBlitImage2KHR(cmock_call_instance, commandBuffer, pBlitImageInfo); +} + +void vkCmdBlitImage2KHR_AddCallback(CMOCK_vkCmdBlitImage2KHR_CALLBACK Callback) +{ + Mock.vkCmdBlitImage2KHR_IgnoreBool = (char)0; + Mock.vkCmdBlitImage2KHR_CallbackBool = (char)1; + Mock.vkCmdBlitImage2KHR_CallbackFunctionPointer = Callback; +} + +void vkCmdBlitImage2KHR_Stub(CMOCK_vkCmdBlitImage2KHR_CALLBACK Callback) +{ + Mock.vkCmdBlitImage2KHR_IgnoreBool = (char)0; + Mock.vkCmdBlitImage2KHR_CallbackBool = (char)0; + Mock.vkCmdBlitImage2KHR_CallbackFunctionPointer = Callback; +} + +void vkCmdBlitImage2KHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBlitImage2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBlitImage2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBlitImage2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBlitImage2KHR_CMockIgnoreArg_pBlitImageInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBlitImage2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBlitImage2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBlitImage2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pBlitImageInfo = 1; +} + +void vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdResolveImage2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdResolveImage2KHR); + cmock_call_instance = (CMOCK_vkCmdResolveImage2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdResolveImage2KHR_CallInstance); + Mock.vkCmdResolveImage2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdResolveImage2KHR_CallInstance); + if (Mock.vkCmdResolveImage2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdResolveImage2KHR_CallbackBool && + Mock.vkCmdResolveImage2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdResolveImage2KHR_CallbackFunctionPointer(commandBuffer, pResolveImageInfo, Mock.vkCmdResolveImage2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdResolveImage2KHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pResolveImageInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdResolveImage2KHR,CMockString_pResolveImageInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pResolveImageInfo), (void*)(pResolveImageInfo), sizeof(const VkResolveImageInfo2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdResolveImage2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdResolveImage2KHR_CallbackFunctionPointer(commandBuffer, pResolveImageInfo, Mock.vkCmdResolveImage2KHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdResolveImage2KHR(CMOCK_vkCmdResolveImage2KHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo); +void CMockExpectParameters_vkCmdResolveImage2KHR(CMOCK_vkCmdResolveImage2KHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pResolveImageInfo = pResolveImageInfo; + cmock_call_instance->IgnoreArg_pResolveImageInfo = 0; +} + +void vkCmdResolveImage2KHR_CMockIgnore(void) +{ + Mock.vkCmdResolveImage2KHR_IgnoreBool = (char)1; +} + +void vkCmdResolveImage2KHR_CMockStopIgnore(void) +{ + Mock.vkCmdResolveImage2KHR_IgnoreBool = (char)0; +} + +void vkCmdResolveImage2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdResolveImage2KHR_CALL_INSTANCE)); + CMOCK_vkCmdResolveImage2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResolveImage2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdResolveImage2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdResolveImage2KHR_CallInstance, cmock_guts_index); + Mock.vkCmdResolveImage2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdResolveImage2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdResolveImage2KHR_CALL_INSTANCE)); + CMOCK_vkCmdResolveImage2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResolveImage2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdResolveImage2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdResolveImage2KHR_CallInstance, cmock_guts_index); + Mock.vkCmdResolveImage2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdResolveImage2KHR(cmock_call_instance, commandBuffer, pResolveImageInfo); +} + +void vkCmdResolveImage2KHR_AddCallback(CMOCK_vkCmdResolveImage2KHR_CALLBACK Callback) +{ + Mock.vkCmdResolveImage2KHR_IgnoreBool = (char)0; + Mock.vkCmdResolveImage2KHR_CallbackBool = (char)1; + Mock.vkCmdResolveImage2KHR_CallbackFunctionPointer = Callback; +} + +void vkCmdResolveImage2KHR_Stub(CMOCK_vkCmdResolveImage2KHR_CALLBACK Callback) +{ + Mock.vkCmdResolveImage2KHR_IgnoreBool = (char)0; + Mock.vkCmdResolveImage2KHR_CallbackBool = (char)0; + Mock.vkCmdResolveImage2KHR_CallbackFunctionPointer = Callback; +} + +void vkCmdResolveImage2KHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdResolveImage2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResolveImage2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdResolveImage2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdResolveImage2KHR_CMockIgnoreArg_pResolveImageInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdResolveImage2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdResolveImage2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdResolveImage2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pResolveImageInfo = 1; +} + +void vkCmdTraceRaysIndirect2KHR(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdTraceRaysIndirect2KHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdTraceRaysIndirect2KHR); + cmock_call_instance = (CMOCK_vkCmdTraceRaysIndirect2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdTraceRaysIndirect2KHR_CallInstance); + Mock.vkCmdTraceRaysIndirect2KHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdTraceRaysIndirect2KHR_CallInstance); + if (Mock.vkCmdTraceRaysIndirect2KHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdTraceRaysIndirect2KHR_CallbackBool && + Mock.vkCmdTraceRaysIndirect2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdTraceRaysIndirect2KHR_CallbackFunctionPointer(commandBuffer, indirectDeviceAddress, Mock.vkCmdTraceRaysIndirect2KHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysIndirect2KHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_indirectDeviceAddress) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysIndirect2KHR,CMockString_indirectDeviceAddress); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_indirectDeviceAddress), (void*)(&indirectDeviceAddress), sizeof(VkDeviceAddress), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdTraceRaysIndirect2KHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdTraceRaysIndirect2KHR_CallbackFunctionPointer(commandBuffer, indirectDeviceAddress, Mock.vkCmdTraceRaysIndirect2KHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdTraceRaysIndirect2KHR(CMOCK_vkCmdTraceRaysIndirect2KHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress); +void CMockExpectParameters_vkCmdTraceRaysIndirect2KHR(CMOCK_vkCmdTraceRaysIndirect2KHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_indirectDeviceAddress), (void*)(&indirectDeviceAddress), + sizeof(VkDeviceAddress[sizeof(indirectDeviceAddress) == sizeof(VkDeviceAddress) ? 1 : -1])); /* add VkDeviceAddress to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_indirectDeviceAddress = 0; +} + +void vkCmdTraceRaysIndirect2KHR_CMockIgnore(void) +{ + Mock.vkCmdTraceRaysIndirect2KHR_IgnoreBool = (char)1; +} + +void vkCmdTraceRaysIndirect2KHR_CMockStopIgnore(void) +{ + Mock.vkCmdTraceRaysIndirect2KHR_IgnoreBool = (char)0; +} + +void vkCmdTraceRaysIndirect2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdTraceRaysIndirect2KHR_CALL_INSTANCE)); + CMOCK_vkCmdTraceRaysIndirect2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysIndirect2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdTraceRaysIndirect2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdTraceRaysIndirect2KHR_CallInstance, cmock_guts_index); + Mock.vkCmdTraceRaysIndirect2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdTraceRaysIndirect2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdTraceRaysIndirect2KHR_CALL_INSTANCE)); + CMOCK_vkCmdTraceRaysIndirect2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysIndirect2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdTraceRaysIndirect2KHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdTraceRaysIndirect2KHR_CallInstance, cmock_guts_index); + Mock.vkCmdTraceRaysIndirect2KHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdTraceRaysIndirect2KHR(cmock_call_instance, commandBuffer, indirectDeviceAddress); +} + +void vkCmdTraceRaysIndirect2KHR_AddCallback(CMOCK_vkCmdTraceRaysIndirect2KHR_CALLBACK Callback) +{ + Mock.vkCmdTraceRaysIndirect2KHR_IgnoreBool = (char)0; + Mock.vkCmdTraceRaysIndirect2KHR_CallbackBool = (char)1; + Mock.vkCmdTraceRaysIndirect2KHR_CallbackFunctionPointer = Callback; +} + +void vkCmdTraceRaysIndirect2KHR_Stub(CMOCK_vkCmdTraceRaysIndirect2KHR_CALLBACK Callback) +{ + Mock.vkCmdTraceRaysIndirect2KHR_IgnoreBool = (char)0; + Mock.vkCmdTraceRaysIndirect2KHR_CallbackBool = (char)0; + Mock.vkCmdTraceRaysIndirect2KHR_CallbackFunctionPointer = Callback; +} + +void vkCmdTraceRaysIndirect2KHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysIndirect2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysIndirect2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysIndirect2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdTraceRaysIndirect2KHR_CMockIgnoreArg_indirectDeviceAddress(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysIndirect2KHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysIndirect2KHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysIndirect2KHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_indirectDeviceAddress = 1; +} + +void vkGetDeviceBufferMemoryRequirementsKHR(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDeviceBufferMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDeviceBufferMemoryRequirementsKHR); + cmock_call_instance = (CMOCK_vkGetDeviceBufferMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDeviceBufferMemoryRequirementsKHR_CallInstance); + Mock.vkGetDeviceBufferMemoryRequirementsKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeviceBufferMemoryRequirementsKHR_CallInstance); + if (Mock.vkGetDeviceBufferMemoryRequirementsKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetDeviceBufferMemoryRequirementsKHR_CallbackBool && + Mock.vkGetDeviceBufferMemoryRequirementsKHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetDeviceBufferMemoryRequirementsKHR_CallbackFunctionPointer(device, pInfo, pMemoryRequirements, Mock.vkGetDeviceBufferMemoryRequirementsKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceBufferMemoryRequirementsKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceBufferMemoryRequirementsKHR,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkDeviceBufferMemoryRequirements), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMemoryRequirements) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceBufferMemoryRequirementsKHR,CMockString_pMemoryRequirements); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMemoryRequirements), (void*)(pMemoryRequirements), sizeof(VkMemoryRequirements2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDeviceBufferMemoryRequirementsKHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetDeviceBufferMemoryRequirementsKHR_CallbackFunctionPointer(device, pInfo, pMemoryRequirements, Mock.vkGetDeviceBufferMemoryRequirementsKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pMemoryRequirements, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pMemoryRequirements, (const void*)cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Val, + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetDeviceBufferMemoryRequirementsKHR(CMOCK_vkGetDeviceBufferMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +void CMockExpectParameters_vkGetDeviceBufferMemoryRequirementsKHR(CMOCK_vkGetDeviceBufferMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; + cmock_call_instance->Expected_pMemoryRequirements = pMemoryRequirements; + cmock_call_instance->IgnoreArg_pMemoryRequirements = 0; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used = 0; +} + +void vkGetDeviceBufferMemoryRequirementsKHR_CMockIgnore(void) +{ + Mock.vkGetDeviceBufferMemoryRequirementsKHR_IgnoreBool = (char)1; +} + +void vkGetDeviceBufferMemoryRequirementsKHR_CMockStopIgnore(void) +{ + Mock.vkGetDeviceBufferMemoryRequirementsKHR_IgnoreBool = (char)0; +} + +void vkGetDeviceBufferMemoryRequirementsKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceBufferMemoryRequirementsKHR_CALL_INSTANCE)); + CMOCK_vkGetDeviceBufferMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceBufferMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceBufferMemoryRequirementsKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceBufferMemoryRequirementsKHR_CallInstance, cmock_guts_index); + Mock.vkGetDeviceBufferMemoryRequirementsKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDeviceBufferMemoryRequirementsKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceBufferMemoryRequirementsKHR_CALL_INSTANCE)); + CMOCK_vkGetDeviceBufferMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceBufferMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceBufferMemoryRequirementsKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceBufferMemoryRequirementsKHR_CallInstance, cmock_guts_index); + Mock.vkGetDeviceBufferMemoryRequirementsKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDeviceBufferMemoryRequirementsKHR(cmock_call_instance, device, pInfo, pMemoryRequirements); +} + +void vkGetDeviceBufferMemoryRequirementsKHR_AddCallback(CMOCK_vkGetDeviceBufferMemoryRequirementsKHR_CALLBACK Callback) +{ + Mock.vkGetDeviceBufferMemoryRequirementsKHR_IgnoreBool = (char)0; + Mock.vkGetDeviceBufferMemoryRequirementsKHR_CallbackBool = (char)1; + Mock.vkGetDeviceBufferMemoryRequirementsKHR_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceBufferMemoryRequirementsKHR_Stub(CMOCK_vkGetDeviceBufferMemoryRequirementsKHR_CALLBACK Callback) +{ + Mock.vkGetDeviceBufferMemoryRequirementsKHR_IgnoreBool = (char)0; + Mock.vkGetDeviceBufferMemoryRequirementsKHR_CallbackBool = (char)0; + Mock.vkGetDeviceBufferMemoryRequirementsKHR_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceBufferMemoryRequirementsKHR_CMockReturnMemThruPtr_pMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkMemoryRequirements2 const* pMemoryRequirements, size_t cmock_size) +{ + CMOCK_vkGetDeviceBufferMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceBufferMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceBufferMemoryRequirementsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used = 1; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Val = pMemoryRequirements; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Size = cmock_size; +} + +void vkGetDeviceBufferMemoryRequirementsKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceBufferMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceBufferMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceBufferMemoryRequirementsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetDeviceBufferMemoryRequirementsKHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceBufferMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceBufferMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceBufferMemoryRequirementsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +void vkGetDeviceBufferMemoryRequirementsKHR_CMockIgnoreArg_pMemoryRequirements(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceBufferMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceBufferMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceBufferMemoryRequirementsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMemoryRequirements = 1; +} + +void vkGetDeviceImageMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDeviceImageMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDeviceImageMemoryRequirementsKHR); + cmock_call_instance = (CMOCK_vkGetDeviceImageMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDeviceImageMemoryRequirementsKHR_CallInstance); + Mock.vkGetDeviceImageMemoryRequirementsKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeviceImageMemoryRequirementsKHR_CallInstance); + if (Mock.vkGetDeviceImageMemoryRequirementsKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetDeviceImageMemoryRequirementsKHR_CallbackBool && + Mock.vkGetDeviceImageMemoryRequirementsKHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetDeviceImageMemoryRequirementsKHR_CallbackFunctionPointer(device, pInfo, pMemoryRequirements, Mock.vkGetDeviceImageMemoryRequirementsKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceImageMemoryRequirementsKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceImageMemoryRequirementsKHR,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkDeviceImageMemoryRequirements), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMemoryRequirements) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceImageMemoryRequirementsKHR,CMockString_pMemoryRequirements); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMemoryRequirements), (void*)(pMemoryRequirements), sizeof(VkMemoryRequirements2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDeviceImageMemoryRequirementsKHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetDeviceImageMemoryRequirementsKHR_CallbackFunctionPointer(device, pInfo, pMemoryRequirements, Mock.vkGetDeviceImageMemoryRequirementsKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pMemoryRequirements, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pMemoryRequirements, (const void*)cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Val, + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetDeviceImageMemoryRequirementsKHR(CMOCK_vkGetDeviceImageMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +void CMockExpectParameters_vkGetDeviceImageMemoryRequirementsKHR(CMOCK_vkGetDeviceImageMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; + cmock_call_instance->Expected_pMemoryRequirements = pMemoryRequirements; + cmock_call_instance->IgnoreArg_pMemoryRequirements = 0; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used = 0; +} + +void vkGetDeviceImageMemoryRequirementsKHR_CMockIgnore(void) +{ + Mock.vkGetDeviceImageMemoryRequirementsKHR_IgnoreBool = (char)1; +} + +void vkGetDeviceImageMemoryRequirementsKHR_CMockStopIgnore(void) +{ + Mock.vkGetDeviceImageMemoryRequirementsKHR_IgnoreBool = (char)0; +} + +void vkGetDeviceImageMemoryRequirementsKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceImageMemoryRequirementsKHR_CALL_INSTANCE)); + CMOCK_vkGetDeviceImageMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceImageMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceImageMemoryRequirementsKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceImageMemoryRequirementsKHR_CallInstance, cmock_guts_index); + Mock.vkGetDeviceImageMemoryRequirementsKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDeviceImageMemoryRequirementsKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceImageMemoryRequirementsKHR_CALL_INSTANCE)); + CMOCK_vkGetDeviceImageMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceImageMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceImageMemoryRequirementsKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceImageMemoryRequirementsKHR_CallInstance, cmock_guts_index); + Mock.vkGetDeviceImageMemoryRequirementsKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDeviceImageMemoryRequirementsKHR(cmock_call_instance, device, pInfo, pMemoryRequirements); +} + +void vkGetDeviceImageMemoryRequirementsKHR_AddCallback(CMOCK_vkGetDeviceImageMemoryRequirementsKHR_CALLBACK Callback) +{ + Mock.vkGetDeviceImageMemoryRequirementsKHR_IgnoreBool = (char)0; + Mock.vkGetDeviceImageMemoryRequirementsKHR_CallbackBool = (char)1; + Mock.vkGetDeviceImageMemoryRequirementsKHR_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceImageMemoryRequirementsKHR_Stub(CMOCK_vkGetDeviceImageMemoryRequirementsKHR_CALLBACK Callback) +{ + Mock.vkGetDeviceImageMemoryRequirementsKHR_IgnoreBool = (char)0; + Mock.vkGetDeviceImageMemoryRequirementsKHR_CallbackBool = (char)0; + Mock.vkGetDeviceImageMemoryRequirementsKHR_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceImageMemoryRequirementsKHR_CMockReturnMemThruPtr_pMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkMemoryRequirements2 const* pMemoryRequirements, size_t cmock_size) +{ + CMOCK_vkGetDeviceImageMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceImageMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceImageMemoryRequirementsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used = 1; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Val = pMemoryRequirements; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Size = cmock_size; +} + +void vkGetDeviceImageMemoryRequirementsKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceImageMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceImageMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceImageMemoryRequirementsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetDeviceImageMemoryRequirementsKHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceImageMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceImageMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceImageMemoryRequirementsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +void vkGetDeviceImageMemoryRequirementsKHR_CMockIgnoreArg_pMemoryRequirements(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceImageMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceImageMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceImageMemoryRequirementsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMemoryRequirements = 1; +} + +void vkGetDeviceImageSparseMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDeviceImageSparseMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDeviceImageSparseMemoryRequirementsKHR); + cmock_call_instance = (CMOCK_vkGetDeviceImageSparseMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_CallInstance); + Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_CallInstance); + if (Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_CallbackBool && + Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_CallbackFunctionPointer(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceImageSparseMemoryRequirementsKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceImageSparseMemoryRequirementsKHR,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkDeviceImageMemoryRequirements), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSparseMemoryRequirementCount) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceImageSparseMemoryRequirementsKHR,CMockString_pSparseMemoryRequirementCount); + if (cmock_call_instance->Expected_pSparseMemoryRequirementCount == NULL) + { UNITY_TEST_ASSERT_NULL(pSparseMemoryRequirementCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pSparseMemoryRequirementCount, pSparseMemoryRequirementCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pSparseMemoryRequirements) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceImageSparseMemoryRequirementsKHR,CMockString_pSparseMemoryRequirements); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSparseMemoryRequirements), (void*)(pSparseMemoryRequirements), sizeof(VkSparseImageMemoryRequirements2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_CallbackFunctionPointer(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSparseMemoryRequirementCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSparseMemoryRequirementCount, (const void*)cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Val, + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSparseMemoryRequirements, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSparseMemoryRequirements, (const void*)cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Val, + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetDeviceImageSparseMemoryRequirementsKHR(CMOCK_vkGetDeviceImageSparseMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +void CMockExpectParameters_vkGetDeviceImageSparseMemoryRequirementsKHR(CMOCK_vkGetDeviceImageSparseMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; + cmock_call_instance->Expected_pSparseMemoryRequirementCount = pSparseMemoryRequirementCount; + cmock_call_instance->IgnoreArg_pSparseMemoryRequirementCount = 0; + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Used = 0; + cmock_call_instance->Expected_pSparseMemoryRequirements = pSparseMemoryRequirements; + cmock_call_instance->IgnoreArg_pSparseMemoryRequirements = 0; + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Used = 0; +} + +void vkGetDeviceImageSparseMemoryRequirementsKHR_CMockIgnore(void) +{ + Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_IgnoreBool = (char)1; +} + +void vkGetDeviceImageSparseMemoryRequirementsKHR_CMockStopIgnore(void) +{ + Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_IgnoreBool = (char)0; +} + +void vkGetDeviceImageSparseMemoryRequirementsKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceImageSparseMemoryRequirementsKHR_CALL_INSTANCE)); + CMOCK_vkGetDeviceImageSparseMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceImageSparseMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_CallInstance, cmock_guts_index); + Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDeviceImageSparseMemoryRequirementsKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceImageSparseMemoryRequirementsKHR_CALL_INSTANCE)); + CMOCK_vkGetDeviceImageSparseMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceImageSparseMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_CallInstance, cmock_guts_index); + Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDeviceImageSparseMemoryRequirementsKHR(cmock_call_instance, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); +} + +void vkGetDeviceImageSparseMemoryRequirementsKHR_AddCallback(CMOCK_vkGetDeviceImageSparseMemoryRequirementsKHR_CALLBACK Callback) +{ + Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_IgnoreBool = (char)0; + Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_CallbackBool = (char)1; + Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceImageSparseMemoryRequirementsKHR_Stub(CMOCK_vkGetDeviceImageSparseMemoryRequirementsKHR_CALLBACK Callback) +{ + Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_IgnoreBool = (char)0; + Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_CallbackBool = (char)0; + Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceImageSparseMemoryRequirementsKHR_CMockReturnMemThruPtr_pSparseMemoryRequirementCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pSparseMemoryRequirementCount, size_t cmock_size) +{ + CMOCK_vkGetDeviceImageSparseMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceImageSparseMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Val = pSparseMemoryRequirementCount; + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirementCount_Size = cmock_size; +} + +void vkGetDeviceImageSparseMemoryRequirementsKHR_CMockReturnMemThruPtr_pSparseMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkSparseImageMemoryRequirements2 const* pSparseMemoryRequirements, size_t cmock_size) +{ + CMOCK_vkGetDeviceImageSparseMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceImageSparseMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Used = 1; + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Val = pSparseMemoryRequirements; + cmock_call_instance->ReturnThruPtr_pSparseMemoryRequirements_Size = cmock_size; +} + +void vkGetDeviceImageSparseMemoryRequirementsKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceImageSparseMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceImageSparseMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetDeviceImageSparseMemoryRequirementsKHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceImageSparseMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceImageSparseMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +void vkGetDeviceImageSparseMemoryRequirementsKHR_CMockIgnoreArg_pSparseMemoryRequirementCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceImageSparseMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceImageSparseMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSparseMemoryRequirementCount = 1; +} + +void vkGetDeviceImageSparseMemoryRequirementsKHR_CMockIgnoreArg_pSparseMemoryRequirements(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceImageSparseMemoryRequirementsKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceImageSparseMemoryRequirementsKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceImageSparseMemoryRequirementsKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSparseMemoryRequirements = 1; +} + +VkResult vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateDebugReportCallbackEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateDebugReportCallbackEXT); + cmock_call_instance = (CMOCK_vkCreateDebugReportCallbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateDebugReportCallbackEXT_CallInstance); + Mock.vkCreateDebugReportCallbackEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCreateDebugReportCallbackEXT_CallInstance); + if (Mock.vkCreateDebugReportCallbackEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateDebugReportCallbackEXT_FinalReturn; + memcpy((void*)(&Mock.vkCreateDebugReportCallbackEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateDebugReportCallbackEXT_CallbackBool && + Mock.vkCreateDebugReportCallbackEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateDebugReportCallbackEXT_CallbackFunctionPointer(instance, pCreateInfo, pAllocator, pCallback, Mock.vkCreateDebugReportCallbackEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_instance) + { + UNITY_SET_DETAILS(CMockString_vkCreateDebugReportCallbackEXT,CMockString_instance); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), sizeof(VkInstance), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateDebugReportCallbackEXT,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkDebugReportCallbackCreateInfoEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateDebugReportCallbackEXT,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCallback) + { + UNITY_SET_DETAILS(CMockString_vkCreateDebugReportCallbackEXT,CMockString_pCallback); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCallback), (void*)(pCallback), sizeof(VkDebugReportCallbackEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateDebugReportCallbackEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateDebugReportCallbackEXT_CallbackFunctionPointer(instance, pCreateInfo, pAllocator, pCallback, Mock.vkCreateDebugReportCallbackEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pCallback_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pCallback, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pCallback, (const void*)cmock_call_instance->ReturnThruPtr_pCallback_Val, + cmock_call_instance->ReturnThruPtr_pCallback_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateDebugReportCallbackEXT(CMOCK_vkCreateDebugReportCallbackEXT_CALL_INSTANCE* cmock_call_instance, VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback); +void CMockExpectParameters_vkCreateDebugReportCallbackEXT(CMOCK_vkCreateDebugReportCallbackEXT_CALL_INSTANCE* cmock_call_instance, VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback) +{ + memcpy((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), + sizeof(VkInstance[sizeof(instance) == sizeof(VkInstance) ? 1 : -1])); /* add VkInstance to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_instance = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pCallback = pCallback; + cmock_call_instance->IgnoreArg_pCallback = 0; + cmock_call_instance->ReturnThruPtr_pCallback_Used = 0; +} + +void vkCreateDebugReportCallbackEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateDebugReportCallbackEXT_CALL_INSTANCE)); + CMOCK_vkCreateDebugReportCallbackEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDebugReportCallbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateDebugReportCallbackEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCreateDebugReportCallbackEXT_CallInstance, cmock_guts_index); + Mock.vkCreateDebugReportCallbackEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateDebugReportCallbackEXT_IgnoreBool = (char)1; +} + +void vkCreateDebugReportCallbackEXT_CMockStopIgnore(void) +{ + if(Mock.vkCreateDebugReportCallbackEXT_IgnoreBool) + Mock.vkCreateDebugReportCallbackEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCreateDebugReportCallbackEXT_CallInstance); + Mock.vkCreateDebugReportCallbackEXT_IgnoreBool = (char)0; +} + +void vkCreateDebugReportCallbackEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateDebugReportCallbackEXT_CALL_INSTANCE)); + CMOCK_vkCreateDebugReportCallbackEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDebugReportCallbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateDebugReportCallbackEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCreateDebugReportCallbackEXT_CallInstance, cmock_guts_index); + Mock.vkCreateDebugReportCallbackEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateDebugReportCallbackEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateDebugReportCallbackEXT_CALL_INSTANCE)); + CMOCK_vkCreateDebugReportCallbackEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDebugReportCallbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateDebugReportCallbackEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCreateDebugReportCallbackEXT_CallInstance, cmock_guts_index); + Mock.vkCreateDebugReportCallbackEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateDebugReportCallbackEXT(cmock_call_instance, instance, pCreateInfo, pAllocator, pCallback); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateDebugReportCallbackEXT_AddCallback(CMOCK_vkCreateDebugReportCallbackEXT_CALLBACK Callback) +{ + Mock.vkCreateDebugReportCallbackEXT_IgnoreBool = (char)0; + Mock.vkCreateDebugReportCallbackEXT_CallbackBool = (char)1; + Mock.vkCreateDebugReportCallbackEXT_CallbackFunctionPointer = Callback; +} + +void vkCreateDebugReportCallbackEXT_Stub(CMOCK_vkCreateDebugReportCallbackEXT_CALLBACK Callback) +{ + Mock.vkCreateDebugReportCallbackEXT_IgnoreBool = (char)0; + Mock.vkCreateDebugReportCallbackEXT_CallbackBool = (char)0; + Mock.vkCreateDebugReportCallbackEXT_CallbackFunctionPointer = Callback; +} + +void vkCreateDebugReportCallbackEXT_CMockReturnMemThruPtr_pCallback(UNITY_LINE_TYPE cmock_line, VkDebugReportCallbackEXT const* pCallback, size_t cmock_size) +{ + CMOCK_vkCreateDebugReportCallbackEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDebugReportCallbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDebugReportCallbackEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pCallback_Used = 1; + cmock_call_instance->ReturnThruPtr_pCallback_Val = pCallback; + cmock_call_instance->ReturnThruPtr_pCallback_Size = cmock_size; +} + +void vkCreateDebugReportCallbackEXT_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDebugReportCallbackEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDebugReportCallbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDebugReportCallbackEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_instance = 1; +} + +void vkCreateDebugReportCallbackEXT_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDebugReportCallbackEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDebugReportCallbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDebugReportCallbackEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateDebugReportCallbackEXT_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDebugReportCallbackEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDebugReportCallbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDebugReportCallbackEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateDebugReportCallbackEXT_CMockIgnoreArg_pCallback(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDebugReportCallbackEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDebugReportCallbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDebugReportCallbackEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCallback = 1; +} + +void vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyDebugReportCallbackEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyDebugReportCallbackEXT); + cmock_call_instance = (CMOCK_vkDestroyDebugReportCallbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyDebugReportCallbackEXT_CallInstance); + Mock.vkDestroyDebugReportCallbackEXT_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyDebugReportCallbackEXT_CallInstance); + if (Mock.vkDestroyDebugReportCallbackEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyDebugReportCallbackEXT_CallbackBool && + Mock.vkDestroyDebugReportCallbackEXT_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyDebugReportCallbackEXT_CallbackFunctionPointer(instance, callback, pAllocator, Mock.vkDestroyDebugReportCallbackEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_instance) + { + UNITY_SET_DETAILS(CMockString_vkDestroyDebugReportCallbackEXT,CMockString_instance); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), sizeof(VkInstance), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_callback) + { + UNITY_SET_DETAILS(CMockString_vkDestroyDebugReportCallbackEXT,CMockString_callback); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), sizeof(VkDebugReportCallbackEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyDebugReportCallbackEXT,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyDebugReportCallbackEXT_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyDebugReportCallbackEXT_CallbackFunctionPointer(instance, callback, pAllocator, Mock.vkDestroyDebugReportCallbackEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyDebugReportCallbackEXT(CMOCK_vkDestroyDebugReportCallbackEXT_CALL_INSTANCE* cmock_call_instance, VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyDebugReportCallbackEXT(CMOCK_vkDestroyDebugReportCallbackEXT_CALL_INSTANCE* cmock_call_instance, VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), + sizeof(VkInstance[sizeof(instance) == sizeof(VkInstance) ? 1 : -1])); /* add VkInstance to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_instance = 0; + memcpy((void*)(&cmock_call_instance->Expected_callback), (void*)(&callback), + sizeof(VkDebugReportCallbackEXT[sizeof(callback) == sizeof(VkDebugReportCallbackEXT) ? 1 : -1])); /* add VkDebugReportCallbackEXT to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_callback = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyDebugReportCallbackEXT_CMockIgnore(void) +{ + Mock.vkDestroyDebugReportCallbackEXT_IgnoreBool = (char)1; +} + +void vkDestroyDebugReportCallbackEXT_CMockStopIgnore(void) +{ + Mock.vkDestroyDebugReportCallbackEXT_IgnoreBool = (char)0; +} + +void vkDestroyDebugReportCallbackEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyDebugReportCallbackEXT_CALL_INSTANCE)); + CMOCK_vkDestroyDebugReportCallbackEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDebugReportCallbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyDebugReportCallbackEXT_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyDebugReportCallbackEXT_CallInstance, cmock_guts_index); + Mock.vkDestroyDebugReportCallbackEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyDebugReportCallbackEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyDebugReportCallbackEXT_CALL_INSTANCE)); + CMOCK_vkDestroyDebugReportCallbackEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDebugReportCallbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyDebugReportCallbackEXT_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyDebugReportCallbackEXT_CallInstance, cmock_guts_index); + Mock.vkDestroyDebugReportCallbackEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyDebugReportCallbackEXT(cmock_call_instance, instance, callback, pAllocator); +} + +void vkDestroyDebugReportCallbackEXT_AddCallback(CMOCK_vkDestroyDebugReportCallbackEXT_CALLBACK Callback) +{ + Mock.vkDestroyDebugReportCallbackEXT_IgnoreBool = (char)0; + Mock.vkDestroyDebugReportCallbackEXT_CallbackBool = (char)1; + Mock.vkDestroyDebugReportCallbackEXT_CallbackFunctionPointer = Callback; +} + +void vkDestroyDebugReportCallbackEXT_Stub(CMOCK_vkDestroyDebugReportCallbackEXT_CALLBACK Callback) +{ + Mock.vkDestroyDebugReportCallbackEXT_IgnoreBool = (char)0; + Mock.vkDestroyDebugReportCallbackEXT_CallbackBool = (char)0; + Mock.vkDestroyDebugReportCallbackEXT_CallbackFunctionPointer = Callback; +} + +void vkDestroyDebugReportCallbackEXT_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyDebugReportCallbackEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDebugReportCallbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyDebugReportCallbackEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_instance = 1; +} + +void vkDestroyDebugReportCallbackEXT_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyDebugReportCallbackEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDebugReportCallbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyDebugReportCallbackEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_callback = 1; +} + +void vkDestroyDebugReportCallbackEXT_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyDebugReportCallbackEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDebugReportCallbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyDebugReportCallbackEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDebugReportMessageEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDebugReportMessageEXT); + cmock_call_instance = (CMOCK_vkDebugReportMessageEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDebugReportMessageEXT_CallInstance); + Mock.vkDebugReportMessageEXT_CallInstance = CMock_Guts_MemNext(Mock.vkDebugReportMessageEXT_CallInstance); + if (Mock.vkDebugReportMessageEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDebugReportMessageEXT_CallbackBool && + Mock.vkDebugReportMessageEXT_CallbackFunctionPointer != NULL) + { + Mock.vkDebugReportMessageEXT_CallbackFunctionPointer(instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage, Mock.vkDebugReportMessageEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_instance) + { + UNITY_SET_DETAILS(CMockString_vkDebugReportMessageEXT,CMockString_instance); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), sizeof(VkInstance), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_flags) + { + UNITY_SET_DETAILS(CMockString_vkDebugReportMessageEXT,CMockString_flags); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_flags), (void*)(&flags), sizeof(VkDebugReportFlagsEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_objectType) + { + UNITY_SET_DETAILS(CMockString_vkDebugReportMessageEXT,CMockString_objectType); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_objectType), (void*)(&objectType), sizeof(VkDebugReportObjectTypeEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_object) + { + UNITY_SET_DETAILS(CMockString_vkDebugReportMessageEXT,CMockString_object); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_object), (void*)(&object), sizeof(uint64_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_location) + { + UNITY_SET_DETAILS(CMockString_vkDebugReportMessageEXT,CMockString_location); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_location), (void*)(&location), sizeof(size_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_messageCode) + { + UNITY_SET_DETAILS(CMockString_vkDebugReportMessageEXT,CMockString_messageCode); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_messageCode, messageCode, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pLayerPrefix) + { + UNITY_SET_DETAILS(CMockString_vkDebugReportMessageEXT,CMockString_pLayerPrefix); + UNITY_TEST_ASSERT_EQUAL_STRING(cmock_call_instance->Expected_pLayerPrefix, pLayerPrefix, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMessage) + { + UNITY_SET_DETAILS(CMockString_vkDebugReportMessageEXT,CMockString_pMessage); + UNITY_TEST_ASSERT_EQUAL_STRING(cmock_call_instance->Expected_pMessage, pMessage, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDebugReportMessageEXT_CallbackFunctionPointer != NULL) + { + Mock.vkDebugReportMessageEXT_CallbackFunctionPointer(instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage, Mock.vkDebugReportMessageEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDebugReportMessageEXT(CMOCK_vkDebugReportMessageEXT_CALL_INSTANCE* cmock_call_instance, VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage); +void CMockExpectParameters_vkDebugReportMessageEXT(CMOCK_vkDebugReportMessageEXT_CALL_INSTANCE* cmock_call_instance, VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage) +{ + memcpy((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), + sizeof(VkInstance[sizeof(instance) == sizeof(VkInstance) ? 1 : -1])); /* add VkInstance to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_instance = 0; + memcpy((void*)(&cmock_call_instance->Expected_flags), (void*)(&flags), + sizeof(VkDebugReportFlagsEXT[sizeof(flags) == sizeof(VkDebugReportFlagsEXT) ? 1 : -1])); /* add VkDebugReportFlagsEXT to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_flags = 0; + memcpy((void*)(&cmock_call_instance->Expected_objectType), (void*)(&objectType), + sizeof(VkDebugReportObjectTypeEXT[sizeof(objectType) == sizeof(VkDebugReportObjectTypeEXT) ? 1 : -1])); /* add VkDebugReportObjectTypeEXT to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_objectType = 0; + memcpy((void*)(&cmock_call_instance->Expected_object), (void*)(&object), + sizeof(uint64_t[sizeof(object) == sizeof(uint64_t) ? 1 : -1])); /* add uint64_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_object = 0; + memcpy((void*)(&cmock_call_instance->Expected_location), (void*)(&location), + sizeof(size_t[sizeof(location) == sizeof(size_t) ? 1 : -1])); /* add size_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_location = 0; + cmock_call_instance->Expected_messageCode = messageCode; + cmock_call_instance->IgnoreArg_messageCode = 0; + cmock_call_instance->Expected_pLayerPrefix = pLayerPrefix; + cmock_call_instance->IgnoreArg_pLayerPrefix = 0; + cmock_call_instance->Expected_pMessage = pMessage; + cmock_call_instance->IgnoreArg_pMessage = 0; +} + +void vkDebugReportMessageEXT_CMockIgnore(void) +{ + Mock.vkDebugReportMessageEXT_IgnoreBool = (char)1; +} + +void vkDebugReportMessageEXT_CMockStopIgnore(void) +{ + Mock.vkDebugReportMessageEXT_IgnoreBool = (char)0; +} + +void vkDebugReportMessageEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDebugReportMessageEXT_CALL_INSTANCE)); + CMOCK_vkDebugReportMessageEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDebugReportMessageEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDebugReportMessageEXT_CallInstance = CMock_Guts_MemChain(Mock.vkDebugReportMessageEXT_CallInstance, cmock_guts_index); + Mock.vkDebugReportMessageEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDebugReportMessageEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDebugReportMessageEXT_CALL_INSTANCE)); + CMOCK_vkDebugReportMessageEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDebugReportMessageEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDebugReportMessageEXT_CallInstance = CMock_Guts_MemChain(Mock.vkDebugReportMessageEXT_CallInstance, cmock_guts_index); + Mock.vkDebugReportMessageEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDebugReportMessageEXT(cmock_call_instance, instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage); +} + +void vkDebugReportMessageEXT_AddCallback(CMOCK_vkDebugReportMessageEXT_CALLBACK Callback) +{ + Mock.vkDebugReportMessageEXT_IgnoreBool = (char)0; + Mock.vkDebugReportMessageEXT_CallbackBool = (char)1; + Mock.vkDebugReportMessageEXT_CallbackFunctionPointer = Callback; +} + +void vkDebugReportMessageEXT_Stub(CMOCK_vkDebugReportMessageEXT_CALLBACK Callback) +{ + Mock.vkDebugReportMessageEXT_IgnoreBool = (char)0; + Mock.vkDebugReportMessageEXT_CallbackBool = (char)0; + Mock.vkDebugReportMessageEXT_CallbackFunctionPointer = Callback; +} + +void vkDebugReportMessageEXT_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDebugReportMessageEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDebugReportMessageEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDebugReportMessageEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_instance = 1; +} + +void vkDebugReportMessageEXT_CMockIgnoreArg_flags(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDebugReportMessageEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDebugReportMessageEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDebugReportMessageEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_flags = 1; +} + +void vkDebugReportMessageEXT_CMockIgnoreArg_objectType(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDebugReportMessageEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDebugReportMessageEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDebugReportMessageEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_objectType = 1; +} + +void vkDebugReportMessageEXT_CMockIgnoreArg_object(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDebugReportMessageEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDebugReportMessageEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDebugReportMessageEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_object = 1; +} + +void vkDebugReportMessageEXT_CMockIgnoreArg_location(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDebugReportMessageEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDebugReportMessageEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDebugReportMessageEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_location = 1; +} + +void vkDebugReportMessageEXT_CMockIgnoreArg_messageCode(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDebugReportMessageEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDebugReportMessageEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDebugReportMessageEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_messageCode = 1; +} + +void vkDebugReportMessageEXT_CMockIgnoreArg_pLayerPrefix(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDebugReportMessageEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDebugReportMessageEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDebugReportMessageEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pLayerPrefix = 1; +} + +void vkDebugReportMessageEXT_CMockIgnoreArg_pMessage(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDebugReportMessageEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDebugReportMessageEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDebugReportMessageEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMessage = 1; +} + +VkResult vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDebugMarkerSetObjectTagEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDebugMarkerSetObjectTagEXT); + cmock_call_instance = (CMOCK_vkDebugMarkerSetObjectTagEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDebugMarkerSetObjectTagEXT_CallInstance); + Mock.vkDebugMarkerSetObjectTagEXT_CallInstance = CMock_Guts_MemNext(Mock.vkDebugMarkerSetObjectTagEXT_CallInstance); + if (Mock.vkDebugMarkerSetObjectTagEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkDebugMarkerSetObjectTagEXT_FinalReturn; + memcpy((void*)(&Mock.vkDebugMarkerSetObjectTagEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkDebugMarkerSetObjectTagEXT_CallbackBool && + Mock.vkDebugMarkerSetObjectTagEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkDebugMarkerSetObjectTagEXT_CallbackFunctionPointer(device, pTagInfo, Mock.vkDebugMarkerSetObjectTagEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDebugMarkerSetObjectTagEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pTagInfo) + { + UNITY_SET_DETAILS(CMockString_vkDebugMarkerSetObjectTagEXT,CMockString_pTagInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pTagInfo), (void*)(pTagInfo), sizeof(const VkDebugMarkerObjectTagInfoEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDebugMarkerSetObjectTagEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkDebugMarkerSetObjectTagEXT_CallbackFunctionPointer(device, pTagInfo, Mock.vkDebugMarkerSetObjectTagEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkDebugMarkerSetObjectTagEXT(CMOCK_vkDebugMarkerSetObjectTagEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo); +void CMockExpectParameters_vkDebugMarkerSetObjectTagEXT(CMOCK_vkDebugMarkerSetObjectTagEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pTagInfo = pTagInfo; + cmock_call_instance->IgnoreArg_pTagInfo = 0; +} + +void vkDebugMarkerSetObjectTagEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDebugMarkerSetObjectTagEXT_CALL_INSTANCE)); + CMOCK_vkDebugMarkerSetObjectTagEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDebugMarkerSetObjectTagEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDebugMarkerSetObjectTagEXT_CallInstance = CMock_Guts_MemChain(Mock.vkDebugMarkerSetObjectTagEXT_CallInstance, cmock_guts_index); + Mock.vkDebugMarkerSetObjectTagEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkDebugMarkerSetObjectTagEXT_IgnoreBool = (char)1; +} + +void vkDebugMarkerSetObjectTagEXT_CMockStopIgnore(void) +{ + if(Mock.vkDebugMarkerSetObjectTagEXT_IgnoreBool) + Mock.vkDebugMarkerSetObjectTagEXT_CallInstance = CMock_Guts_MemNext(Mock.vkDebugMarkerSetObjectTagEXT_CallInstance); + Mock.vkDebugMarkerSetObjectTagEXT_IgnoreBool = (char)0; +} + +void vkDebugMarkerSetObjectTagEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDebugMarkerSetObjectTagEXT_CALL_INSTANCE)); + CMOCK_vkDebugMarkerSetObjectTagEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDebugMarkerSetObjectTagEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDebugMarkerSetObjectTagEXT_CallInstance = CMock_Guts_MemChain(Mock.vkDebugMarkerSetObjectTagEXT_CallInstance, cmock_guts_index); + Mock.vkDebugMarkerSetObjectTagEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDebugMarkerSetObjectTagEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDebugMarkerSetObjectTagEXT_CALL_INSTANCE)); + CMOCK_vkDebugMarkerSetObjectTagEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDebugMarkerSetObjectTagEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDebugMarkerSetObjectTagEXT_CallInstance = CMock_Guts_MemChain(Mock.vkDebugMarkerSetObjectTagEXT_CallInstance, cmock_guts_index); + Mock.vkDebugMarkerSetObjectTagEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDebugMarkerSetObjectTagEXT(cmock_call_instance, device, pTagInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkDebugMarkerSetObjectTagEXT_AddCallback(CMOCK_vkDebugMarkerSetObjectTagEXT_CALLBACK Callback) +{ + Mock.vkDebugMarkerSetObjectTagEXT_IgnoreBool = (char)0; + Mock.vkDebugMarkerSetObjectTagEXT_CallbackBool = (char)1; + Mock.vkDebugMarkerSetObjectTagEXT_CallbackFunctionPointer = Callback; +} + +void vkDebugMarkerSetObjectTagEXT_Stub(CMOCK_vkDebugMarkerSetObjectTagEXT_CALLBACK Callback) +{ + Mock.vkDebugMarkerSetObjectTagEXT_IgnoreBool = (char)0; + Mock.vkDebugMarkerSetObjectTagEXT_CallbackBool = (char)0; + Mock.vkDebugMarkerSetObjectTagEXT_CallbackFunctionPointer = Callback; +} + +void vkDebugMarkerSetObjectTagEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDebugMarkerSetObjectTagEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDebugMarkerSetObjectTagEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDebugMarkerSetObjectTagEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDebugMarkerSetObjectTagEXT_CMockIgnoreArg_pTagInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDebugMarkerSetObjectTagEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDebugMarkerSetObjectTagEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDebugMarkerSetObjectTagEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pTagInfo = 1; +} + +VkResult vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDebugMarkerSetObjectNameEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDebugMarkerSetObjectNameEXT); + cmock_call_instance = (CMOCK_vkDebugMarkerSetObjectNameEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDebugMarkerSetObjectNameEXT_CallInstance); + Mock.vkDebugMarkerSetObjectNameEXT_CallInstance = CMock_Guts_MemNext(Mock.vkDebugMarkerSetObjectNameEXT_CallInstance); + if (Mock.vkDebugMarkerSetObjectNameEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkDebugMarkerSetObjectNameEXT_FinalReturn; + memcpy((void*)(&Mock.vkDebugMarkerSetObjectNameEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkDebugMarkerSetObjectNameEXT_CallbackBool && + Mock.vkDebugMarkerSetObjectNameEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkDebugMarkerSetObjectNameEXT_CallbackFunctionPointer(device, pNameInfo, Mock.vkDebugMarkerSetObjectNameEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDebugMarkerSetObjectNameEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pNameInfo) + { + UNITY_SET_DETAILS(CMockString_vkDebugMarkerSetObjectNameEXT,CMockString_pNameInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pNameInfo), (void*)(pNameInfo), sizeof(const VkDebugMarkerObjectNameInfoEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDebugMarkerSetObjectNameEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkDebugMarkerSetObjectNameEXT_CallbackFunctionPointer(device, pNameInfo, Mock.vkDebugMarkerSetObjectNameEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkDebugMarkerSetObjectNameEXT(CMOCK_vkDebugMarkerSetObjectNameEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo); +void CMockExpectParameters_vkDebugMarkerSetObjectNameEXT(CMOCK_vkDebugMarkerSetObjectNameEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pNameInfo = pNameInfo; + cmock_call_instance->IgnoreArg_pNameInfo = 0; +} + +void vkDebugMarkerSetObjectNameEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDebugMarkerSetObjectNameEXT_CALL_INSTANCE)); + CMOCK_vkDebugMarkerSetObjectNameEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDebugMarkerSetObjectNameEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDebugMarkerSetObjectNameEXT_CallInstance = CMock_Guts_MemChain(Mock.vkDebugMarkerSetObjectNameEXT_CallInstance, cmock_guts_index); + Mock.vkDebugMarkerSetObjectNameEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkDebugMarkerSetObjectNameEXT_IgnoreBool = (char)1; +} + +void vkDebugMarkerSetObjectNameEXT_CMockStopIgnore(void) +{ + if(Mock.vkDebugMarkerSetObjectNameEXT_IgnoreBool) + Mock.vkDebugMarkerSetObjectNameEXT_CallInstance = CMock_Guts_MemNext(Mock.vkDebugMarkerSetObjectNameEXT_CallInstance); + Mock.vkDebugMarkerSetObjectNameEXT_IgnoreBool = (char)0; +} + +void vkDebugMarkerSetObjectNameEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDebugMarkerSetObjectNameEXT_CALL_INSTANCE)); + CMOCK_vkDebugMarkerSetObjectNameEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDebugMarkerSetObjectNameEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDebugMarkerSetObjectNameEXT_CallInstance = CMock_Guts_MemChain(Mock.vkDebugMarkerSetObjectNameEXT_CallInstance, cmock_guts_index); + Mock.vkDebugMarkerSetObjectNameEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDebugMarkerSetObjectNameEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDebugMarkerSetObjectNameEXT_CALL_INSTANCE)); + CMOCK_vkDebugMarkerSetObjectNameEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDebugMarkerSetObjectNameEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDebugMarkerSetObjectNameEXT_CallInstance = CMock_Guts_MemChain(Mock.vkDebugMarkerSetObjectNameEXT_CallInstance, cmock_guts_index); + Mock.vkDebugMarkerSetObjectNameEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDebugMarkerSetObjectNameEXT(cmock_call_instance, device, pNameInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkDebugMarkerSetObjectNameEXT_AddCallback(CMOCK_vkDebugMarkerSetObjectNameEXT_CALLBACK Callback) +{ + Mock.vkDebugMarkerSetObjectNameEXT_IgnoreBool = (char)0; + Mock.vkDebugMarkerSetObjectNameEXT_CallbackBool = (char)1; + Mock.vkDebugMarkerSetObjectNameEXT_CallbackFunctionPointer = Callback; +} + +void vkDebugMarkerSetObjectNameEXT_Stub(CMOCK_vkDebugMarkerSetObjectNameEXT_CALLBACK Callback) +{ + Mock.vkDebugMarkerSetObjectNameEXT_IgnoreBool = (char)0; + Mock.vkDebugMarkerSetObjectNameEXT_CallbackBool = (char)0; + Mock.vkDebugMarkerSetObjectNameEXT_CallbackFunctionPointer = Callback; +} + +void vkDebugMarkerSetObjectNameEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDebugMarkerSetObjectNameEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDebugMarkerSetObjectNameEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDebugMarkerSetObjectNameEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDebugMarkerSetObjectNameEXT_CMockIgnoreArg_pNameInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDebugMarkerSetObjectNameEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDebugMarkerSetObjectNameEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDebugMarkerSetObjectNameEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pNameInfo = 1; +} + +void vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDebugMarkerBeginEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDebugMarkerBeginEXT); + cmock_call_instance = (CMOCK_vkCmdDebugMarkerBeginEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDebugMarkerBeginEXT_CallInstance); + Mock.vkCmdDebugMarkerBeginEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDebugMarkerBeginEXT_CallInstance); + if (Mock.vkCmdDebugMarkerBeginEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDebugMarkerBeginEXT_CallbackBool && + Mock.vkCmdDebugMarkerBeginEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDebugMarkerBeginEXT_CallbackFunctionPointer(commandBuffer, pMarkerInfo, Mock.vkCmdDebugMarkerBeginEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDebugMarkerBeginEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMarkerInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdDebugMarkerBeginEXT,CMockString_pMarkerInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMarkerInfo), (void*)(pMarkerInfo), sizeof(const VkDebugMarkerMarkerInfoEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdDebugMarkerBeginEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDebugMarkerBeginEXT_CallbackFunctionPointer(commandBuffer, pMarkerInfo, Mock.vkCmdDebugMarkerBeginEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDebugMarkerBeginEXT(CMOCK_vkCmdDebugMarkerBeginEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); +void CMockExpectParameters_vkCmdDebugMarkerBeginEXT(CMOCK_vkCmdDebugMarkerBeginEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pMarkerInfo = pMarkerInfo; + cmock_call_instance->IgnoreArg_pMarkerInfo = 0; +} + +void vkCmdDebugMarkerBeginEXT_CMockIgnore(void) +{ + Mock.vkCmdDebugMarkerBeginEXT_IgnoreBool = (char)1; +} + +void vkCmdDebugMarkerBeginEXT_CMockStopIgnore(void) +{ + Mock.vkCmdDebugMarkerBeginEXT_IgnoreBool = (char)0; +} + +void vkCmdDebugMarkerBeginEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDebugMarkerBeginEXT_CALL_INSTANCE)); + CMOCK_vkCmdDebugMarkerBeginEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDebugMarkerBeginEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDebugMarkerBeginEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDebugMarkerBeginEXT_CallInstance, cmock_guts_index); + Mock.vkCmdDebugMarkerBeginEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDebugMarkerBeginEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDebugMarkerBeginEXT_CALL_INSTANCE)); + CMOCK_vkCmdDebugMarkerBeginEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDebugMarkerBeginEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDebugMarkerBeginEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDebugMarkerBeginEXT_CallInstance, cmock_guts_index); + Mock.vkCmdDebugMarkerBeginEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDebugMarkerBeginEXT(cmock_call_instance, commandBuffer, pMarkerInfo); +} + +void vkCmdDebugMarkerBeginEXT_AddCallback(CMOCK_vkCmdDebugMarkerBeginEXT_CALLBACK Callback) +{ + Mock.vkCmdDebugMarkerBeginEXT_IgnoreBool = (char)0; + Mock.vkCmdDebugMarkerBeginEXT_CallbackBool = (char)1; + Mock.vkCmdDebugMarkerBeginEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdDebugMarkerBeginEXT_Stub(CMOCK_vkCmdDebugMarkerBeginEXT_CALLBACK Callback) +{ + Mock.vkCmdDebugMarkerBeginEXT_IgnoreBool = (char)0; + Mock.vkCmdDebugMarkerBeginEXT_CallbackBool = (char)0; + Mock.vkCmdDebugMarkerBeginEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdDebugMarkerBeginEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDebugMarkerBeginEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDebugMarkerBeginEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDebugMarkerBeginEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDebugMarkerBeginEXT_CMockIgnoreArg_pMarkerInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDebugMarkerBeginEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDebugMarkerBeginEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDebugMarkerBeginEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMarkerInfo = 1; +} + +void vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDebugMarkerEndEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDebugMarkerEndEXT); + cmock_call_instance = (CMOCK_vkCmdDebugMarkerEndEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDebugMarkerEndEXT_CallInstance); + Mock.vkCmdDebugMarkerEndEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDebugMarkerEndEXT_CallInstance); + if (Mock.vkCmdDebugMarkerEndEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDebugMarkerEndEXT_CallbackBool && + Mock.vkCmdDebugMarkerEndEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDebugMarkerEndEXT_CallbackFunctionPointer(commandBuffer, Mock.vkCmdDebugMarkerEndEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDebugMarkerEndEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdDebugMarkerEndEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDebugMarkerEndEXT_CallbackFunctionPointer(commandBuffer, Mock.vkCmdDebugMarkerEndEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDebugMarkerEndEXT(CMOCK_vkCmdDebugMarkerEndEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer); +void CMockExpectParameters_vkCmdDebugMarkerEndEXT(CMOCK_vkCmdDebugMarkerEndEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; +} + +void vkCmdDebugMarkerEndEXT_CMockIgnore(void) +{ + Mock.vkCmdDebugMarkerEndEXT_IgnoreBool = (char)1; +} + +void vkCmdDebugMarkerEndEXT_CMockStopIgnore(void) +{ + Mock.vkCmdDebugMarkerEndEXT_IgnoreBool = (char)0; +} + +void vkCmdDebugMarkerEndEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDebugMarkerEndEXT_CALL_INSTANCE)); + CMOCK_vkCmdDebugMarkerEndEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDebugMarkerEndEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDebugMarkerEndEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDebugMarkerEndEXT_CallInstance, cmock_guts_index); + Mock.vkCmdDebugMarkerEndEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDebugMarkerEndEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDebugMarkerEndEXT_CALL_INSTANCE)); + CMOCK_vkCmdDebugMarkerEndEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDebugMarkerEndEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDebugMarkerEndEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDebugMarkerEndEXT_CallInstance, cmock_guts_index); + Mock.vkCmdDebugMarkerEndEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDebugMarkerEndEXT(cmock_call_instance, commandBuffer); +} + +void vkCmdDebugMarkerEndEXT_AddCallback(CMOCK_vkCmdDebugMarkerEndEXT_CALLBACK Callback) +{ + Mock.vkCmdDebugMarkerEndEXT_IgnoreBool = (char)0; + Mock.vkCmdDebugMarkerEndEXT_CallbackBool = (char)1; + Mock.vkCmdDebugMarkerEndEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdDebugMarkerEndEXT_Stub(CMOCK_vkCmdDebugMarkerEndEXT_CALLBACK Callback) +{ + Mock.vkCmdDebugMarkerEndEXT_IgnoreBool = (char)0; + Mock.vkCmdDebugMarkerEndEXT_CallbackBool = (char)0; + Mock.vkCmdDebugMarkerEndEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdDebugMarkerEndEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDebugMarkerEndEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDebugMarkerEndEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDebugMarkerEndEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDebugMarkerInsertEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDebugMarkerInsertEXT); + cmock_call_instance = (CMOCK_vkCmdDebugMarkerInsertEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDebugMarkerInsertEXT_CallInstance); + Mock.vkCmdDebugMarkerInsertEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDebugMarkerInsertEXT_CallInstance); + if (Mock.vkCmdDebugMarkerInsertEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDebugMarkerInsertEXT_CallbackBool && + Mock.vkCmdDebugMarkerInsertEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDebugMarkerInsertEXT_CallbackFunctionPointer(commandBuffer, pMarkerInfo, Mock.vkCmdDebugMarkerInsertEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDebugMarkerInsertEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMarkerInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdDebugMarkerInsertEXT,CMockString_pMarkerInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMarkerInfo), (void*)(pMarkerInfo), sizeof(const VkDebugMarkerMarkerInfoEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdDebugMarkerInsertEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDebugMarkerInsertEXT_CallbackFunctionPointer(commandBuffer, pMarkerInfo, Mock.vkCmdDebugMarkerInsertEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDebugMarkerInsertEXT(CMOCK_vkCmdDebugMarkerInsertEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); +void CMockExpectParameters_vkCmdDebugMarkerInsertEXT(CMOCK_vkCmdDebugMarkerInsertEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pMarkerInfo = pMarkerInfo; + cmock_call_instance->IgnoreArg_pMarkerInfo = 0; +} + +void vkCmdDebugMarkerInsertEXT_CMockIgnore(void) +{ + Mock.vkCmdDebugMarkerInsertEXT_IgnoreBool = (char)1; +} + +void vkCmdDebugMarkerInsertEXT_CMockStopIgnore(void) +{ + Mock.vkCmdDebugMarkerInsertEXT_IgnoreBool = (char)0; +} + +void vkCmdDebugMarkerInsertEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDebugMarkerInsertEXT_CALL_INSTANCE)); + CMOCK_vkCmdDebugMarkerInsertEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDebugMarkerInsertEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDebugMarkerInsertEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDebugMarkerInsertEXT_CallInstance, cmock_guts_index); + Mock.vkCmdDebugMarkerInsertEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDebugMarkerInsertEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDebugMarkerInsertEXT_CALL_INSTANCE)); + CMOCK_vkCmdDebugMarkerInsertEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDebugMarkerInsertEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDebugMarkerInsertEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDebugMarkerInsertEXT_CallInstance, cmock_guts_index); + Mock.vkCmdDebugMarkerInsertEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDebugMarkerInsertEXT(cmock_call_instance, commandBuffer, pMarkerInfo); +} + +void vkCmdDebugMarkerInsertEXT_AddCallback(CMOCK_vkCmdDebugMarkerInsertEXT_CALLBACK Callback) +{ + Mock.vkCmdDebugMarkerInsertEXT_IgnoreBool = (char)0; + Mock.vkCmdDebugMarkerInsertEXT_CallbackBool = (char)1; + Mock.vkCmdDebugMarkerInsertEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdDebugMarkerInsertEXT_Stub(CMOCK_vkCmdDebugMarkerInsertEXT_CALLBACK Callback) +{ + Mock.vkCmdDebugMarkerInsertEXT_IgnoreBool = (char)0; + Mock.vkCmdDebugMarkerInsertEXT_CallbackBool = (char)0; + Mock.vkCmdDebugMarkerInsertEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdDebugMarkerInsertEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDebugMarkerInsertEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDebugMarkerInsertEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDebugMarkerInsertEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDebugMarkerInsertEXT_CMockIgnoreArg_pMarkerInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDebugMarkerInsertEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDebugMarkerInsertEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDebugMarkerInsertEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMarkerInfo = 1; +} + +void vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBindTransformFeedbackBuffersEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBindTransformFeedbackBuffersEXT); + cmock_call_instance = (CMOCK_vkCmdBindTransformFeedbackBuffersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBindTransformFeedbackBuffersEXT_CallInstance); + Mock.vkCmdBindTransformFeedbackBuffersEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBindTransformFeedbackBuffersEXT_CallInstance); + if (Mock.vkCmdBindTransformFeedbackBuffersEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBindTransformFeedbackBuffersEXT_CallbackBool && + Mock.vkCmdBindTransformFeedbackBuffersEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBindTransformFeedbackBuffersEXT_CallbackFunctionPointer(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, Mock.vkCmdBindTransformFeedbackBuffersEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindTransformFeedbackBuffersEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstBinding) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindTransformFeedbackBuffersEXT,CMockString_firstBinding); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstBinding, firstBinding, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_bindingCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindTransformFeedbackBuffersEXT,CMockString_bindingCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_bindingCount, bindingCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pBuffers) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindTransformFeedbackBuffersEXT,CMockString_pBuffers); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pBuffers), (void*)(pBuffers), sizeof(const VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pOffsets) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindTransformFeedbackBuffersEXT,CMockString_pOffsets); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pOffsets), (void*)(pOffsets), sizeof(const VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSizes) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindTransformFeedbackBuffersEXT,CMockString_pSizes); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSizes), (void*)(pSizes), sizeof(const VkDeviceSize), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdBindTransformFeedbackBuffersEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBindTransformFeedbackBuffersEXT_CallbackFunctionPointer(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, Mock.vkCmdBindTransformFeedbackBuffersEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBindTransformFeedbackBuffersEXT(CMOCK_vkCmdBindTransformFeedbackBuffersEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes); +void CMockExpectParameters_vkCmdBindTransformFeedbackBuffersEXT(CMOCK_vkCmdBindTransformFeedbackBuffersEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_firstBinding = firstBinding; + cmock_call_instance->IgnoreArg_firstBinding = 0; + cmock_call_instance->Expected_bindingCount = bindingCount; + cmock_call_instance->IgnoreArg_bindingCount = 0; + cmock_call_instance->Expected_pBuffers = pBuffers; + cmock_call_instance->IgnoreArg_pBuffers = 0; + cmock_call_instance->Expected_pOffsets = pOffsets; + cmock_call_instance->IgnoreArg_pOffsets = 0; + cmock_call_instance->Expected_pSizes = pSizes; + cmock_call_instance->IgnoreArg_pSizes = 0; +} + +void vkCmdBindTransformFeedbackBuffersEXT_CMockIgnore(void) +{ + Mock.vkCmdBindTransformFeedbackBuffersEXT_IgnoreBool = (char)1; +} + +void vkCmdBindTransformFeedbackBuffersEXT_CMockStopIgnore(void) +{ + Mock.vkCmdBindTransformFeedbackBuffersEXT_IgnoreBool = (char)0; +} + +void vkCmdBindTransformFeedbackBuffersEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBindTransformFeedbackBuffersEXT_CALL_INSTANCE)); + CMOCK_vkCmdBindTransformFeedbackBuffersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindTransformFeedbackBuffersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBindTransformFeedbackBuffersEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBindTransformFeedbackBuffersEXT_CallInstance, cmock_guts_index); + Mock.vkCmdBindTransformFeedbackBuffersEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBindTransformFeedbackBuffersEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBindTransformFeedbackBuffersEXT_CALL_INSTANCE)); + CMOCK_vkCmdBindTransformFeedbackBuffersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindTransformFeedbackBuffersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBindTransformFeedbackBuffersEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBindTransformFeedbackBuffersEXT_CallInstance, cmock_guts_index); + Mock.vkCmdBindTransformFeedbackBuffersEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBindTransformFeedbackBuffersEXT(cmock_call_instance, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes); +} + +void vkCmdBindTransformFeedbackBuffersEXT_AddCallback(CMOCK_vkCmdBindTransformFeedbackBuffersEXT_CALLBACK Callback) +{ + Mock.vkCmdBindTransformFeedbackBuffersEXT_IgnoreBool = (char)0; + Mock.vkCmdBindTransformFeedbackBuffersEXT_CallbackBool = (char)1; + Mock.vkCmdBindTransformFeedbackBuffersEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdBindTransformFeedbackBuffersEXT_Stub(CMOCK_vkCmdBindTransformFeedbackBuffersEXT_CALLBACK Callback) +{ + Mock.vkCmdBindTransformFeedbackBuffersEXT_IgnoreBool = (char)0; + Mock.vkCmdBindTransformFeedbackBuffersEXT_CallbackBool = (char)0; + Mock.vkCmdBindTransformFeedbackBuffersEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdBindTransformFeedbackBuffersEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindTransformFeedbackBuffersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindTransformFeedbackBuffersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindTransformFeedbackBuffersEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBindTransformFeedbackBuffersEXT_CMockIgnoreArg_firstBinding(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindTransformFeedbackBuffersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindTransformFeedbackBuffersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindTransformFeedbackBuffersEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstBinding = 1; +} + +void vkCmdBindTransformFeedbackBuffersEXT_CMockIgnoreArg_bindingCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindTransformFeedbackBuffersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindTransformFeedbackBuffersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindTransformFeedbackBuffersEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_bindingCount = 1; +} + +void vkCmdBindTransformFeedbackBuffersEXT_CMockIgnoreArg_pBuffers(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindTransformFeedbackBuffersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindTransformFeedbackBuffersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindTransformFeedbackBuffersEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pBuffers = 1; +} + +void vkCmdBindTransformFeedbackBuffersEXT_CMockIgnoreArg_pOffsets(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindTransformFeedbackBuffersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindTransformFeedbackBuffersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindTransformFeedbackBuffersEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pOffsets = 1; +} + +void vkCmdBindTransformFeedbackBuffersEXT_CMockIgnoreArg_pSizes(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindTransformFeedbackBuffersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindTransformFeedbackBuffersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindTransformFeedbackBuffersEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSizes = 1; +} + +void vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBeginTransformFeedbackEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBeginTransformFeedbackEXT); + cmock_call_instance = (CMOCK_vkCmdBeginTransformFeedbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBeginTransformFeedbackEXT_CallInstance); + Mock.vkCmdBeginTransformFeedbackEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBeginTransformFeedbackEXT_CallInstance); + if (Mock.vkCmdBeginTransformFeedbackEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBeginTransformFeedbackEXT_CallbackBool && + Mock.vkCmdBeginTransformFeedbackEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBeginTransformFeedbackEXT_CallbackFunctionPointer(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets, Mock.vkCmdBeginTransformFeedbackEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginTransformFeedbackEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstCounterBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginTransformFeedbackEXT,CMockString_firstCounterBuffer); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstCounterBuffer, firstCounterBuffer, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_counterBufferCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginTransformFeedbackEXT,CMockString_counterBufferCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_counterBufferCount, counterBufferCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCounterBuffers) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginTransformFeedbackEXT,CMockString_pCounterBuffers); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCounterBuffers), (void*)(pCounterBuffers), sizeof(const VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCounterBufferOffsets) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginTransformFeedbackEXT,CMockString_pCounterBufferOffsets); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCounterBufferOffsets), (void*)(pCounterBufferOffsets), sizeof(const VkDeviceSize), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdBeginTransformFeedbackEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBeginTransformFeedbackEXT_CallbackFunctionPointer(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets, Mock.vkCmdBeginTransformFeedbackEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBeginTransformFeedbackEXT(CMOCK_vkCmdBeginTransformFeedbackEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets); +void CMockExpectParameters_vkCmdBeginTransformFeedbackEXT(CMOCK_vkCmdBeginTransformFeedbackEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_firstCounterBuffer = firstCounterBuffer; + cmock_call_instance->IgnoreArg_firstCounterBuffer = 0; + cmock_call_instance->Expected_counterBufferCount = counterBufferCount; + cmock_call_instance->IgnoreArg_counterBufferCount = 0; + cmock_call_instance->Expected_pCounterBuffers = pCounterBuffers; + cmock_call_instance->IgnoreArg_pCounterBuffers = 0; + cmock_call_instance->Expected_pCounterBufferOffsets = pCounterBufferOffsets; + cmock_call_instance->IgnoreArg_pCounterBufferOffsets = 0; +} + +void vkCmdBeginTransformFeedbackEXT_CMockIgnore(void) +{ + Mock.vkCmdBeginTransformFeedbackEXT_IgnoreBool = (char)1; +} + +void vkCmdBeginTransformFeedbackEXT_CMockStopIgnore(void) +{ + Mock.vkCmdBeginTransformFeedbackEXT_IgnoreBool = (char)0; +} + +void vkCmdBeginTransformFeedbackEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBeginTransformFeedbackEXT_CALL_INSTANCE)); + CMOCK_vkCmdBeginTransformFeedbackEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginTransformFeedbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBeginTransformFeedbackEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBeginTransformFeedbackEXT_CallInstance, cmock_guts_index); + Mock.vkCmdBeginTransformFeedbackEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBeginTransformFeedbackEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBeginTransformFeedbackEXT_CALL_INSTANCE)); + CMOCK_vkCmdBeginTransformFeedbackEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginTransformFeedbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBeginTransformFeedbackEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBeginTransformFeedbackEXT_CallInstance, cmock_guts_index); + Mock.vkCmdBeginTransformFeedbackEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBeginTransformFeedbackEXT(cmock_call_instance, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); +} + +void vkCmdBeginTransformFeedbackEXT_AddCallback(CMOCK_vkCmdBeginTransformFeedbackEXT_CALLBACK Callback) +{ + Mock.vkCmdBeginTransformFeedbackEXT_IgnoreBool = (char)0; + Mock.vkCmdBeginTransformFeedbackEXT_CallbackBool = (char)1; + Mock.vkCmdBeginTransformFeedbackEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdBeginTransformFeedbackEXT_Stub(CMOCK_vkCmdBeginTransformFeedbackEXT_CALLBACK Callback) +{ + Mock.vkCmdBeginTransformFeedbackEXT_IgnoreBool = (char)0; + Mock.vkCmdBeginTransformFeedbackEXT_CallbackBool = (char)0; + Mock.vkCmdBeginTransformFeedbackEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdBeginTransformFeedbackEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginTransformFeedbackEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginTransformFeedbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginTransformFeedbackEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBeginTransformFeedbackEXT_CMockIgnoreArg_firstCounterBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginTransformFeedbackEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginTransformFeedbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginTransformFeedbackEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstCounterBuffer = 1; +} + +void vkCmdBeginTransformFeedbackEXT_CMockIgnoreArg_counterBufferCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginTransformFeedbackEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginTransformFeedbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginTransformFeedbackEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_counterBufferCount = 1; +} + +void vkCmdBeginTransformFeedbackEXT_CMockIgnoreArg_pCounterBuffers(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginTransformFeedbackEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginTransformFeedbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginTransformFeedbackEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCounterBuffers = 1; +} + +void vkCmdBeginTransformFeedbackEXT_CMockIgnoreArg_pCounterBufferOffsets(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginTransformFeedbackEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginTransformFeedbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginTransformFeedbackEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCounterBufferOffsets = 1; +} + +void vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdEndTransformFeedbackEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdEndTransformFeedbackEXT); + cmock_call_instance = (CMOCK_vkCmdEndTransformFeedbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdEndTransformFeedbackEXT_CallInstance); + Mock.vkCmdEndTransformFeedbackEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdEndTransformFeedbackEXT_CallInstance); + if (Mock.vkCmdEndTransformFeedbackEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdEndTransformFeedbackEXT_CallbackBool && + Mock.vkCmdEndTransformFeedbackEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdEndTransformFeedbackEXT_CallbackFunctionPointer(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets, Mock.vkCmdEndTransformFeedbackEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdEndTransformFeedbackEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstCounterBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdEndTransformFeedbackEXT,CMockString_firstCounterBuffer); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstCounterBuffer, firstCounterBuffer, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_counterBufferCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdEndTransformFeedbackEXT,CMockString_counterBufferCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_counterBufferCount, counterBufferCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCounterBuffers) + { + UNITY_SET_DETAILS(CMockString_vkCmdEndTransformFeedbackEXT,CMockString_pCounterBuffers); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCounterBuffers), (void*)(pCounterBuffers), sizeof(const VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCounterBufferOffsets) + { + UNITY_SET_DETAILS(CMockString_vkCmdEndTransformFeedbackEXT,CMockString_pCounterBufferOffsets); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCounterBufferOffsets), (void*)(pCounterBufferOffsets), sizeof(const VkDeviceSize), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdEndTransformFeedbackEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdEndTransformFeedbackEXT_CallbackFunctionPointer(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets, Mock.vkCmdEndTransformFeedbackEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdEndTransformFeedbackEXT(CMOCK_vkCmdEndTransformFeedbackEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets); +void CMockExpectParameters_vkCmdEndTransformFeedbackEXT(CMOCK_vkCmdEndTransformFeedbackEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_firstCounterBuffer = firstCounterBuffer; + cmock_call_instance->IgnoreArg_firstCounterBuffer = 0; + cmock_call_instance->Expected_counterBufferCount = counterBufferCount; + cmock_call_instance->IgnoreArg_counterBufferCount = 0; + cmock_call_instance->Expected_pCounterBuffers = pCounterBuffers; + cmock_call_instance->IgnoreArg_pCounterBuffers = 0; + cmock_call_instance->Expected_pCounterBufferOffsets = pCounterBufferOffsets; + cmock_call_instance->IgnoreArg_pCounterBufferOffsets = 0; +} + +void vkCmdEndTransformFeedbackEXT_CMockIgnore(void) +{ + Mock.vkCmdEndTransformFeedbackEXT_IgnoreBool = (char)1; +} + +void vkCmdEndTransformFeedbackEXT_CMockStopIgnore(void) +{ + Mock.vkCmdEndTransformFeedbackEXT_IgnoreBool = (char)0; +} + +void vkCmdEndTransformFeedbackEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdEndTransformFeedbackEXT_CALL_INSTANCE)); + CMOCK_vkCmdEndTransformFeedbackEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndTransformFeedbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdEndTransformFeedbackEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdEndTransformFeedbackEXT_CallInstance, cmock_guts_index); + Mock.vkCmdEndTransformFeedbackEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdEndTransformFeedbackEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdEndTransformFeedbackEXT_CALL_INSTANCE)); + CMOCK_vkCmdEndTransformFeedbackEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndTransformFeedbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdEndTransformFeedbackEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdEndTransformFeedbackEXT_CallInstance, cmock_guts_index); + Mock.vkCmdEndTransformFeedbackEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdEndTransformFeedbackEXT(cmock_call_instance, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); +} + +void vkCmdEndTransformFeedbackEXT_AddCallback(CMOCK_vkCmdEndTransformFeedbackEXT_CALLBACK Callback) +{ + Mock.vkCmdEndTransformFeedbackEXT_IgnoreBool = (char)0; + Mock.vkCmdEndTransformFeedbackEXT_CallbackBool = (char)1; + Mock.vkCmdEndTransformFeedbackEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdEndTransformFeedbackEXT_Stub(CMOCK_vkCmdEndTransformFeedbackEXT_CALLBACK Callback) +{ + Mock.vkCmdEndTransformFeedbackEXT_IgnoreBool = (char)0; + Mock.vkCmdEndTransformFeedbackEXT_CallbackBool = (char)0; + Mock.vkCmdEndTransformFeedbackEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdEndTransformFeedbackEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdEndTransformFeedbackEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndTransformFeedbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdEndTransformFeedbackEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdEndTransformFeedbackEXT_CMockIgnoreArg_firstCounterBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdEndTransformFeedbackEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndTransformFeedbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdEndTransformFeedbackEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstCounterBuffer = 1; +} + +void vkCmdEndTransformFeedbackEXT_CMockIgnoreArg_counterBufferCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdEndTransformFeedbackEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndTransformFeedbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdEndTransformFeedbackEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_counterBufferCount = 1; +} + +void vkCmdEndTransformFeedbackEXT_CMockIgnoreArg_pCounterBuffers(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdEndTransformFeedbackEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndTransformFeedbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdEndTransformFeedbackEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCounterBuffers = 1; +} + +void vkCmdEndTransformFeedbackEXT_CMockIgnoreArg_pCounterBufferOffsets(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdEndTransformFeedbackEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndTransformFeedbackEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdEndTransformFeedbackEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCounterBufferOffsets = 1; +} + +void vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBeginQueryIndexedEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBeginQueryIndexedEXT); + cmock_call_instance = (CMOCK_vkCmdBeginQueryIndexedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBeginQueryIndexedEXT_CallInstance); + Mock.vkCmdBeginQueryIndexedEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBeginQueryIndexedEXT_CallInstance); + if (Mock.vkCmdBeginQueryIndexedEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBeginQueryIndexedEXT_CallbackBool && + Mock.vkCmdBeginQueryIndexedEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBeginQueryIndexedEXT_CallbackFunctionPointer(commandBuffer, queryPool, query, flags, index, Mock.vkCmdBeginQueryIndexedEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginQueryIndexedEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queryPool) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginQueryIndexedEXT,CMockString_queryPool); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), sizeof(VkQueryPool), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_query) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginQueryIndexedEXT,CMockString_query); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_query, query, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_flags) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginQueryIndexedEXT,CMockString_flags); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_flags), (void*)(&flags), sizeof(VkQueryControlFlags), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_index) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginQueryIndexedEXT,CMockString_index); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_index, index, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdBeginQueryIndexedEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBeginQueryIndexedEXT_CallbackFunctionPointer(commandBuffer, queryPool, query, flags, index, Mock.vkCmdBeginQueryIndexedEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBeginQueryIndexedEXT(CMOCK_vkCmdBeginQueryIndexedEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index); +void CMockExpectParameters_vkCmdBeginQueryIndexedEXT(CMOCK_vkCmdBeginQueryIndexedEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), + sizeof(VkQueryPool[sizeof(queryPool) == sizeof(VkQueryPool) ? 1 : -1])); /* add VkQueryPool to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queryPool = 0; + cmock_call_instance->Expected_query = query; + cmock_call_instance->IgnoreArg_query = 0; + memcpy((void*)(&cmock_call_instance->Expected_flags), (void*)(&flags), + sizeof(VkQueryControlFlags[sizeof(flags) == sizeof(VkQueryControlFlags) ? 1 : -1])); /* add VkQueryControlFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_flags = 0; + cmock_call_instance->Expected_index = index; + cmock_call_instance->IgnoreArg_index = 0; +} + +void vkCmdBeginQueryIndexedEXT_CMockIgnore(void) +{ + Mock.vkCmdBeginQueryIndexedEXT_IgnoreBool = (char)1; +} + +void vkCmdBeginQueryIndexedEXT_CMockStopIgnore(void) +{ + Mock.vkCmdBeginQueryIndexedEXT_IgnoreBool = (char)0; +} + +void vkCmdBeginQueryIndexedEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBeginQueryIndexedEXT_CALL_INSTANCE)); + CMOCK_vkCmdBeginQueryIndexedEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginQueryIndexedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBeginQueryIndexedEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBeginQueryIndexedEXT_CallInstance, cmock_guts_index); + Mock.vkCmdBeginQueryIndexedEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBeginQueryIndexedEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBeginQueryIndexedEXT_CALL_INSTANCE)); + CMOCK_vkCmdBeginQueryIndexedEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginQueryIndexedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBeginQueryIndexedEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBeginQueryIndexedEXT_CallInstance, cmock_guts_index); + Mock.vkCmdBeginQueryIndexedEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBeginQueryIndexedEXT(cmock_call_instance, commandBuffer, queryPool, query, flags, index); +} + +void vkCmdBeginQueryIndexedEXT_AddCallback(CMOCK_vkCmdBeginQueryIndexedEXT_CALLBACK Callback) +{ + Mock.vkCmdBeginQueryIndexedEXT_IgnoreBool = (char)0; + Mock.vkCmdBeginQueryIndexedEXT_CallbackBool = (char)1; + Mock.vkCmdBeginQueryIndexedEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdBeginQueryIndexedEXT_Stub(CMOCK_vkCmdBeginQueryIndexedEXT_CALLBACK Callback) +{ + Mock.vkCmdBeginQueryIndexedEXT_IgnoreBool = (char)0; + Mock.vkCmdBeginQueryIndexedEXT_CallbackBool = (char)0; + Mock.vkCmdBeginQueryIndexedEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdBeginQueryIndexedEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginQueryIndexedEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginQueryIndexedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginQueryIndexedEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBeginQueryIndexedEXT_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginQueryIndexedEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginQueryIndexedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginQueryIndexedEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queryPool = 1; +} + +void vkCmdBeginQueryIndexedEXT_CMockIgnoreArg_query(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginQueryIndexedEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginQueryIndexedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginQueryIndexedEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_query = 1; +} + +void vkCmdBeginQueryIndexedEXT_CMockIgnoreArg_flags(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginQueryIndexedEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginQueryIndexedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginQueryIndexedEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_flags = 1; +} + +void vkCmdBeginQueryIndexedEXT_CMockIgnoreArg_index(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginQueryIndexedEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginQueryIndexedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginQueryIndexedEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_index = 1; +} + +void vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdEndQueryIndexedEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdEndQueryIndexedEXT); + cmock_call_instance = (CMOCK_vkCmdEndQueryIndexedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdEndQueryIndexedEXT_CallInstance); + Mock.vkCmdEndQueryIndexedEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdEndQueryIndexedEXT_CallInstance); + if (Mock.vkCmdEndQueryIndexedEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdEndQueryIndexedEXT_CallbackBool && + Mock.vkCmdEndQueryIndexedEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdEndQueryIndexedEXT_CallbackFunctionPointer(commandBuffer, queryPool, query, index, Mock.vkCmdEndQueryIndexedEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdEndQueryIndexedEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queryPool) + { + UNITY_SET_DETAILS(CMockString_vkCmdEndQueryIndexedEXT,CMockString_queryPool); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), sizeof(VkQueryPool), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_query) + { + UNITY_SET_DETAILS(CMockString_vkCmdEndQueryIndexedEXT,CMockString_query); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_query, query, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_index) + { + UNITY_SET_DETAILS(CMockString_vkCmdEndQueryIndexedEXT,CMockString_index); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_index, index, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdEndQueryIndexedEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdEndQueryIndexedEXT_CallbackFunctionPointer(commandBuffer, queryPool, query, index, Mock.vkCmdEndQueryIndexedEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdEndQueryIndexedEXT(CMOCK_vkCmdEndQueryIndexedEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index); +void CMockExpectParameters_vkCmdEndQueryIndexedEXT(CMOCK_vkCmdEndQueryIndexedEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), + sizeof(VkQueryPool[sizeof(queryPool) == sizeof(VkQueryPool) ? 1 : -1])); /* add VkQueryPool to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queryPool = 0; + cmock_call_instance->Expected_query = query; + cmock_call_instance->IgnoreArg_query = 0; + cmock_call_instance->Expected_index = index; + cmock_call_instance->IgnoreArg_index = 0; +} + +void vkCmdEndQueryIndexedEXT_CMockIgnore(void) +{ + Mock.vkCmdEndQueryIndexedEXT_IgnoreBool = (char)1; +} + +void vkCmdEndQueryIndexedEXT_CMockStopIgnore(void) +{ + Mock.vkCmdEndQueryIndexedEXT_IgnoreBool = (char)0; +} + +void vkCmdEndQueryIndexedEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdEndQueryIndexedEXT_CALL_INSTANCE)); + CMOCK_vkCmdEndQueryIndexedEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndQueryIndexedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdEndQueryIndexedEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdEndQueryIndexedEXT_CallInstance, cmock_guts_index); + Mock.vkCmdEndQueryIndexedEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdEndQueryIndexedEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdEndQueryIndexedEXT_CALL_INSTANCE)); + CMOCK_vkCmdEndQueryIndexedEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndQueryIndexedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdEndQueryIndexedEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdEndQueryIndexedEXT_CallInstance, cmock_guts_index); + Mock.vkCmdEndQueryIndexedEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdEndQueryIndexedEXT(cmock_call_instance, commandBuffer, queryPool, query, index); +} + +void vkCmdEndQueryIndexedEXT_AddCallback(CMOCK_vkCmdEndQueryIndexedEXT_CALLBACK Callback) +{ + Mock.vkCmdEndQueryIndexedEXT_IgnoreBool = (char)0; + Mock.vkCmdEndQueryIndexedEXT_CallbackBool = (char)1; + Mock.vkCmdEndQueryIndexedEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdEndQueryIndexedEXT_Stub(CMOCK_vkCmdEndQueryIndexedEXT_CALLBACK Callback) +{ + Mock.vkCmdEndQueryIndexedEXT_IgnoreBool = (char)0; + Mock.vkCmdEndQueryIndexedEXT_CallbackBool = (char)0; + Mock.vkCmdEndQueryIndexedEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdEndQueryIndexedEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdEndQueryIndexedEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndQueryIndexedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdEndQueryIndexedEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdEndQueryIndexedEXT_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdEndQueryIndexedEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndQueryIndexedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdEndQueryIndexedEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queryPool = 1; +} + +void vkCmdEndQueryIndexedEXT_CMockIgnoreArg_query(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdEndQueryIndexedEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndQueryIndexedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdEndQueryIndexedEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_query = 1; +} + +void vkCmdEndQueryIndexedEXT_CMockIgnoreArg_index(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdEndQueryIndexedEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndQueryIndexedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdEndQueryIndexedEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_index = 1; +} + +void vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDrawIndirectByteCountEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDrawIndirectByteCountEXT); + cmock_call_instance = (CMOCK_vkCmdDrawIndirectByteCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDrawIndirectByteCountEXT_CallInstance); + Mock.vkCmdDrawIndirectByteCountEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDrawIndirectByteCountEXT_CallInstance); + if (Mock.vkCmdDrawIndirectByteCountEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDrawIndirectByteCountEXT_CallbackBool && + Mock.vkCmdDrawIndirectByteCountEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawIndirectByteCountEXT_CallbackFunctionPointer(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride, Mock.vkCmdDrawIndirectByteCountEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirectByteCountEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_instanceCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirectByteCountEXT,CMockString_instanceCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_instanceCount, instanceCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstInstance) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirectByteCountEXT,CMockString_firstInstance); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstInstance, firstInstance, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_counterBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirectByteCountEXT,CMockString_counterBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_counterBuffer), (void*)(&counterBuffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_counterBufferOffset) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirectByteCountEXT,CMockString_counterBufferOffset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_counterBufferOffset), (void*)(&counterBufferOffset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_counterOffset) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirectByteCountEXT,CMockString_counterOffset); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_counterOffset, counterOffset, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_vertexStride) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirectByteCountEXT,CMockString_vertexStride); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_vertexStride, vertexStride, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdDrawIndirectByteCountEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawIndirectByteCountEXT_CallbackFunctionPointer(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride, Mock.vkCmdDrawIndirectByteCountEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDrawIndirectByteCountEXT(CMOCK_vkCmdDrawIndirectByteCountEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride); +void CMockExpectParameters_vkCmdDrawIndirectByteCountEXT(CMOCK_vkCmdDrawIndirectByteCountEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_instanceCount = instanceCount; + cmock_call_instance->IgnoreArg_instanceCount = 0; + cmock_call_instance->Expected_firstInstance = firstInstance; + cmock_call_instance->IgnoreArg_firstInstance = 0; + memcpy((void*)(&cmock_call_instance->Expected_counterBuffer), (void*)(&counterBuffer), + sizeof(VkBuffer[sizeof(counterBuffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_counterBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_counterBufferOffset), (void*)(&counterBufferOffset), + sizeof(VkDeviceSize[sizeof(counterBufferOffset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_counterBufferOffset = 0; + cmock_call_instance->Expected_counterOffset = counterOffset; + cmock_call_instance->IgnoreArg_counterOffset = 0; + cmock_call_instance->Expected_vertexStride = vertexStride; + cmock_call_instance->IgnoreArg_vertexStride = 0; +} + +void vkCmdDrawIndirectByteCountEXT_CMockIgnore(void) +{ + Mock.vkCmdDrawIndirectByteCountEXT_IgnoreBool = (char)1; +} + +void vkCmdDrawIndirectByteCountEXT_CMockStopIgnore(void) +{ + Mock.vkCmdDrawIndirectByteCountEXT_IgnoreBool = (char)0; +} + +void vkCmdDrawIndirectByteCountEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawIndirectByteCountEXT_CALL_INSTANCE)); + CMOCK_vkCmdDrawIndirectByteCountEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectByteCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawIndirectByteCountEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawIndirectByteCountEXT_CallInstance, cmock_guts_index); + Mock.vkCmdDrawIndirectByteCountEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDrawIndirectByteCountEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawIndirectByteCountEXT_CALL_INSTANCE)); + CMOCK_vkCmdDrawIndirectByteCountEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectByteCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawIndirectByteCountEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawIndirectByteCountEXT_CallInstance, cmock_guts_index); + Mock.vkCmdDrawIndirectByteCountEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDrawIndirectByteCountEXT(cmock_call_instance, commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride); +} + +void vkCmdDrawIndirectByteCountEXT_AddCallback(CMOCK_vkCmdDrawIndirectByteCountEXT_CALLBACK Callback) +{ + Mock.vkCmdDrawIndirectByteCountEXT_IgnoreBool = (char)0; + Mock.vkCmdDrawIndirectByteCountEXT_CallbackBool = (char)1; + Mock.vkCmdDrawIndirectByteCountEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawIndirectByteCountEXT_Stub(CMOCK_vkCmdDrawIndirectByteCountEXT_CALLBACK Callback) +{ + Mock.vkCmdDrawIndirectByteCountEXT_IgnoreBool = (char)0; + Mock.vkCmdDrawIndirectByteCountEXT_CallbackBool = (char)0; + Mock.vkCmdDrawIndirectByteCountEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawIndirectByteCountEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirectByteCountEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectByteCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirectByteCountEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDrawIndirectByteCountEXT_CMockIgnoreArg_instanceCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirectByteCountEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectByteCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirectByteCountEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_instanceCount = 1; +} + +void vkCmdDrawIndirectByteCountEXT_CMockIgnoreArg_firstInstance(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirectByteCountEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectByteCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirectByteCountEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstInstance = 1; +} + +void vkCmdDrawIndirectByteCountEXT_CMockIgnoreArg_counterBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirectByteCountEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectByteCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirectByteCountEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_counterBuffer = 1; +} + +void vkCmdDrawIndirectByteCountEXT_CMockIgnoreArg_counterBufferOffset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirectByteCountEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectByteCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirectByteCountEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_counterBufferOffset = 1; +} + +void vkCmdDrawIndirectByteCountEXT_CMockIgnoreArg_counterOffset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirectByteCountEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectByteCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirectByteCountEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_counterOffset = 1; +} + +void vkCmdDrawIndirectByteCountEXT_CMockIgnoreArg_vertexStride(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirectByteCountEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectByteCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirectByteCountEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_vertexStride = 1; +} + +VkResult vkCreateCuModuleNVX(VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateCuModuleNVX_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateCuModuleNVX); + cmock_call_instance = (CMOCK_vkCreateCuModuleNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateCuModuleNVX_CallInstance); + Mock.vkCreateCuModuleNVX_CallInstance = CMock_Guts_MemNext(Mock.vkCreateCuModuleNVX_CallInstance); + if (Mock.vkCreateCuModuleNVX_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateCuModuleNVX_FinalReturn; + memcpy((void*)(&Mock.vkCreateCuModuleNVX_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateCuModuleNVX_CallbackBool && + Mock.vkCreateCuModuleNVX_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateCuModuleNVX_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pModule, Mock.vkCreateCuModuleNVX_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateCuModuleNVX,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateCuModuleNVX,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkCuModuleCreateInfoNVX), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateCuModuleNVX,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pModule) + { + UNITY_SET_DETAILS(CMockString_vkCreateCuModuleNVX,CMockString_pModule); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pModule), (void*)(pModule), sizeof(VkCuModuleNVX), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateCuModuleNVX_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateCuModuleNVX_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pModule, Mock.vkCreateCuModuleNVX_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pModule_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pModule, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pModule, (const void*)cmock_call_instance->ReturnThruPtr_pModule_Val, + cmock_call_instance->ReturnThruPtr_pModule_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateCuModuleNVX(CMOCK_vkCreateCuModuleNVX_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule); +void CMockExpectParameters_vkCreateCuModuleNVX(CMOCK_vkCreateCuModuleNVX_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pModule = pModule; + cmock_call_instance->IgnoreArg_pModule = 0; + cmock_call_instance->ReturnThruPtr_pModule_Used = 0; +} + +void vkCreateCuModuleNVX_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateCuModuleNVX_CALL_INSTANCE)); + CMOCK_vkCreateCuModuleNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateCuModuleNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateCuModuleNVX_CallInstance = CMock_Guts_MemChain(Mock.vkCreateCuModuleNVX_CallInstance, cmock_guts_index); + Mock.vkCreateCuModuleNVX_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateCuModuleNVX_IgnoreBool = (char)1; +} + +void vkCreateCuModuleNVX_CMockStopIgnore(void) +{ + if(Mock.vkCreateCuModuleNVX_IgnoreBool) + Mock.vkCreateCuModuleNVX_CallInstance = CMock_Guts_MemNext(Mock.vkCreateCuModuleNVX_CallInstance); + Mock.vkCreateCuModuleNVX_IgnoreBool = (char)0; +} + +void vkCreateCuModuleNVX_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateCuModuleNVX_CALL_INSTANCE)); + CMOCK_vkCreateCuModuleNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateCuModuleNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateCuModuleNVX_CallInstance = CMock_Guts_MemChain(Mock.vkCreateCuModuleNVX_CallInstance, cmock_guts_index); + Mock.vkCreateCuModuleNVX_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateCuModuleNVX_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateCuModuleNVX_CALL_INSTANCE)); + CMOCK_vkCreateCuModuleNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateCuModuleNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateCuModuleNVX_CallInstance = CMock_Guts_MemChain(Mock.vkCreateCuModuleNVX_CallInstance, cmock_guts_index); + Mock.vkCreateCuModuleNVX_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateCuModuleNVX(cmock_call_instance, device, pCreateInfo, pAllocator, pModule); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateCuModuleNVX_AddCallback(CMOCK_vkCreateCuModuleNVX_CALLBACK Callback) +{ + Mock.vkCreateCuModuleNVX_IgnoreBool = (char)0; + Mock.vkCreateCuModuleNVX_CallbackBool = (char)1; + Mock.vkCreateCuModuleNVX_CallbackFunctionPointer = Callback; +} + +void vkCreateCuModuleNVX_Stub(CMOCK_vkCreateCuModuleNVX_CALLBACK Callback) +{ + Mock.vkCreateCuModuleNVX_IgnoreBool = (char)0; + Mock.vkCreateCuModuleNVX_CallbackBool = (char)0; + Mock.vkCreateCuModuleNVX_CallbackFunctionPointer = Callback; +} + +void vkCreateCuModuleNVX_CMockReturnMemThruPtr_pModule(UNITY_LINE_TYPE cmock_line, VkCuModuleNVX const* pModule, size_t cmock_size) +{ + CMOCK_vkCreateCuModuleNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateCuModuleNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateCuModuleNVX_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pModule_Used = 1; + cmock_call_instance->ReturnThruPtr_pModule_Val = pModule; + cmock_call_instance->ReturnThruPtr_pModule_Size = cmock_size; +} + +void vkCreateCuModuleNVX_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateCuModuleNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateCuModuleNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateCuModuleNVX_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateCuModuleNVX_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateCuModuleNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateCuModuleNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateCuModuleNVX_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateCuModuleNVX_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateCuModuleNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateCuModuleNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateCuModuleNVX_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateCuModuleNVX_CMockIgnoreArg_pModule(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateCuModuleNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateCuModuleNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateCuModuleNVX_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pModule = 1; +} + +VkResult vkCreateCuFunctionNVX(VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateCuFunctionNVX_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateCuFunctionNVX); + cmock_call_instance = (CMOCK_vkCreateCuFunctionNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateCuFunctionNVX_CallInstance); + Mock.vkCreateCuFunctionNVX_CallInstance = CMock_Guts_MemNext(Mock.vkCreateCuFunctionNVX_CallInstance); + if (Mock.vkCreateCuFunctionNVX_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateCuFunctionNVX_FinalReturn; + memcpy((void*)(&Mock.vkCreateCuFunctionNVX_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateCuFunctionNVX_CallbackBool && + Mock.vkCreateCuFunctionNVX_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateCuFunctionNVX_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pFunction, Mock.vkCreateCuFunctionNVX_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateCuFunctionNVX,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateCuFunctionNVX,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkCuFunctionCreateInfoNVX), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateCuFunctionNVX,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pFunction) + { + UNITY_SET_DETAILS(CMockString_vkCreateCuFunctionNVX,CMockString_pFunction); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pFunction), (void*)(pFunction), sizeof(VkCuFunctionNVX), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateCuFunctionNVX_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateCuFunctionNVX_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pFunction, Mock.vkCreateCuFunctionNVX_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pFunction_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pFunction, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pFunction, (const void*)cmock_call_instance->ReturnThruPtr_pFunction_Val, + cmock_call_instance->ReturnThruPtr_pFunction_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateCuFunctionNVX(CMOCK_vkCreateCuFunctionNVX_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction); +void CMockExpectParameters_vkCreateCuFunctionNVX(CMOCK_vkCreateCuFunctionNVX_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pFunction = pFunction; + cmock_call_instance->IgnoreArg_pFunction = 0; + cmock_call_instance->ReturnThruPtr_pFunction_Used = 0; +} + +void vkCreateCuFunctionNVX_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateCuFunctionNVX_CALL_INSTANCE)); + CMOCK_vkCreateCuFunctionNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateCuFunctionNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateCuFunctionNVX_CallInstance = CMock_Guts_MemChain(Mock.vkCreateCuFunctionNVX_CallInstance, cmock_guts_index); + Mock.vkCreateCuFunctionNVX_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateCuFunctionNVX_IgnoreBool = (char)1; +} + +void vkCreateCuFunctionNVX_CMockStopIgnore(void) +{ + if(Mock.vkCreateCuFunctionNVX_IgnoreBool) + Mock.vkCreateCuFunctionNVX_CallInstance = CMock_Guts_MemNext(Mock.vkCreateCuFunctionNVX_CallInstance); + Mock.vkCreateCuFunctionNVX_IgnoreBool = (char)0; +} + +void vkCreateCuFunctionNVX_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateCuFunctionNVX_CALL_INSTANCE)); + CMOCK_vkCreateCuFunctionNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateCuFunctionNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateCuFunctionNVX_CallInstance = CMock_Guts_MemChain(Mock.vkCreateCuFunctionNVX_CallInstance, cmock_guts_index); + Mock.vkCreateCuFunctionNVX_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateCuFunctionNVX_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateCuFunctionNVX_CALL_INSTANCE)); + CMOCK_vkCreateCuFunctionNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateCuFunctionNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateCuFunctionNVX_CallInstance = CMock_Guts_MemChain(Mock.vkCreateCuFunctionNVX_CallInstance, cmock_guts_index); + Mock.vkCreateCuFunctionNVX_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateCuFunctionNVX(cmock_call_instance, device, pCreateInfo, pAllocator, pFunction); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateCuFunctionNVX_AddCallback(CMOCK_vkCreateCuFunctionNVX_CALLBACK Callback) +{ + Mock.vkCreateCuFunctionNVX_IgnoreBool = (char)0; + Mock.vkCreateCuFunctionNVX_CallbackBool = (char)1; + Mock.vkCreateCuFunctionNVX_CallbackFunctionPointer = Callback; +} + +void vkCreateCuFunctionNVX_Stub(CMOCK_vkCreateCuFunctionNVX_CALLBACK Callback) +{ + Mock.vkCreateCuFunctionNVX_IgnoreBool = (char)0; + Mock.vkCreateCuFunctionNVX_CallbackBool = (char)0; + Mock.vkCreateCuFunctionNVX_CallbackFunctionPointer = Callback; +} + +void vkCreateCuFunctionNVX_CMockReturnMemThruPtr_pFunction(UNITY_LINE_TYPE cmock_line, VkCuFunctionNVX const* pFunction, size_t cmock_size) +{ + CMOCK_vkCreateCuFunctionNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateCuFunctionNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateCuFunctionNVX_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pFunction_Used = 1; + cmock_call_instance->ReturnThruPtr_pFunction_Val = pFunction; + cmock_call_instance->ReturnThruPtr_pFunction_Size = cmock_size; +} + +void vkCreateCuFunctionNVX_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateCuFunctionNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateCuFunctionNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateCuFunctionNVX_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateCuFunctionNVX_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateCuFunctionNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateCuFunctionNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateCuFunctionNVX_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateCuFunctionNVX_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateCuFunctionNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateCuFunctionNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateCuFunctionNVX_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateCuFunctionNVX_CMockIgnoreArg_pFunction(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateCuFunctionNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateCuFunctionNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateCuFunctionNVX_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pFunction = 1; +} + +void vkDestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyCuModuleNVX_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyCuModuleNVX); + cmock_call_instance = (CMOCK_vkDestroyCuModuleNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyCuModuleNVX_CallInstance); + Mock.vkDestroyCuModuleNVX_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyCuModuleNVX_CallInstance); + if (Mock.vkDestroyCuModuleNVX_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyCuModuleNVX_CallbackBool && + Mock.vkDestroyCuModuleNVX_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyCuModuleNVX_CallbackFunctionPointer(device, module, pAllocator, Mock.vkDestroyCuModuleNVX_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyCuModuleNVX,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_module) + { + UNITY_SET_DETAILS(CMockString_vkDestroyCuModuleNVX,CMockString_module); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_module), (void*)(&module), sizeof(VkCuModuleNVX), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyCuModuleNVX,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyCuModuleNVX_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyCuModuleNVX_CallbackFunctionPointer(device, module, pAllocator, Mock.vkDestroyCuModuleNVX_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyCuModuleNVX(CMOCK_vkDestroyCuModuleNVX_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyCuModuleNVX(CMOCK_vkDestroyCuModuleNVX_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_module), (void*)(&module), + sizeof(VkCuModuleNVX[sizeof(module) == sizeof(VkCuModuleNVX) ? 1 : -1])); /* add VkCuModuleNVX to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_module = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyCuModuleNVX_CMockIgnore(void) +{ + Mock.vkDestroyCuModuleNVX_IgnoreBool = (char)1; +} + +void vkDestroyCuModuleNVX_CMockStopIgnore(void) +{ + Mock.vkDestroyCuModuleNVX_IgnoreBool = (char)0; +} + +void vkDestroyCuModuleNVX_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyCuModuleNVX_CALL_INSTANCE)); + CMOCK_vkDestroyCuModuleNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyCuModuleNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyCuModuleNVX_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyCuModuleNVX_CallInstance, cmock_guts_index); + Mock.vkDestroyCuModuleNVX_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyCuModuleNVX_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyCuModuleNVX_CALL_INSTANCE)); + CMOCK_vkDestroyCuModuleNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyCuModuleNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyCuModuleNVX_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyCuModuleNVX_CallInstance, cmock_guts_index); + Mock.vkDestroyCuModuleNVX_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyCuModuleNVX(cmock_call_instance, device, module, pAllocator); +} + +void vkDestroyCuModuleNVX_AddCallback(CMOCK_vkDestroyCuModuleNVX_CALLBACK Callback) +{ + Mock.vkDestroyCuModuleNVX_IgnoreBool = (char)0; + Mock.vkDestroyCuModuleNVX_CallbackBool = (char)1; + Mock.vkDestroyCuModuleNVX_CallbackFunctionPointer = Callback; +} + +void vkDestroyCuModuleNVX_Stub(CMOCK_vkDestroyCuModuleNVX_CALLBACK Callback) +{ + Mock.vkDestroyCuModuleNVX_IgnoreBool = (char)0; + Mock.vkDestroyCuModuleNVX_CallbackBool = (char)0; + Mock.vkDestroyCuModuleNVX_CallbackFunctionPointer = Callback; +} + +void vkDestroyCuModuleNVX_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyCuModuleNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyCuModuleNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyCuModuleNVX_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyCuModuleNVX_CMockIgnoreArg_module(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyCuModuleNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyCuModuleNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyCuModuleNVX_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_module = 1; +} + +void vkDestroyCuModuleNVX_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyCuModuleNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyCuModuleNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyCuModuleNVX_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkDestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyCuFunctionNVX_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyCuFunctionNVX); + cmock_call_instance = (CMOCK_vkDestroyCuFunctionNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyCuFunctionNVX_CallInstance); + Mock.vkDestroyCuFunctionNVX_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyCuFunctionNVX_CallInstance); + if (Mock.vkDestroyCuFunctionNVX_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyCuFunctionNVX_CallbackBool && + Mock.vkDestroyCuFunctionNVX_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyCuFunctionNVX_CallbackFunctionPointer(device, function, pAllocator, Mock.vkDestroyCuFunctionNVX_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyCuFunctionNVX,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_function) + { + UNITY_SET_DETAILS(CMockString_vkDestroyCuFunctionNVX,CMockString_function); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_function), (void*)(&function), sizeof(VkCuFunctionNVX), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyCuFunctionNVX,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyCuFunctionNVX_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyCuFunctionNVX_CallbackFunctionPointer(device, function, pAllocator, Mock.vkDestroyCuFunctionNVX_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyCuFunctionNVX(CMOCK_vkDestroyCuFunctionNVX_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyCuFunctionNVX(CMOCK_vkDestroyCuFunctionNVX_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_function), (void*)(&function), + sizeof(VkCuFunctionNVX[sizeof(function) == sizeof(VkCuFunctionNVX) ? 1 : -1])); /* add VkCuFunctionNVX to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_function = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyCuFunctionNVX_CMockIgnore(void) +{ + Mock.vkDestroyCuFunctionNVX_IgnoreBool = (char)1; +} + +void vkDestroyCuFunctionNVX_CMockStopIgnore(void) +{ + Mock.vkDestroyCuFunctionNVX_IgnoreBool = (char)0; +} + +void vkDestroyCuFunctionNVX_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyCuFunctionNVX_CALL_INSTANCE)); + CMOCK_vkDestroyCuFunctionNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyCuFunctionNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyCuFunctionNVX_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyCuFunctionNVX_CallInstance, cmock_guts_index); + Mock.vkDestroyCuFunctionNVX_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyCuFunctionNVX_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyCuFunctionNVX_CALL_INSTANCE)); + CMOCK_vkDestroyCuFunctionNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyCuFunctionNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyCuFunctionNVX_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyCuFunctionNVX_CallInstance, cmock_guts_index); + Mock.vkDestroyCuFunctionNVX_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyCuFunctionNVX(cmock_call_instance, device, function, pAllocator); +} + +void vkDestroyCuFunctionNVX_AddCallback(CMOCK_vkDestroyCuFunctionNVX_CALLBACK Callback) +{ + Mock.vkDestroyCuFunctionNVX_IgnoreBool = (char)0; + Mock.vkDestroyCuFunctionNVX_CallbackBool = (char)1; + Mock.vkDestroyCuFunctionNVX_CallbackFunctionPointer = Callback; +} + +void vkDestroyCuFunctionNVX_Stub(CMOCK_vkDestroyCuFunctionNVX_CALLBACK Callback) +{ + Mock.vkDestroyCuFunctionNVX_IgnoreBool = (char)0; + Mock.vkDestroyCuFunctionNVX_CallbackBool = (char)0; + Mock.vkDestroyCuFunctionNVX_CallbackFunctionPointer = Callback; +} + +void vkDestroyCuFunctionNVX_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyCuFunctionNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyCuFunctionNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyCuFunctionNVX_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyCuFunctionNVX_CMockIgnoreArg_function(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyCuFunctionNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyCuFunctionNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyCuFunctionNVX_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_function = 1; +} + +void vkDestroyCuFunctionNVX_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyCuFunctionNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyCuFunctionNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyCuFunctionNVX_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdCuLaunchKernelNVX_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdCuLaunchKernelNVX); + cmock_call_instance = (CMOCK_vkCmdCuLaunchKernelNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdCuLaunchKernelNVX_CallInstance); + Mock.vkCmdCuLaunchKernelNVX_CallInstance = CMock_Guts_MemNext(Mock.vkCmdCuLaunchKernelNVX_CallInstance); + if (Mock.vkCmdCuLaunchKernelNVX_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdCuLaunchKernelNVX_CallbackBool && + Mock.vkCmdCuLaunchKernelNVX_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCuLaunchKernelNVX_CallbackFunctionPointer(commandBuffer, pLaunchInfo, Mock.vkCmdCuLaunchKernelNVX_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdCuLaunchKernelNVX,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pLaunchInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdCuLaunchKernelNVX,CMockString_pLaunchInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pLaunchInfo), (void*)(pLaunchInfo), sizeof(const VkCuLaunchInfoNVX), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdCuLaunchKernelNVX_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCuLaunchKernelNVX_CallbackFunctionPointer(commandBuffer, pLaunchInfo, Mock.vkCmdCuLaunchKernelNVX_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdCuLaunchKernelNVX(CMOCK_vkCmdCuLaunchKernelNVX_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo); +void CMockExpectParameters_vkCmdCuLaunchKernelNVX(CMOCK_vkCmdCuLaunchKernelNVX_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pLaunchInfo = pLaunchInfo; + cmock_call_instance->IgnoreArg_pLaunchInfo = 0; +} + +void vkCmdCuLaunchKernelNVX_CMockIgnore(void) +{ + Mock.vkCmdCuLaunchKernelNVX_IgnoreBool = (char)1; +} + +void vkCmdCuLaunchKernelNVX_CMockStopIgnore(void) +{ + Mock.vkCmdCuLaunchKernelNVX_IgnoreBool = (char)0; +} + +void vkCmdCuLaunchKernelNVX_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCuLaunchKernelNVX_CALL_INSTANCE)); + CMOCK_vkCmdCuLaunchKernelNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCuLaunchKernelNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCuLaunchKernelNVX_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCuLaunchKernelNVX_CallInstance, cmock_guts_index); + Mock.vkCmdCuLaunchKernelNVX_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdCuLaunchKernelNVX_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCuLaunchKernelNVX_CALL_INSTANCE)); + CMOCK_vkCmdCuLaunchKernelNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCuLaunchKernelNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCuLaunchKernelNVX_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCuLaunchKernelNVX_CallInstance, cmock_guts_index); + Mock.vkCmdCuLaunchKernelNVX_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdCuLaunchKernelNVX(cmock_call_instance, commandBuffer, pLaunchInfo); +} + +void vkCmdCuLaunchKernelNVX_AddCallback(CMOCK_vkCmdCuLaunchKernelNVX_CALLBACK Callback) +{ + Mock.vkCmdCuLaunchKernelNVX_IgnoreBool = (char)0; + Mock.vkCmdCuLaunchKernelNVX_CallbackBool = (char)1; + Mock.vkCmdCuLaunchKernelNVX_CallbackFunctionPointer = Callback; +} + +void vkCmdCuLaunchKernelNVX_Stub(CMOCK_vkCmdCuLaunchKernelNVX_CALLBACK Callback) +{ + Mock.vkCmdCuLaunchKernelNVX_IgnoreBool = (char)0; + Mock.vkCmdCuLaunchKernelNVX_CallbackBool = (char)0; + Mock.vkCmdCuLaunchKernelNVX_CallbackFunctionPointer = Callback; +} + +void vkCmdCuLaunchKernelNVX_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCuLaunchKernelNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCuLaunchKernelNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCuLaunchKernelNVX_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdCuLaunchKernelNVX_CMockIgnoreArg_pLaunchInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCuLaunchKernelNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCuLaunchKernelNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCuLaunchKernelNVX_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pLaunchInfo = 1; +} + +uint32_t vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX* pInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetImageViewHandleNVX_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetImageViewHandleNVX); + cmock_call_instance = (CMOCK_vkGetImageViewHandleNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetImageViewHandleNVX_CallInstance); + Mock.vkGetImageViewHandleNVX_CallInstance = CMock_Guts_MemNext(Mock.vkGetImageViewHandleNVX_CallInstance); + if (Mock.vkGetImageViewHandleNVX_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetImageViewHandleNVX_FinalReturn; + Mock.vkGetImageViewHandleNVX_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetImageViewHandleNVX_CallbackBool && + Mock.vkGetImageViewHandleNVX_CallbackFunctionPointer != NULL) + { + uint32_t cmock_cb_ret = Mock.vkGetImageViewHandleNVX_CallbackFunctionPointer(device, pInfo, Mock.vkGetImageViewHandleNVX_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetImageViewHandleNVX,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetImageViewHandleNVX,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkImageViewHandleInfoNVX), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetImageViewHandleNVX_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetImageViewHandleNVX_CallbackFunctionPointer(device, pInfo, Mock.vkGetImageViewHandleNVX_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetImageViewHandleNVX(CMOCK_vkGetImageViewHandleNVX_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkImageViewHandleInfoNVX* pInfo); +void CMockExpectParameters_vkGetImageViewHandleNVX(CMOCK_vkGetImageViewHandleNVX_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkImageViewHandleInfoNVX* pInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; +} + +void vkGetImageViewHandleNVX_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, uint32_t cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageViewHandleNVX_CALL_INSTANCE)); + CMOCK_vkGetImageViewHandleNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageViewHandleNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageViewHandleNVX_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageViewHandleNVX_CallInstance, cmock_guts_index); + Mock.vkGetImageViewHandleNVX_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetImageViewHandleNVX_IgnoreBool = (char)1; +} + +void vkGetImageViewHandleNVX_CMockStopIgnore(void) +{ + if(Mock.vkGetImageViewHandleNVX_IgnoreBool) + Mock.vkGetImageViewHandleNVX_CallInstance = CMock_Guts_MemNext(Mock.vkGetImageViewHandleNVX_CallInstance); + Mock.vkGetImageViewHandleNVX_IgnoreBool = (char)0; +} + +void vkGetImageViewHandleNVX_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, uint32_t cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageViewHandleNVX_CALL_INSTANCE)); + CMOCK_vkGetImageViewHandleNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageViewHandleNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageViewHandleNVX_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageViewHandleNVX_CallInstance, cmock_guts_index); + Mock.vkGetImageViewHandleNVX_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetImageViewHandleNVX_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkImageViewHandleInfoNVX* pInfo, uint32_t cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageViewHandleNVX_CALL_INSTANCE)); + CMOCK_vkGetImageViewHandleNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageViewHandleNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageViewHandleNVX_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageViewHandleNVX_CallInstance, cmock_guts_index); + Mock.vkGetImageViewHandleNVX_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetImageViewHandleNVX(cmock_call_instance, device, pInfo); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void vkGetImageViewHandleNVX_AddCallback(CMOCK_vkGetImageViewHandleNVX_CALLBACK Callback) +{ + Mock.vkGetImageViewHandleNVX_IgnoreBool = (char)0; + Mock.vkGetImageViewHandleNVX_CallbackBool = (char)1; + Mock.vkGetImageViewHandleNVX_CallbackFunctionPointer = Callback; +} + +void vkGetImageViewHandleNVX_Stub(CMOCK_vkGetImageViewHandleNVX_CALLBACK Callback) +{ + Mock.vkGetImageViewHandleNVX_IgnoreBool = (char)0; + Mock.vkGetImageViewHandleNVX_CallbackBool = (char)0; + Mock.vkGetImageViewHandleNVX_CallbackFunctionPointer = Callback; +} + +void vkGetImageViewHandleNVX_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageViewHandleNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageViewHandleNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageViewHandleNVX_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetImageViewHandleNVX_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageViewHandleNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageViewHandleNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageViewHandleNVX_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +VkResult vkGetImageViewAddressNVX(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetImageViewAddressNVX_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetImageViewAddressNVX); + cmock_call_instance = (CMOCK_vkGetImageViewAddressNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetImageViewAddressNVX_CallInstance); + Mock.vkGetImageViewAddressNVX_CallInstance = CMock_Guts_MemNext(Mock.vkGetImageViewAddressNVX_CallInstance); + if (Mock.vkGetImageViewAddressNVX_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetImageViewAddressNVX_FinalReturn; + memcpy((void*)(&Mock.vkGetImageViewAddressNVX_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetImageViewAddressNVX_CallbackBool && + Mock.vkGetImageViewAddressNVX_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetImageViewAddressNVX_CallbackFunctionPointer(device, imageView, pProperties, Mock.vkGetImageViewAddressNVX_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetImageViewAddressNVX,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_imageView) + { + UNITY_SET_DETAILS(CMockString_vkGetImageViewAddressNVX,CMockString_imageView); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_imageView), (void*)(&imageView), sizeof(VkImageView), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetImageViewAddressNVX,CMockString_pProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pProperties), (void*)(pProperties), sizeof(VkImageViewAddressPropertiesNVX), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetImageViewAddressNVX_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetImageViewAddressNVX_CallbackFunctionPointer(device, imageView, pProperties, Mock.vkGetImageViewAddressNVX_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pProperties, (const void*)cmock_call_instance->ReturnThruPtr_pProperties_Val, + cmock_call_instance->ReturnThruPtr_pProperties_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetImageViewAddressNVX(CMOCK_vkGetImageViewAddressNVX_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties); +void CMockExpectParameters_vkGetImageViewAddressNVX(CMOCK_vkGetImageViewAddressNVX_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_imageView), (void*)(&imageView), + sizeof(VkImageView[sizeof(imageView) == sizeof(VkImageView) ? 1 : -1])); /* add VkImageView to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_imageView = 0; + cmock_call_instance->Expected_pProperties = pProperties; + cmock_call_instance->IgnoreArg_pProperties = 0; + cmock_call_instance->ReturnThruPtr_pProperties_Used = 0; +} + +void vkGetImageViewAddressNVX_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageViewAddressNVX_CALL_INSTANCE)); + CMOCK_vkGetImageViewAddressNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageViewAddressNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageViewAddressNVX_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageViewAddressNVX_CallInstance, cmock_guts_index); + Mock.vkGetImageViewAddressNVX_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetImageViewAddressNVX_IgnoreBool = (char)1; +} + +void vkGetImageViewAddressNVX_CMockStopIgnore(void) +{ + if(Mock.vkGetImageViewAddressNVX_IgnoreBool) + Mock.vkGetImageViewAddressNVX_CallInstance = CMock_Guts_MemNext(Mock.vkGetImageViewAddressNVX_CallInstance); + Mock.vkGetImageViewAddressNVX_IgnoreBool = (char)0; +} + +void vkGetImageViewAddressNVX_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageViewAddressNVX_CALL_INSTANCE)); + CMOCK_vkGetImageViewAddressNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageViewAddressNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageViewAddressNVX_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageViewAddressNVX_CallInstance, cmock_guts_index); + Mock.vkGetImageViewAddressNVX_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetImageViewAddressNVX_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageViewAddressNVX_CALL_INSTANCE)); + CMOCK_vkGetImageViewAddressNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageViewAddressNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageViewAddressNVX_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageViewAddressNVX_CallInstance, cmock_guts_index); + Mock.vkGetImageViewAddressNVX_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetImageViewAddressNVX(cmock_call_instance, device, imageView, pProperties); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetImageViewAddressNVX_AddCallback(CMOCK_vkGetImageViewAddressNVX_CALLBACK Callback) +{ + Mock.vkGetImageViewAddressNVX_IgnoreBool = (char)0; + Mock.vkGetImageViewAddressNVX_CallbackBool = (char)1; + Mock.vkGetImageViewAddressNVX_CallbackFunctionPointer = Callback; +} + +void vkGetImageViewAddressNVX_Stub(CMOCK_vkGetImageViewAddressNVX_CALLBACK Callback) +{ + Mock.vkGetImageViewAddressNVX_IgnoreBool = (char)0; + Mock.vkGetImageViewAddressNVX_CallbackBool = (char)0; + Mock.vkGetImageViewAddressNVX_CallbackFunctionPointer = Callback; +} + +void vkGetImageViewAddressNVX_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkImageViewAddressPropertiesNVX const* pProperties, size_t cmock_size) +{ + CMOCK_vkGetImageViewAddressNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageViewAddressNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageViewAddressNVX_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pProperties_Val = pProperties; + cmock_call_instance->ReturnThruPtr_pProperties_Size = cmock_size; +} + +void vkGetImageViewAddressNVX_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageViewAddressNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageViewAddressNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageViewAddressNVX_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetImageViewAddressNVX_CMockIgnoreArg_imageView(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageViewAddressNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageViewAddressNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageViewAddressNVX_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_imageView = 1; +} + +void vkGetImageViewAddressNVX_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageViewAddressNVX_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageViewAddressNVX_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageViewAddressNVX_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pProperties = 1; +} + +void vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDrawIndirectCountAMD_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDrawIndirectCountAMD); + cmock_call_instance = (CMOCK_vkCmdDrawIndirectCountAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDrawIndirectCountAMD_CallInstance); + Mock.vkCmdDrawIndirectCountAMD_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDrawIndirectCountAMD_CallInstance); + if (Mock.vkCmdDrawIndirectCountAMD_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDrawIndirectCountAMD_CallbackBool && + Mock.vkCmdDrawIndirectCountAMD_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawIndirectCountAMD_CallbackFunctionPointer(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, Mock.vkCmdDrawIndirectCountAMD_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirectCountAMD,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_buffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirectCountAMD,CMockString_buffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_offset) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirectCountAMD,CMockString_offset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_countBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirectCountAMD,CMockString_countBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_countBuffer), (void*)(&countBuffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_countBufferOffset) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirectCountAMD,CMockString_countBufferOffset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_countBufferOffset), (void*)(&countBufferOffset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_maxDrawCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirectCountAMD,CMockString_maxDrawCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_maxDrawCount, maxDrawCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_stride) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndirectCountAMD,CMockString_stride); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_stride, stride, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdDrawIndirectCountAMD_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawIndirectCountAMD_CallbackFunctionPointer(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, Mock.vkCmdDrawIndirectCountAMD_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDrawIndirectCountAMD(CMOCK_vkCmdDrawIndirectCountAMD_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +void CMockExpectParameters_vkCmdDrawIndirectCountAMD(CMOCK_vkCmdDrawIndirectCountAMD_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), + sizeof(VkBuffer[sizeof(buffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_buffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), + sizeof(VkDeviceSize[sizeof(offset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_offset = 0; + memcpy((void*)(&cmock_call_instance->Expected_countBuffer), (void*)(&countBuffer), + sizeof(VkBuffer[sizeof(countBuffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_countBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_countBufferOffset), (void*)(&countBufferOffset), + sizeof(VkDeviceSize[sizeof(countBufferOffset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_countBufferOffset = 0; + cmock_call_instance->Expected_maxDrawCount = maxDrawCount; + cmock_call_instance->IgnoreArg_maxDrawCount = 0; + cmock_call_instance->Expected_stride = stride; + cmock_call_instance->IgnoreArg_stride = 0; +} + +void vkCmdDrawIndirectCountAMD_CMockIgnore(void) +{ + Mock.vkCmdDrawIndirectCountAMD_IgnoreBool = (char)1; +} + +void vkCmdDrawIndirectCountAMD_CMockStopIgnore(void) +{ + Mock.vkCmdDrawIndirectCountAMD_IgnoreBool = (char)0; +} + +void vkCmdDrawIndirectCountAMD_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawIndirectCountAMD_CALL_INSTANCE)); + CMOCK_vkCmdDrawIndirectCountAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectCountAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawIndirectCountAMD_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawIndirectCountAMD_CallInstance, cmock_guts_index); + Mock.vkCmdDrawIndirectCountAMD_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDrawIndirectCountAMD_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawIndirectCountAMD_CALL_INSTANCE)); + CMOCK_vkCmdDrawIndirectCountAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectCountAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawIndirectCountAMD_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawIndirectCountAMD_CallInstance, cmock_guts_index); + Mock.vkCmdDrawIndirectCountAMD_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDrawIndirectCountAMD(cmock_call_instance, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); +} + +void vkCmdDrawIndirectCountAMD_AddCallback(CMOCK_vkCmdDrawIndirectCountAMD_CALLBACK Callback) +{ + Mock.vkCmdDrawIndirectCountAMD_IgnoreBool = (char)0; + Mock.vkCmdDrawIndirectCountAMD_CallbackBool = (char)1; + Mock.vkCmdDrawIndirectCountAMD_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawIndirectCountAMD_Stub(CMOCK_vkCmdDrawIndirectCountAMD_CALLBACK Callback) +{ + Mock.vkCmdDrawIndirectCountAMD_IgnoreBool = (char)0; + Mock.vkCmdDrawIndirectCountAMD_CallbackBool = (char)0; + Mock.vkCmdDrawIndirectCountAMD_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawIndirectCountAMD_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirectCountAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectCountAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirectCountAMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDrawIndirectCountAMD_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirectCountAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectCountAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirectCountAMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_buffer = 1; +} + +void vkCmdDrawIndirectCountAMD_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirectCountAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectCountAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirectCountAMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_offset = 1; +} + +void vkCmdDrawIndirectCountAMD_CMockIgnoreArg_countBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirectCountAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectCountAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirectCountAMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_countBuffer = 1; +} + +void vkCmdDrawIndirectCountAMD_CMockIgnoreArg_countBufferOffset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirectCountAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectCountAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirectCountAMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_countBufferOffset = 1; +} + +void vkCmdDrawIndirectCountAMD_CMockIgnoreArg_maxDrawCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirectCountAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectCountAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirectCountAMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_maxDrawCount = 1; +} + +void vkCmdDrawIndirectCountAMD_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndirectCountAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndirectCountAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndirectCountAMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stride = 1; +} + +void vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDrawIndexedIndirectCountAMD); + cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDrawIndexedIndirectCountAMD_CallInstance); + Mock.vkCmdDrawIndexedIndirectCountAMD_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDrawIndexedIndirectCountAMD_CallInstance); + if (Mock.vkCmdDrawIndexedIndirectCountAMD_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDrawIndexedIndirectCountAMD_CallbackBool && + Mock.vkCmdDrawIndexedIndirectCountAMD_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawIndexedIndirectCountAMD_CallbackFunctionPointer(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, Mock.vkCmdDrawIndexedIndirectCountAMD_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexedIndirectCountAMD,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_buffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexedIndirectCountAMD,CMockString_buffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_offset) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexedIndirectCountAMD,CMockString_offset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_countBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexedIndirectCountAMD,CMockString_countBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_countBuffer), (void*)(&countBuffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_countBufferOffset) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexedIndirectCountAMD,CMockString_countBufferOffset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_countBufferOffset), (void*)(&countBufferOffset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_maxDrawCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexedIndirectCountAMD,CMockString_maxDrawCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_maxDrawCount, maxDrawCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_stride) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawIndexedIndirectCountAMD,CMockString_stride); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_stride, stride, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdDrawIndexedIndirectCountAMD_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawIndexedIndirectCountAMD_CallbackFunctionPointer(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, Mock.vkCmdDrawIndexedIndirectCountAMD_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDrawIndexedIndirectCountAMD(CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +void CMockExpectParameters_vkCmdDrawIndexedIndirectCountAMD(CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), + sizeof(VkBuffer[sizeof(buffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_buffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), + sizeof(VkDeviceSize[sizeof(offset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_offset = 0; + memcpy((void*)(&cmock_call_instance->Expected_countBuffer), (void*)(&countBuffer), + sizeof(VkBuffer[sizeof(countBuffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_countBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_countBufferOffset), (void*)(&countBufferOffset), + sizeof(VkDeviceSize[sizeof(countBufferOffset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_countBufferOffset = 0; + cmock_call_instance->Expected_maxDrawCount = maxDrawCount; + cmock_call_instance->IgnoreArg_maxDrawCount = 0; + cmock_call_instance->Expected_stride = stride; + cmock_call_instance->IgnoreArg_stride = 0; +} + +void vkCmdDrawIndexedIndirectCountAMD_CMockIgnore(void) +{ + Mock.vkCmdDrawIndexedIndirectCountAMD_IgnoreBool = (char)1; +} + +void vkCmdDrawIndexedIndirectCountAMD_CMockStopIgnore(void) +{ + Mock.vkCmdDrawIndexedIndirectCountAMD_IgnoreBool = (char)0; +} + +void vkCmdDrawIndexedIndirectCountAMD_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALL_INSTANCE)); + CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawIndexedIndirectCountAMD_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawIndexedIndirectCountAMD_CallInstance, cmock_guts_index); + Mock.vkCmdDrawIndexedIndirectCountAMD_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDrawIndexedIndirectCountAMD_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALL_INSTANCE)); + CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawIndexedIndirectCountAMD_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawIndexedIndirectCountAMD_CallInstance, cmock_guts_index); + Mock.vkCmdDrawIndexedIndirectCountAMD_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDrawIndexedIndirectCountAMD(cmock_call_instance, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); +} + +void vkCmdDrawIndexedIndirectCountAMD_AddCallback(CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALLBACK Callback) +{ + Mock.vkCmdDrawIndexedIndirectCountAMD_IgnoreBool = (char)0; + Mock.vkCmdDrawIndexedIndirectCountAMD_CallbackBool = (char)1; + Mock.vkCmdDrawIndexedIndirectCountAMD_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawIndexedIndirectCountAMD_Stub(CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALLBACK Callback) +{ + Mock.vkCmdDrawIndexedIndirectCountAMD_IgnoreBool = (char)0; + Mock.vkCmdDrawIndexedIndirectCountAMD_CallbackBool = (char)0; + Mock.vkCmdDrawIndexedIndirectCountAMD_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawIndexedIndirectCountAMD_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexedIndirectCountAMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDrawIndexedIndirectCountAMD_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexedIndirectCountAMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_buffer = 1; +} + +void vkCmdDrawIndexedIndirectCountAMD_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexedIndirectCountAMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_offset = 1; +} + +void vkCmdDrawIndexedIndirectCountAMD_CMockIgnoreArg_countBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexedIndirectCountAMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_countBuffer = 1; +} + +void vkCmdDrawIndexedIndirectCountAMD_CMockIgnoreArg_countBufferOffset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexedIndirectCountAMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_countBufferOffset = 1; +} + +void vkCmdDrawIndexedIndirectCountAMD_CMockIgnoreArg_maxDrawCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexedIndirectCountAMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_maxDrawCount = 1; +} + +void vkCmdDrawIndexedIndirectCountAMD_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawIndexedIndirectCountAMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stride = 1; +} + +VkResult vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetShaderInfoAMD); + cmock_call_instance = (CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetShaderInfoAMD_CallInstance); + Mock.vkGetShaderInfoAMD_CallInstance = CMock_Guts_MemNext(Mock.vkGetShaderInfoAMD_CallInstance); + if (Mock.vkGetShaderInfoAMD_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetShaderInfoAMD_FinalReturn; + memcpy((void*)(&Mock.vkGetShaderInfoAMD_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetShaderInfoAMD_CallbackBool && + Mock.vkGetShaderInfoAMD_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetShaderInfoAMD_CallbackFunctionPointer(device, pipeline, shaderStage, infoType, pInfoSize, pInfo, Mock.vkGetShaderInfoAMD_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetShaderInfoAMD,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pipeline) + { + UNITY_SET_DETAILS(CMockString_vkGetShaderInfoAMD,CMockString_pipeline); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_pipeline), (void*)(&pipeline), sizeof(VkPipeline), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_shaderStage) + { + UNITY_SET_DETAILS(CMockString_vkGetShaderInfoAMD,CMockString_shaderStage); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_shaderStage), (void*)(&shaderStage), sizeof(VkShaderStageFlagBits), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_infoType) + { + UNITY_SET_DETAILS(CMockString_vkGetShaderInfoAMD,CMockString_infoType); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_infoType), (void*)(&infoType), sizeof(VkShaderInfoTypeAMD), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfoSize) + { + UNITY_SET_DETAILS(CMockString_vkGetShaderInfoAMD,CMockString_pInfoSize); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfoSize), (void*)(pInfoSize), sizeof(size_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetShaderInfoAMD,CMockString_pInfo); + if (cmock_call_instance->Expected_pInfo == NULL) + { UNITY_TEST_ASSERT_NULL(pInfo, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(cmock_call_instance->Expected_pInfo, pInfo, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkGetShaderInfoAMD_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetShaderInfoAMD_CallbackFunctionPointer(device, pipeline, shaderStage, infoType, pInfoSize, pInfo, Mock.vkGetShaderInfoAMD_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pInfoSize_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pInfoSize, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pInfoSize, (const void*)cmock_call_instance->ReturnThruPtr_pInfoSize_Val, + cmock_call_instance->ReturnThruPtr_pInfoSize_Size); + } + if (cmock_call_instance->ReturnThruPtr_pInfo_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pInfo, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pInfo, (const void*)cmock_call_instance->ReturnThruPtr_pInfo_Val, + cmock_call_instance->ReturnThruPtr_pInfo_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetShaderInfoAMD(CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo); +void CMockExpectParameters_vkGetShaderInfoAMD(CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_pipeline), (void*)(&pipeline), + sizeof(VkPipeline[sizeof(pipeline) == sizeof(VkPipeline) ? 1 : -1])); /* add VkPipeline to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_pipeline = 0; + memcpy((void*)(&cmock_call_instance->Expected_shaderStage), (void*)(&shaderStage), + sizeof(VkShaderStageFlagBits[sizeof(shaderStage) == sizeof(VkShaderStageFlagBits) ? 1 : -1])); /* add VkShaderStageFlagBits to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_shaderStage = 0; + memcpy((void*)(&cmock_call_instance->Expected_infoType), (void*)(&infoType), + sizeof(VkShaderInfoTypeAMD[sizeof(infoType) == sizeof(VkShaderInfoTypeAMD) ? 1 : -1])); /* add VkShaderInfoTypeAMD to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_infoType = 0; + cmock_call_instance->Expected_pInfoSize = pInfoSize; + cmock_call_instance->IgnoreArg_pInfoSize = 0; + cmock_call_instance->ReturnThruPtr_pInfoSize_Used = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; + cmock_call_instance->ReturnThruPtr_pInfo_Used = 0; +} + +void vkGetShaderInfoAMD_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE)); + CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetShaderInfoAMD_CallInstance = CMock_Guts_MemChain(Mock.vkGetShaderInfoAMD_CallInstance, cmock_guts_index); + Mock.vkGetShaderInfoAMD_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetShaderInfoAMD_IgnoreBool = (char)1; +} + +void vkGetShaderInfoAMD_CMockStopIgnore(void) +{ + if(Mock.vkGetShaderInfoAMD_IgnoreBool) + Mock.vkGetShaderInfoAMD_CallInstance = CMock_Guts_MemNext(Mock.vkGetShaderInfoAMD_CallInstance); + Mock.vkGetShaderInfoAMD_IgnoreBool = (char)0; +} + +void vkGetShaderInfoAMD_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE)); + CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetShaderInfoAMD_CallInstance = CMock_Guts_MemChain(Mock.vkGetShaderInfoAMD_CallInstance, cmock_guts_index); + Mock.vkGetShaderInfoAMD_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetShaderInfoAMD_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE)); + CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetShaderInfoAMD_CallInstance = CMock_Guts_MemChain(Mock.vkGetShaderInfoAMD_CallInstance, cmock_guts_index); + Mock.vkGetShaderInfoAMD_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetShaderInfoAMD(cmock_call_instance, device, pipeline, shaderStage, infoType, pInfoSize, pInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetShaderInfoAMD_AddCallback(CMOCK_vkGetShaderInfoAMD_CALLBACK Callback) +{ + Mock.vkGetShaderInfoAMD_IgnoreBool = (char)0; + Mock.vkGetShaderInfoAMD_CallbackBool = (char)1; + Mock.vkGetShaderInfoAMD_CallbackFunctionPointer = Callback; +} + +void vkGetShaderInfoAMD_Stub(CMOCK_vkGetShaderInfoAMD_CALLBACK Callback) +{ + Mock.vkGetShaderInfoAMD_IgnoreBool = (char)0; + Mock.vkGetShaderInfoAMD_CallbackBool = (char)0; + Mock.vkGetShaderInfoAMD_CallbackFunctionPointer = Callback; +} + +void vkGetShaderInfoAMD_CMockReturnMemThruPtr_pInfoSize(UNITY_LINE_TYPE cmock_line, size_t const* pInfoSize, size_t cmock_size) +{ + CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetShaderInfoAMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pInfoSize_Used = 1; + cmock_call_instance->ReturnThruPtr_pInfoSize_Val = pInfoSize; + cmock_call_instance->ReturnThruPtr_pInfoSize_Size = cmock_size; +} + +void vkGetShaderInfoAMD_CMockReturnMemThruPtr_pInfo(UNITY_LINE_TYPE cmock_line, void const* pInfo, size_t cmock_size) +{ + CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetShaderInfoAMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pInfo_Used = 1; + cmock_call_instance->ReturnThruPtr_pInfo_Val = pInfo; + cmock_call_instance->ReturnThruPtr_pInfo_Size = cmock_size; +} + +void vkGetShaderInfoAMD_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetShaderInfoAMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetShaderInfoAMD_CMockIgnoreArg_pipeline(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetShaderInfoAMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pipeline = 1; +} + +void vkGetShaderInfoAMD_CMockIgnoreArg_shaderStage(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetShaderInfoAMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_shaderStage = 1; +} + +void vkGetShaderInfoAMD_CMockIgnoreArg_infoType(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetShaderInfoAMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_infoType = 1; +} + +void vkGetShaderInfoAMD_CMockIgnoreArg_pInfoSize(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetShaderInfoAMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfoSize = 1; +} + +void vkGetShaderInfoAMD_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderInfoAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetShaderInfoAMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceExternalImageFormatPropertiesNV); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallInstance); + Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallInstance); + if (Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_FinalReturn; + memcpy((void*)(&Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallbackBool && + Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallbackFunctionPointer(physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties, Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceExternalImageFormatPropertiesNV,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_format) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceExternalImageFormatPropertiesNV,CMockString_format); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_format), (void*)(&format), sizeof(VkFormat), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_type) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceExternalImageFormatPropertiesNV,CMockString_type); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_type), (void*)(&type), sizeof(VkImageType), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_tiling) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceExternalImageFormatPropertiesNV,CMockString_tiling); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_tiling), (void*)(&tiling), sizeof(VkImageTiling), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_usage) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceExternalImageFormatPropertiesNV,CMockString_usage); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_usage), (void*)(&usage), sizeof(VkImageUsageFlags), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_flags) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceExternalImageFormatPropertiesNV,CMockString_flags); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_flags), (void*)(&flags), sizeof(VkImageCreateFlags), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_externalHandleType) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceExternalImageFormatPropertiesNV,CMockString_externalHandleType); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_externalHandleType), (void*)(&externalHandleType), sizeof(VkExternalMemoryHandleTypeFlagsNV), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pExternalImageFormatProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceExternalImageFormatPropertiesNV,CMockString_pExternalImageFormatProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pExternalImageFormatProperties), (void*)(pExternalImageFormatProperties), sizeof(VkExternalImageFormatPropertiesNV), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallbackFunctionPointer(physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties, Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pExternalImageFormatProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pExternalImageFormatProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pExternalImageFormatProperties, (const void*)cmock_call_instance->ReturnThruPtr_pExternalImageFormatProperties_Val, + cmock_call_instance->ReturnThruPtr_pExternalImageFormatProperties_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); +void CMockExpectParameters_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + memcpy((void*)(&cmock_call_instance->Expected_format), (void*)(&format), + sizeof(VkFormat[sizeof(format) == sizeof(VkFormat) ? 1 : -1])); /* add VkFormat to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_format = 0; + memcpy((void*)(&cmock_call_instance->Expected_type), (void*)(&type), + sizeof(VkImageType[sizeof(type) == sizeof(VkImageType) ? 1 : -1])); /* add VkImageType to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_type = 0; + memcpy((void*)(&cmock_call_instance->Expected_tiling), (void*)(&tiling), + sizeof(VkImageTiling[sizeof(tiling) == sizeof(VkImageTiling) ? 1 : -1])); /* add VkImageTiling to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_tiling = 0; + memcpy((void*)(&cmock_call_instance->Expected_usage), (void*)(&usage), + sizeof(VkImageUsageFlags[sizeof(usage) == sizeof(VkImageUsageFlags) ? 1 : -1])); /* add VkImageUsageFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_usage = 0; + memcpy((void*)(&cmock_call_instance->Expected_flags), (void*)(&flags), + sizeof(VkImageCreateFlags[sizeof(flags) == sizeof(VkImageCreateFlags) ? 1 : -1])); /* add VkImageCreateFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_flags = 0; + memcpy((void*)(&cmock_call_instance->Expected_externalHandleType), (void*)(&externalHandleType), + sizeof(VkExternalMemoryHandleTypeFlagsNV[sizeof(externalHandleType) == sizeof(VkExternalMemoryHandleTypeFlagsNV) ? 1 : -1])); /* add VkExternalMemoryHandleTypeFlagsNV to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_externalHandleType = 0; + cmock_call_instance->Expected_pExternalImageFormatProperties = pExternalImageFormatProperties; + cmock_call_instance->IgnoreArg_pExternalImageFormatProperties = 0; + cmock_call_instance->ReturnThruPtr_pExternalImageFormatProperties_Used = 0; +} + +void vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockStopIgnore(void) +{ + if(Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_IgnoreBool) + Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallInstance); + Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(cmock_call_instance, physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPhysicalDeviceExternalImageFormatPropertiesNV_AddCallback(CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceExternalImageFormatPropertiesNV_Stub(CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockReturnMemThruPtr_pExternalImageFormatProperties(UNITY_LINE_TYPE cmock_line, VkExternalImageFormatPropertiesNV const* pExternalImageFormatProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pExternalImageFormatProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pExternalImageFormatProperties_Val = pExternalImageFormatProperties; + cmock_call_instance->ReturnThruPtr_pExternalImageFormatProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockIgnoreArg_format(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_format = 1; +} + +void vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockIgnoreArg_type(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_type = 1; +} + +void vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockIgnoreArg_tiling(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_tiling = 1; +} + +void vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockIgnoreArg_usage(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_usage = 1; +} + +void vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockIgnoreArg_flags(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_flags = 1; +} + +void vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockIgnoreArg_externalHandleType(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_externalHandleType = 1; +} + +void vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockIgnoreArg_pExternalImageFormatProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pExternalImageFormatProperties = 1; +} + +void vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBeginConditionalRenderingEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBeginConditionalRenderingEXT); + cmock_call_instance = (CMOCK_vkCmdBeginConditionalRenderingEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBeginConditionalRenderingEXT_CallInstance); + Mock.vkCmdBeginConditionalRenderingEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBeginConditionalRenderingEXT_CallInstance); + if (Mock.vkCmdBeginConditionalRenderingEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBeginConditionalRenderingEXT_CallbackBool && + Mock.vkCmdBeginConditionalRenderingEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBeginConditionalRenderingEXT_CallbackFunctionPointer(commandBuffer, pConditionalRenderingBegin, Mock.vkCmdBeginConditionalRenderingEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginConditionalRenderingEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pConditionalRenderingBegin) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginConditionalRenderingEXT,CMockString_pConditionalRenderingBegin); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pConditionalRenderingBegin), (void*)(pConditionalRenderingBegin), sizeof(const VkConditionalRenderingBeginInfoEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdBeginConditionalRenderingEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBeginConditionalRenderingEXT_CallbackFunctionPointer(commandBuffer, pConditionalRenderingBegin, Mock.vkCmdBeginConditionalRenderingEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBeginConditionalRenderingEXT(CMOCK_vkCmdBeginConditionalRenderingEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin); +void CMockExpectParameters_vkCmdBeginConditionalRenderingEXT(CMOCK_vkCmdBeginConditionalRenderingEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pConditionalRenderingBegin = pConditionalRenderingBegin; + cmock_call_instance->IgnoreArg_pConditionalRenderingBegin = 0; +} + +void vkCmdBeginConditionalRenderingEXT_CMockIgnore(void) +{ + Mock.vkCmdBeginConditionalRenderingEXT_IgnoreBool = (char)1; +} + +void vkCmdBeginConditionalRenderingEXT_CMockStopIgnore(void) +{ + Mock.vkCmdBeginConditionalRenderingEXT_IgnoreBool = (char)0; +} + +void vkCmdBeginConditionalRenderingEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBeginConditionalRenderingEXT_CALL_INSTANCE)); + CMOCK_vkCmdBeginConditionalRenderingEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginConditionalRenderingEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBeginConditionalRenderingEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBeginConditionalRenderingEXT_CallInstance, cmock_guts_index); + Mock.vkCmdBeginConditionalRenderingEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBeginConditionalRenderingEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBeginConditionalRenderingEXT_CALL_INSTANCE)); + CMOCK_vkCmdBeginConditionalRenderingEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginConditionalRenderingEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBeginConditionalRenderingEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBeginConditionalRenderingEXT_CallInstance, cmock_guts_index); + Mock.vkCmdBeginConditionalRenderingEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBeginConditionalRenderingEXT(cmock_call_instance, commandBuffer, pConditionalRenderingBegin); +} + +void vkCmdBeginConditionalRenderingEXT_AddCallback(CMOCK_vkCmdBeginConditionalRenderingEXT_CALLBACK Callback) +{ + Mock.vkCmdBeginConditionalRenderingEXT_IgnoreBool = (char)0; + Mock.vkCmdBeginConditionalRenderingEXT_CallbackBool = (char)1; + Mock.vkCmdBeginConditionalRenderingEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdBeginConditionalRenderingEXT_Stub(CMOCK_vkCmdBeginConditionalRenderingEXT_CALLBACK Callback) +{ + Mock.vkCmdBeginConditionalRenderingEXT_IgnoreBool = (char)0; + Mock.vkCmdBeginConditionalRenderingEXT_CallbackBool = (char)0; + Mock.vkCmdBeginConditionalRenderingEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdBeginConditionalRenderingEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginConditionalRenderingEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginConditionalRenderingEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginConditionalRenderingEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBeginConditionalRenderingEXT_CMockIgnoreArg_pConditionalRenderingBegin(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginConditionalRenderingEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginConditionalRenderingEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginConditionalRenderingEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pConditionalRenderingBegin = 1; +} + +void vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdEndConditionalRenderingEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdEndConditionalRenderingEXT); + cmock_call_instance = (CMOCK_vkCmdEndConditionalRenderingEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdEndConditionalRenderingEXT_CallInstance); + Mock.vkCmdEndConditionalRenderingEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdEndConditionalRenderingEXT_CallInstance); + if (Mock.vkCmdEndConditionalRenderingEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdEndConditionalRenderingEXT_CallbackBool && + Mock.vkCmdEndConditionalRenderingEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdEndConditionalRenderingEXT_CallbackFunctionPointer(commandBuffer, Mock.vkCmdEndConditionalRenderingEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdEndConditionalRenderingEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdEndConditionalRenderingEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdEndConditionalRenderingEXT_CallbackFunctionPointer(commandBuffer, Mock.vkCmdEndConditionalRenderingEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdEndConditionalRenderingEXT(CMOCK_vkCmdEndConditionalRenderingEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer); +void CMockExpectParameters_vkCmdEndConditionalRenderingEXT(CMOCK_vkCmdEndConditionalRenderingEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; +} + +void vkCmdEndConditionalRenderingEXT_CMockIgnore(void) +{ + Mock.vkCmdEndConditionalRenderingEXT_IgnoreBool = (char)1; +} + +void vkCmdEndConditionalRenderingEXT_CMockStopIgnore(void) +{ + Mock.vkCmdEndConditionalRenderingEXT_IgnoreBool = (char)0; +} + +void vkCmdEndConditionalRenderingEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdEndConditionalRenderingEXT_CALL_INSTANCE)); + CMOCK_vkCmdEndConditionalRenderingEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndConditionalRenderingEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdEndConditionalRenderingEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdEndConditionalRenderingEXT_CallInstance, cmock_guts_index); + Mock.vkCmdEndConditionalRenderingEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdEndConditionalRenderingEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdEndConditionalRenderingEXT_CALL_INSTANCE)); + CMOCK_vkCmdEndConditionalRenderingEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndConditionalRenderingEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdEndConditionalRenderingEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdEndConditionalRenderingEXT_CallInstance, cmock_guts_index); + Mock.vkCmdEndConditionalRenderingEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdEndConditionalRenderingEXT(cmock_call_instance, commandBuffer); +} + +void vkCmdEndConditionalRenderingEXT_AddCallback(CMOCK_vkCmdEndConditionalRenderingEXT_CALLBACK Callback) +{ + Mock.vkCmdEndConditionalRenderingEXT_IgnoreBool = (char)0; + Mock.vkCmdEndConditionalRenderingEXT_CallbackBool = (char)1; + Mock.vkCmdEndConditionalRenderingEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdEndConditionalRenderingEXT_Stub(CMOCK_vkCmdEndConditionalRenderingEXT_CALLBACK Callback) +{ + Mock.vkCmdEndConditionalRenderingEXT_IgnoreBool = (char)0; + Mock.vkCmdEndConditionalRenderingEXT_CallbackBool = (char)0; + Mock.vkCmdEndConditionalRenderingEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdEndConditionalRenderingEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdEndConditionalRenderingEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndConditionalRenderingEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdEndConditionalRenderingEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetViewportWScalingNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetViewportWScalingNV); + cmock_call_instance = (CMOCK_vkCmdSetViewportWScalingNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetViewportWScalingNV_CallInstance); + Mock.vkCmdSetViewportWScalingNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetViewportWScalingNV_CallInstance); + if (Mock.vkCmdSetViewportWScalingNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetViewportWScalingNV_CallbackBool && + Mock.vkCmdSetViewportWScalingNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetViewportWScalingNV_CallbackFunctionPointer(commandBuffer, firstViewport, viewportCount, pViewportWScalings, Mock.vkCmdSetViewportWScalingNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetViewportWScalingNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstViewport) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetViewportWScalingNV,CMockString_firstViewport); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstViewport, firstViewport, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_viewportCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetViewportWScalingNV,CMockString_viewportCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_viewportCount, viewportCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pViewportWScalings) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetViewportWScalingNV,CMockString_pViewportWScalings); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pViewportWScalings), (void*)(pViewportWScalings), sizeof(const VkViewportWScalingNV), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetViewportWScalingNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetViewportWScalingNV_CallbackFunctionPointer(commandBuffer, firstViewport, viewportCount, pViewportWScalings, Mock.vkCmdSetViewportWScalingNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetViewportWScalingNV(CMOCK_vkCmdSetViewportWScalingNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings); +void CMockExpectParameters_vkCmdSetViewportWScalingNV(CMOCK_vkCmdSetViewportWScalingNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_firstViewport = firstViewport; + cmock_call_instance->IgnoreArg_firstViewport = 0; + cmock_call_instance->Expected_viewportCount = viewportCount; + cmock_call_instance->IgnoreArg_viewportCount = 0; + cmock_call_instance->Expected_pViewportWScalings = pViewportWScalings; + cmock_call_instance->IgnoreArg_pViewportWScalings = 0; +} + +void vkCmdSetViewportWScalingNV_CMockIgnore(void) +{ + Mock.vkCmdSetViewportWScalingNV_IgnoreBool = (char)1; +} + +void vkCmdSetViewportWScalingNV_CMockStopIgnore(void) +{ + Mock.vkCmdSetViewportWScalingNV_IgnoreBool = (char)0; +} + +void vkCmdSetViewportWScalingNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetViewportWScalingNV_CALL_INSTANCE)); + CMOCK_vkCmdSetViewportWScalingNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportWScalingNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetViewportWScalingNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetViewportWScalingNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetViewportWScalingNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetViewportWScalingNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetViewportWScalingNV_CALL_INSTANCE)); + CMOCK_vkCmdSetViewportWScalingNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportWScalingNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetViewportWScalingNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetViewportWScalingNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetViewportWScalingNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetViewportWScalingNV(cmock_call_instance, commandBuffer, firstViewport, viewportCount, pViewportWScalings); +} + +void vkCmdSetViewportWScalingNV_AddCallback(CMOCK_vkCmdSetViewportWScalingNV_CALLBACK Callback) +{ + Mock.vkCmdSetViewportWScalingNV_IgnoreBool = (char)0; + Mock.vkCmdSetViewportWScalingNV_CallbackBool = (char)1; + Mock.vkCmdSetViewportWScalingNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetViewportWScalingNV_Stub(CMOCK_vkCmdSetViewportWScalingNV_CALLBACK Callback) +{ + Mock.vkCmdSetViewportWScalingNV_IgnoreBool = (char)0; + Mock.vkCmdSetViewportWScalingNV_CallbackBool = (char)0; + Mock.vkCmdSetViewportWScalingNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetViewportWScalingNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetViewportWScalingNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportWScalingNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetViewportWScalingNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetViewportWScalingNV_CMockIgnoreArg_firstViewport(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetViewportWScalingNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportWScalingNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetViewportWScalingNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstViewport = 1; +} + +void vkCmdSetViewportWScalingNV_CMockIgnoreArg_viewportCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetViewportWScalingNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportWScalingNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetViewportWScalingNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_viewportCount = 1; +} + +void vkCmdSetViewportWScalingNV_CMockIgnoreArg_pViewportWScalings(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetViewportWScalingNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportWScalingNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetViewportWScalingNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pViewportWScalings = 1; +} + +VkResult vkReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkReleaseDisplayEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkReleaseDisplayEXT); + cmock_call_instance = (CMOCK_vkReleaseDisplayEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkReleaseDisplayEXT_CallInstance); + Mock.vkReleaseDisplayEXT_CallInstance = CMock_Guts_MemNext(Mock.vkReleaseDisplayEXT_CallInstance); + if (Mock.vkReleaseDisplayEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkReleaseDisplayEXT_FinalReturn; + memcpy((void*)(&Mock.vkReleaseDisplayEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkReleaseDisplayEXT_CallbackBool && + Mock.vkReleaseDisplayEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkReleaseDisplayEXT_CallbackFunctionPointer(physicalDevice, display, Mock.vkReleaseDisplayEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkReleaseDisplayEXT,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_display) + { + UNITY_SET_DETAILS(CMockString_vkReleaseDisplayEXT,CMockString_display); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_display), (void*)(&display), sizeof(VkDisplayKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkReleaseDisplayEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkReleaseDisplayEXT_CallbackFunctionPointer(physicalDevice, display, Mock.vkReleaseDisplayEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkReleaseDisplayEXT(CMOCK_vkReleaseDisplayEXT_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkDisplayKHR display); +void CMockExpectParameters_vkReleaseDisplayEXT(CMOCK_vkReleaseDisplayEXT_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkDisplayKHR display) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + memcpy((void*)(&cmock_call_instance->Expected_display), (void*)(&display), + sizeof(VkDisplayKHR[sizeof(display) == sizeof(VkDisplayKHR) ? 1 : -1])); /* add VkDisplayKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_display = 0; +} + +void vkReleaseDisplayEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkReleaseDisplayEXT_CALL_INSTANCE)); + CMOCK_vkReleaseDisplayEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkReleaseDisplayEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkReleaseDisplayEXT_CallInstance = CMock_Guts_MemChain(Mock.vkReleaseDisplayEXT_CallInstance, cmock_guts_index); + Mock.vkReleaseDisplayEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkReleaseDisplayEXT_IgnoreBool = (char)1; +} + +void vkReleaseDisplayEXT_CMockStopIgnore(void) +{ + if(Mock.vkReleaseDisplayEXT_IgnoreBool) + Mock.vkReleaseDisplayEXT_CallInstance = CMock_Guts_MemNext(Mock.vkReleaseDisplayEXT_CallInstance); + Mock.vkReleaseDisplayEXT_IgnoreBool = (char)0; +} + +void vkReleaseDisplayEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkReleaseDisplayEXT_CALL_INSTANCE)); + CMOCK_vkReleaseDisplayEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkReleaseDisplayEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkReleaseDisplayEXT_CallInstance = CMock_Guts_MemChain(Mock.vkReleaseDisplayEXT_CallInstance, cmock_guts_index); + Mock.vkReleaseDisplayEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkReleaseDisplayEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkDisplayKHR display, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkReleaseDisplayEXT_CALL_INSTANCE)); + CMOCK_vkReleaseDisplayEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkReleaseDisplayEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkReleaseDisplayEXT_CallInstance = CMock_Guts_MemChain(Mock.vkReleaseDisplayEXT_CallInstance, cmock_guts_index); + Mock.vkReleaseDisplayEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkReleaseDisplayEXT(cmock_call_instance, physicalDevice, display); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkReleaseDisplayEXT_AddCallback(CMOCK_vkReleaseDisplayEXT_CALLBACK Callback) +{ + Mock.vkReleaseDisplayEXT_IgnoreBool = (char)0; + Mock.vkReleaseDisplayEXT_CallbackBool = (char)1; + Mock.vkReleaseDisplayEXT_CallbackFunctionPointer = Callback; +} + +void vkReleaseDisplayEXT_Stub(CMOCK_vkReleaseDisplayEXT_CALLBACK Callback) +{ + Mock.vkReleaseDisplayEXT_IgnoreBool = (char)0; + Mock.vkReleaseDisplayEXT_CallbackBool = (char)0; + Mock.vkReleaseDisplayEXT_CallbackFunctionPointer = Callback; +} + +void vkReleaseDisplayEXT_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkReleaseDisplayEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkReleaseDisplayEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkReleaseDisplayEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkReleaseDisplayEXT_CMockIgnoreArg_display(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkReleaseDisplayEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkReleaseDisplayEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkReleaseDisplayEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_display = 1; +} + +VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2EXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceSurfaceCapabilities2EXT); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2EXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallInstance); + Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallInstance); + if (Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_FinalReturn; + memcpy((void*)(&Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallbackBool && + Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallbackFunctionPointer(physicalDevice, surface, pSurfaceCapabilities, Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSurfaceCapabilities2EXT,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_surface) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSurfaceCapabilities2EXT,CMockString_surface); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_surface), (void*)(&surface), sizeof(VkSurfaceKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSurfaceCapabilities) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSurfaceCapabilities2EXT,CMockString_pSurfaceCapabilities); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSurfaceCapabilities), (void*)(pSurfaceCapabilities), sizeof(VkSurfaceCapabilities2EXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallbackFunctionPointer(physicalDevice, surface, pSurfaceCapabilities, Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pSurfaceCapabilities_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSurfaceCapabilities, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSurfaceCapabilities, (const void*)cmock_call_instance->ReturnThruPtr_pSurfaceCapabilities_Val, + cmock_call_instance->ReturnThruPtr_pSurfaceCapabilities_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPhysicalDeviceSurfaceCapabilities2EXT(CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2EXT_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities); +void CMockExpectParameters_vkGetPhysicalDeviceSurfaceCapabilities2EXT(CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2EXT_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + memcpy((void*)(&cmock_call_instance->Expected_surface), (void*)(&surface), + sizeof(VkSurfaceKHR[sizeof(surface) == sizeof(VkSurfaceKHR) ? 1 : -1])); /* add VkSurfaceKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_surface = 0; + cmock_call_instance->Expected_pSurfaceCapabilities = pSurfaceCapabilities; + cmock_call_instance->IgnoreArg_pSurfaceCapabilities = 0; + cmock_call_instance->ReturnThruPtr_pSurfaceCapabilities_Used = 0; +} + +void vkGetPhysicalDeviceSurfaceCapabilities2EXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2EXT_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2EXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2EXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceSurfaceCapabilities2EXT_CMockStopIgnore(void) +{ + if(Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_IgnoreBool) + Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallInstance); + Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceSurfaceCapabilities2EXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2EXT_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2EXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2EXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceSurfaceCapabilities2EXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2EXT_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2EXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2EXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceSurfaceCapabilities2EXT(cmock_call_instance, physicalDevice, surface, pSurfaceCapabilities); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPhysicalDeviceSurfaceCapabilities2EXT_AddCallback(CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2EXT_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceSurfaceCapabilities2EXT_Stub(CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2EXT_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceSurfaceCapabilities2EXT_CMockReturnMemThruPtr_pSurfaceCapabilities(UNITY_LINE_TYPE cmock_line, VkSurfaceCapabilities2EXT const* pSurfaceCapabilities, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2EXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2EXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSurfaceCapabilities_Used = 1; + cmock_call_instance->ReturnThruPtr_pSurfaceCapabilities_Val = pSurfaceCapabilities; + cmock_call_instance->ReturnThruPtr_pSurfaceCapabilities_Size = cmock_size; +} + +void vkGetPhysicalDeviceSurfaceCapabilities2EXT_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2EXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2EXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceSurfaceCapabilities2EXT_CMockIgnoreArg_surface(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2EXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2EXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_surface = 1; +} + +void vkGetPhysicalDeviceSurfaceCapabilities2EXT_CMockIgnoreArg_pSurfaceCapabilities(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2EXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2EXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSurfaceCapabilities2EXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSurfaceCapabilities = 1; +} + +VkResult vkDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDisplayPowerControlEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDisplayPowerControlEXT); + cmock_call_instance = (CMOCK_vkDisplayPowerControlEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDisplayPowerControlEXT_CallInstance); + Mock.vkDisplayPowerControlEXT_CallInstance = CMock_Guts_MemNext(Mock.vkDisplayPowerControlEXT_CallInstance); + if (Mock.vkDisplayPowerControlEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkDisplayPowerControlEXT_FinalReturn; + memcpy((void*)(&Mock.vkDisplayPowerControlEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkDisplayPowerControlEXT_CallbackBool && + Mock.vkDisplayPowerControlEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkDisplayPowerControlEXT_CallbackFunctionPointer(device, display, pDisplayPowerInfo, Mock.vkDisplayPowerControlEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDisplayPowerControlEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_display) + { + UNITY_SET_DETAILS(CMockString_vkDisplayPowerControlEXT,CMockString_display); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_display), (void*)(&display), sizeof(VkDisplayKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDisplayPowerInfo) + { + UNITY_SET_DETAILS(CMockString_vkDisplayPowerControlEXT,CMockString_pDisplayPowerInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDisplayPowerInfo), (void*)(pDisplayPowerInfo), sizeof(const VkDisplayPowerInfoEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDisplayPowerControlEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkDisplayPowerControlEXT_CallbackFunctionPointer(device, display, pDisplayPowerInfo, Mock.vkDisplayPowerControlEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkDisplayPowerControlEXT(CMOCK_vkDisplayPowerControlEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo); +void CMockExpectParameters_vkDisplayPowerControlEXT(CMOCK_vkDisplayPowerControlEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_display), (void*)(&display), + sizeof(VkDisplayKHR[sizeof(display) == sizeof(VkDisplayKHR) ? 1 : -1])); /* add VkDisplayKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_display = 0; + cmock_call_instance->Expected_pDisplayPowerInfo = pDisplayPowerInfo; + cmock_call_instance->IgnoreArg_pDisplayPowerInfo = 0; +} + +void vkDisplayPowerControlEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDisplayPowerControlEXT_CALL_INSTANCE)); + CMOCK_vkDisplayPowerControlEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDisplayPowerControlEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDisplayPowerControlEXT_CallInstance = CMock_Guts_MemChain(Mock.vkDisplayPowerControlEXT_CallInstance, cmock_guts_index); + Mock.vkDisplayPowerControlEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkDisplayPowerControlEXT_IgnoreBool = (char)1; +} + +void vkDisplayPowerControlEXT_CMockStopIgnore(void) +{ + if(Mock.vkDisplayPowerControlEXT_IgnoreBool) + Mock.vkDisplayPowerControlEXT_CallInstance = CMock_Guts_MemNext(Mock.vkDisplayPowerControlEXT_CallInstance); + Mock.vkDisplayPowerControlEXT_IgnoreBool = (char)0; +} + +void vkDisplayPowerControlEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDisplayPowerControlEXT_CALL_INSTANCE)); + CMOCK_vkDisplayPowerControlEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDisplayPowerControlEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDisplayPowerControlEXT_CallInstance = CMock_Guts_MemChain(Mock.vkDisplayPowerControlEXT_CallInstance, cmock_guts_index); + Mock.vkDisplayPowerControlEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDisplayPowerControlEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDisplayPowerControlEXT_CALL_INSTANCE)); + CMOCK_vkDisplayPowerControlEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDisplayPowerControlEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDisplayPowerControlEXT_CallInstance = CMock_Guts_MemChain(Mock.vkDisplayPowerControlEXT_CallInstance, cmock_guts_index); + Mock.vkDisplayPowerControlEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDisplayPowerControlEXT(cmock_call_instance, device, display, pDisplayPowerInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkDisplayPowerControlEXT_AddCallback(CMOCK_vkDisplayPowerControlEXT_CALLBACK Callback) +{ + Mock.vkDisplayPowerControlEXT_IgnoreBool = (char)0; + Mock.vkDisplayPowerControlEXT_CallbackBool = (char)1; + Mock.vkDisplayPowerControlEXT_CallbackFunctionPointer = Callback; +} + +void vkDisplayPowerControlEXT_Stub(CMOCK_vkDisplayPowerControlEXT_CALLBACK Callback) +{ + Mock.vkDisplayPowerControlEXT_IgnoreBool = (char)0; + Mock.vkDisplayPowerControlEXT_CallbackBool = (char)0; + Mock.vkDisplayPowerControlEXT_CallbackFunctionPointer = Callback; +} + +void vkDisplayPowerControlEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDisplayPowerControlEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDisplayPowerControlEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDisplayPowerControlEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDisplayPowerControlEXT_CMockIgnoreArg_display(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDisplayPowerControlEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDisplayPowerControlEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDisplayPowerControlEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_display = 1; +} + +void vkDisplayPowerControlEXT_CMockIgnoreArg_pDisplayPowerInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDisplayPowerControlEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDisplayPowerControlEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDisplayPowerControlEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDisplayPowerInfo = 1; +} + +VkResult vkRegisterDeviceEventEXT(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkRegisterDeviceEventEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkRegisterDeviceEventEXT); + cmock_call_instance = (CMOCK_vkRegisterDeviceEventEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkRegisterDeviceEventEXT_CallInstance); + Mock.vkRegisterDeviceEventEXT_CallInstance = CMock_Guts_MemNext(Mock.vkRegisterDeviceEventEXT_CallInstance); + if (Mock.vkRegisterDeviceEventEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkRegisterDeviceEventEXT_FinalReturn; + memcpy((void*)(&Mock.vkRegisterDeviceEventEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkRegisterDeviceEventEXT_CallbackBool && + Mock.vkRegisterDeviceEventEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkRegisterDeviceEventEXT_CallbackFunctionPointer(device, pDeviceEventInfo, pAllocator, pFence, Mock.vkRegisterDeviceEventEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkRegisterDeviceEventEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDeviceEventInfo) + { + UNITY_SET_DETAILS(CMockString_vkRegisterDeviceEventEXT,CMockString_pDeviceEventInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDeviceEventInfo), (void*)(pDeviceEventInfo), sizeof(const VkDeviceEventInfoEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkRegisterDeviceEventEXT,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pFence) + { + UNITY_SET_DETAILS(CMockString_vkRegisterDeviceEventEXT,CMockString_pFence); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pFence), (void*)(pFence), sizeof(VkFence), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkRegisterDeviceEventEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkRegisterDeviceEventEXT_CallbackFunctionPointer(device, pDeviceEventInfo, pAllocator, pFence, Mock.vkRegisterDeviceEventEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pFence_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pFence, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pFence, (const void*)cmock_call_instance->ReturnThruPtr_pFence_Val, + cmock_call_instance->ReturnThruPtr_pFence_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkRegisterDeviceEventEXT(CMOCK_vkRegisterDeviceEventEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); +void CMockExpectParameters_vkRegisterDeviceEventEXT(CMOCK_vkRegisterDeviceEventEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pDeviceEventInfo = pDeviceEventInfo; + cmock_call_instance->IgnoreArg_pDeviceEventInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pFence = pFence; + cmock_call_instance->IgnoreArg_pFence = 0; + cmock_call_instance->ReturnThruPtr_pFence_Used = 0; +} + +void vkRegisterDeviceEventEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkRegisterDeviceEventEXT_CALL_INSTANCE)); + CMOCK_vkRegisterDeviceEventEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkRegisterDeviceEventEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkRegisterDeviceEventEXT_CallInstance = CMock_Guts_MemChain(Mock.vkRegisterDeviceEventEXT_CallInstance, cmock_guts_index); + Mock.vkRegisterDeviceEventEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkRegisterDeviceEventEXT_IgnoreBool = (char)1; +} + +void vkRegisterDeviceEventEXT_CMockStopIgnore(void) +{ + if(Mock.vkRegisterDeviceEventEXT_IgnoreBool) + Mock.vkRegisterDeviceEventEXT_CallInstance = CMock_Guts_MemNext(Mock.vkRegisterDeviceEventEXT_CallInstance); + Mock.vkRegisterDeviceEventEXT_IgnoreBool = (char)0; +} + +void vkRegisterDeviceEventEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkRegisterDeviceEventEXT_CALL_INSTANCE)); + CMOCK_vkRegisterDeviceEventEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkRegisterDeviceEventEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkRegisterDeviceEventEXT_CallInstance = CMock_Guts_MemChain(Mock.vkRegisterDeviceEventEXT_CallInstance, cmock_guts_index); + Mock.vkRegisterDeviceEventEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkRegisterDeviceEventEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkRegisterDeviceEventEXT_CALL_INSTANCE)); + CMOCK_vkRegisterDeviceEventEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkRegisterDeviceEventEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkRegisterDeviceEventEXT_CallInstance = CMock_Guts_MemChain(Mock.vkRegisterDeviceEventEXT_CallInstance, cmock_guts_index); + Mock.vkRegisterDeviceEventEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkRegisterDeviceEventEXT(cmock_call_instance, device, pDeviceEventInfo, pAllocator, pFence); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkRegisterDeviceEventEXT_AddCallback(CMOCK_vkRegisterDeviceEventEXT_CALLBACK Callback) +{ + Mock.vkRegisterDeviceEventEXT_IgnoreBool = (char)0; + Mock.vkRegisterDeviceEventEXT_CallbackBool = (char)1; + Mock.vkRegisterDeviceEventEXT_CallbackFunctionPointer = Callback; +} + +void vkRegisterDeviceEventEXT_Stub(CMOCK_vkRegisterDeviceEventEXT_CALLBACK Callback) +{ + Mock.vkRegisterDeviceEventEXT_IgnoreBool = (char)0; + Mock.vkRegisterDeviceEventEXT_CallbackBool = (char)0; + Mock.vkRegisterDeviceEventEXT_CallbackFunctionPointer = Callback; +} + +void vkRegisterDeviceEventEXT_CMockReturnMemThruPtr_pFence(UNITY_LINE_TYPE cmock_line, VkFence const* pFence, size_t cmock_size) +{ + CMOCK_vkRegisterDeviceEventEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkRegisterDeviceEventEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkRegisterDeviceEventEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pFence_Used = 1; + cmock_call_instance->ReturnThruPtr_pFence_Val = pFence; + cmock_call_instance->ReturnThruPtr_pFence_Size = cmock_size; +} + +void vkRegisterDeviceEventEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkRegisterDeviceEventEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkRegisterDeviceEventEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkRegisterDeviceEventEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkRegisterDeviceEventEXT_CMockIgnoreArg_pDeviceEventInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkRegisterDeviceEventEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkRegisterDeviceEventEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkRegisterDeviceEventEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDeviceEventInfo = 1; +} + +void vkRegisterDeviceEventEXT_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkRegisterDeviceEventEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkRegisterDeviceEventEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkRegisterDeviceEventEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkRegisterDeviceEventEXT_CMockIgnoreArg_pFence(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkRegisterDeviceEventEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkRegisterDeviceEventEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkRegisterDeviceEventEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pFence = 1; +} + +VkResult vkRegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkRegisterDisplayEventEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkRegisterDisplayEventEXT); + cmock_call_instance = (CMOCK_vkRegisterDisplayEventEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkRegisterDisplayEventEXT_CallInstance); + Mock.vkRegisterDisplayEventEXT_CallInstance = CMock_Guts_MemNext(Mock.vkRegisterDisplayEventEXT_CallInstance); + if (Mock.vkRegisterDisplayEventEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkRegisterDisplayEventEXT_FinalReturn; + memcpy((void*)(&Mock.vkRegisterDisplayEventEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkRegisterDisplayEventEXT_CallbackBool && + Mock.vkRegisterDisplayEventEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkRegisterDisplayEventEXT_CallbackFunctionPointer(device, display, pDisplayEventInfo, pAllocator, pFence, Mock.vkRegisterDisplayEventEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkRegisterDisplayEventEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_display) + { + UNITY_SET_DETAILS(CMockString_vkRegisterDisplayEventEXT,CMockString_display); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_display), (void*)(&display), sizeof(VkDisplayKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDisplayEventInfo) + { + UNITY_SET_DETAILS(CMockString_vkRegisterDisplayEventEXT,CMockString_pDisplayEventInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDisplayEventInfo), (void*)(pDisplayEventInfo), sizeof(const VkDisplayEventInfoEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkRegisterDisplayEventEXT,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pFence) + { + UNITY_SET_DETAILS(CMockString_vkRegisterDisplayEventEXT,CMockString_pFence); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pFence), (void*)(pFence), sizeof(VkFence), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkRegisterDisplayEventEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkRegisterDisplayEventEXT_CallbackFunctionPointer(device, display, pDisplayEventInfo, pAllocator, pFence, Mock.vkRegisterDisplayEventEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pFence_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pFence, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pFence, (const void*)cmock_call_instance->ReturnThruPtr_pFence_Val, + cmock_call_instance->ReturnThruPtr_pFence_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkRegisterDisplayEventEXT(CMOCK_vkRegisterDisplayEventEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); +void CMockExpectParameters_vkRegisterDisplayEventEXT(CMOCK_vkRegisterDisplayEventEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_display), (void*)(&display), + sizeof(VkDisplayKHR[sizeof(display) == sizeof(VkDisplayKHR) ? 1 : -1])); /* add VkDisplayKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_display = 0; + cmock_call_instance->Expected_pDisplayEventInfo = pDisplayEventInfo; + cmock_call_instance->IgnoreArg_pDisplayEventInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pFence = pFence; + cmock_call_instance->IgnoreArg_pFence = 0; + cmock_call_instance->ReturnThruPtr_pFence_Used = 0; +} + +void vkRegisterDisplayEventEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkRegisterDisplayEventEXT_CALL_INSTANCE)); + CMOCK_vkRegisterDisplayEventEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkRegisterDisplayEventEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkRegisterDisplayEventEXT_CallInstance = CMock_Guts_MemChain(Mock.vkRegisterDisplayEventEXT_CallInstance, cmock_guts_index); + Mock.vkRegisterDisplayEventEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkRegisterDisplayEventEXT_IgnoreBool = (char)1; +} + +void vkRegisterDisplayEventEXT_CMockStopIgnore(void) +{ + if(Mock.vkRegisterDisplayEventEXT_IgnoreBool) + Mock.vkRegisterDisplayEventEXT_CallInstance = CMock_Guts_MemNext(Mock.vkRegisterDisplayEventEXT_CallInstance); + Mock.vkRegisterDisplayEventEXT_IgnoreBool = (char)0; +} + +void vkRegisterDisplayEventEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkRegisterDisplayEventEXT_CALL_INSTANCE)); + CMOCK_vkRegisterDisplayEventEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkRegisterDisplayEventEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkRegisterDisplayEventEXT_CallInstance = CMock_Guts_MemChain(Mock.vkRegisterDisplayEventEXT_CallInstance, cmock_guts_index); + Mock.vkRegisterDisplayEventEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkRegisterDisplayEventEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkRegisterDisplayEventEXT_CALL_INSTANCE)); + CMOCK_vkRegisterDisplayEventEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkRegisterDisplayEventEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkRegisterDisplayEventEXT_CallInstance = CMock_Guts_MemChain(Mock.vkRegisterDisplayEventEXT_CallInstance, cmock_guts_index); + Mock.vkRegisterDisplayEventEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkRegisterDisplayEventEXT(cmock_call_instance, device, display, pDisplayEventInfo, pAllocator, pFence); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkRegisterDisplayEventEXT_AddCallback(CMOCK_vkRegisterDisplayEventEXT_CALLBACK Callback) +{ + Mock.vkRegisterDisplayEventEXT_IgnoreBool = (char)0; + Mock.vkRegisterDisplayEventEXT_CallbackBool = (char)1; + Mock.vkRegisterDisplayEventEXT_CallbackFunctionPointer = Callback; +} + +void vkRegisterDisplayEventEXT_Stub(CMOCK_vkRegisterDisplayEventEXT_CALLBACK Callback) +{ + Mock.vkRegisterDisplayEventEXT_IgnoreBool = (char)0; + Mock.vkRegisterDisplayEventEXT_CallbackBool = (char)0; + Mock.vkRegisterDisplayEventEXT_CallbackFunctionPointer = Callback; +} + +void vkRegisterDisplayEventEXT_CMockReturnMemThruPtr_pFence(UNITY_LINE_TYPE cmock_line, VkFence const* pFence, size_t cmock_size) +{ + CMOCK_vkRegisterDisplayEventEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkRegisterDisplayEventEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkRegisterDisplayEventEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pFence_Used = 1; + cmock_call_instance->ReturnThruPtr_pFence_Val = pFence; + cmock_call_instance->ReturnThruPtr_pFence_Size = cmock_size; +} + +void vkRegisterDisplayEventEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkRegisterDisplayEventEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkRegisterDisplayEventEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkRegisterDisplayEventEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkRegisterDisplayEventEXT_CMockIgnoreArg_display(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkRegisterDisplayEventEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkRegisterDisplayEventEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkRegisterDisplayEventEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_display = 1; +} + +void vkRegisterDisplayEventEXT_CMockIgnoreArg_pDisplayEventInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkRegisterDisplayEventEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkRegisterDisplayEventEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkRegisterDisplayEventEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDisplayEventInfo = 1; +} + +void vkRegisterDisplayEventEXT_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkRegisterDisplayEventEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkRegisterDisplayEventEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkRegisterDisplayEventEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkRegisterDisplayEventEXT_CMockIgnoreArg_pFence(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkRegisterDisplayEventEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkRegisterDisplayEventEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkRegisterDisplayEventEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pFence = 1; +} + +VkResult vkGetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetSwapchainCounterEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetSwapchainCounterEXT); + cmock_call_instance = (CMOCK_vkGetSwapchainCounterEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetSwapchainCounterEXT_CallInstance); + Mock.vkGetSwapchainCounterEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetSwapchainCounterEXT_CallInstance); + if (Mock.vkGetSwapchainCounterEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetSwapchainCounterEXT_FinalReturn; + memcpy((void*)(&Mock.vkGetSwapchainCounterEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetSwapchainCounterEXT_CallbackBool && + Mock.vkGetSwapchainCounterEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetSwapchainCounterEXT_CallbackFunctionPointer(device, swapchain, counter, pCounterValue, Mock.vkGetSwapchainCounterEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetSwapchainCounterEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_swapchain) + { + UNITY_SET_DETAILS(CMockString_vkGetSwapchainCounterEXT,CMockString_swapchain); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_swapchain), (void*)(&swapchain), sizeof(VkSwapchainKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_counter) + { + UNITY_SET_DETAILS(CMockString_vkGetSwapchainCounterEXT,CMockString_counter); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_counter), (void*)(&counter), sizeof(VkSurfaceCounterFlagBitsEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCounterValue) + { + UNITY_SET_DETAILS(CMockString_vkGetSwapchainCounterEXT,CMockString_pCounterValue); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCounterValue), (void*)(pCounterValue), sizeof(uint64_t), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetSwapchainCounterEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetSwapchainCounterEXT_CallbackFunctionPointer(device, swapchain, counter, pCounterValue, Mock.vkGetSwapchainCounterEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pCounterValue_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pCounterValue, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pCounterValue, (const void*)cmock_call_instance->ReturnThruPtr_pCounterValue_Val, + cmock_call_instance->ReturnThruPtr_pCounterValue_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetSwapchainCounterEXT(CMOCK_vkGetSwapchainCounterEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue); +void CMockExpectParameters_vkGetSwapchainCounterEXT(CMOCK_vkGetSwapchainCounterEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_swapchain), (void*)(&swapchain), + sizeof(VkSwapchainKHR[sizeof(swapchain) == sizeof(VkSwapchainKHR) ? 1 : -1])); /* add VkSwapchainKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_swapchain = 0; + memcpy((void*)(&cmock_call_instance->Expected_counter), (void*)(&counter), + sizeof(VkSurfaceCounterFlagBitsEXT[sizeof(counter) == sizeof(VkSurfaceCounterFlagBitsEXT) ? 1 : -1])); /* add VkSurfaceCounterFlagBitsEXT to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_counter = 0; + cmock_call_instance->Expected_pCounterValue = pCounterValue; + cmock_call_instance->IgnoreArg_pCounterValue = 0; + cmock_call_instance->ReturnThruPtr_pCounterValue_Used = 0; +} + +void vkGetSwapchainCounterEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetSwapchainCounterEXT_CALL_INSTANCE)); + CMOCK_vkGetSwapchainCounterEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSwapchainCounterEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetSwapchainCounterEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetSwapchainCounterEXT_CallInstance, cmock_guts_index); + Mock.vkGetSwapchainCounterEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetSwapchainCounterEXT_IgnoreBool = (char)1; +} + +void vkGetSwapchainCounterEXT_CMockStopIgnore(void) +{ + if(Mock.vkGetSwapchainCounterEXT_IgnoreBool) + Mock.vkGetSwapchainCounterEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetSwapchainCounterEXT_CallInstance); + Mock.vkGetSwapchainCounterEXT_IgnoreBool = (char)0; +} + +void vkGetSwapchainCounterEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetSwapchainCounterEXT_CALL_INSTANCE)); + CMOCK_vkGetSwapchainCounterEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSwapchainCounterEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetSwapchainCounterEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetSwapchainCounterEXT_CallInstance, cmock_guts_index); + Mock.vkGetSwapchainCounterEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetSwapchainCounterEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetSwapchainCounterEXT_CALL_INSTANCE)); + CMOCK_vkGetSwapchainCounterEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSwapchainCounterEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetSwapchainCounterEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetSwapchainCounterEXT_CallInstance, cmock_guts_index); + Mock.vkGetSwapchainCounterEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetSwapchainCounterEXT(cmock_call_instance, device, swapchain, counter, pCounterValue); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetSwapchainCounterEXT_AddCallback(CMOCK_vkGetSwapchainCounterEXT_CALLBACK Callback) +{ + Mock.vkGetSwapchainCounterEXT_IgnoreBool = (char)0; + Mock.vkGetSwapchainCounterEXT_CallbackBool = (char)1; + Mock.vkGetSwapchainCounterEXT_CallbackFunctionPointer = Callback; +} + +void vkGetSwapchainCounterEXT_Stub(CMOCK_vkGetSwapchainCounterEXT_CALLBACK Callback) +{ + Mock.vkGetSwapchainCounterEXT_IgnoreBool = (char)0; + Mock.vkGetSwapchainCounterEXT_CallbackBool = (char)0; + Mock.vkGetSwapchainCounterEXT_CallbackFunctionPointer = Callback; +} + +void vkGetSwapchainCounterEXT_CMockReturnMemThruPtr_pCounterValue(UNITY_LINE_TYPE cmock_line, uint64_t const* pCounterValue, size_t cmock_size) +{ + CMOCK_vkGetSwapchainCounterEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSwapchainCounterEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetSwapchainCounterEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pCounterValue_Used = 1; + cmock_call_instance->ReturnThruPtr_pCounterValue_Val = pCounterValue; + cmock_call_instance->ReturnThruPtr_pCounterValue_Size = cmock_size; +} + +void vkGetSwapchainCounterEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetSwapchainCounterEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSwapchainCounterEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetSwapchainCounterEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetSwapchainCounterEXT_CMockIgnoreArg_swapchain(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetSwapchainCounterEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSwapchainCounterEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetSwapchainCounterEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_swapchain = 1; +} + +void vkGetSwapchainCounterEXT_CMockIgnoreArg_counter(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetSwapchainCounterEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSwapchainCounterEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetSwapchainCounterEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_counter = 1; +} + +void vkGetSwapchainCounterEXT_CMockIgnoreArg_pCounterValue(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetSwapchainCounterEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSwapchainCounterEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetSwapchainCounterEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCounterValue = 1; +} + +VkResult vkGetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetRefreshCycleDurationGOOGLE_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetRefreshCycleDurationGOOGLE); + cmock_call_instance = (CMOCK_vkGetRefreshCycleDurationGOOGLE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetRefreshCycleDurationGOOGLE_CallInstance); + Mock.vkGetRefreshCycleDurationGOOGLE_CallInstance = CMock_Guts_MemNext(Mock.vkGetRefreshCycleDurationGOOGLE_CallInstance); + if (Mock.vkGetRefreshCycleDurationGOOGLE_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetRefreshCycleDurationGOOGLE_FinalReturn; + memcpy((void*)(&Mock.vkGetRefreshCycleDurationGOOGLE_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetRefreshCycleDurationGOOGLE_CallbackBool && + Mock.vkGetRefreshCycleDurationGOOGLE_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetRefreshCycleDurationGOOGLE_CallbackFunctionPointer(device, swapchain, pDisplayTimingProperties, Mock.vkGetRefreshCycleDurationGOOGLE_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetRefreshCycleDurationGOOGLE,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_swapchain) + { + UNITY_SET_DETAILS(CMockString_vkGetRefreshCycleDurationGOOGLE,CMockString_swapchain); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_swapchain), (void*)(&swapchain), sizeof(VkSwapchainKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDisplayTimingProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetRefreshCycleDurationGOOGLE,CMockString_pDisplayTimingProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDisplayTimingProperties), (void*)(pDisplayTimingProperties), sizeof(VkRefreshCycleDurationGOOGLE), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetRefreshCycleDurationGOOGLE_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetRefreshCycleDurationGOOGLE_CallbackFunctionPointer(device, swapchain, pDisplayTimingProperties, Mock.vkGetRefreshCycleDurationGOOGLE_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pDisplayTimingProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pDisplayTimingProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pDisplayTimingProperties, (const void*)cmock_call_instance->ReturnThruPtr_pDisplayTimingProperties_Val, + cmock_call_instance->ReturnThruPtr_pDisplayTimingProperties_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetRefreshCycleDurationGOOGLE(CMOCK_vkGetRefreshCycleDurationGOOGLE_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); +void CMockExpectParameters_vkGetRefreshCycleDurationGOOGLE(CMOCK_vkGetRefreshCycleDurationGOOGLE_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_swapchain), (void*)(&swapchain), + sizeof(VkSwapchainKHR[sizeof(swapchain) == sizeof(VkSwapchainKHR) ? 1 : -1])); /* add VkSwapchainKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_swapchain = 0; + cmock_call_instance->Expected_pDisplayTimingProperties = pDisplayTimingProperties; + cmock_call_instance->IgnoreArg_pDisplayTimingProperties = 0; + cmock_call_instance->ReturnThruPtr_pDisplayTimingProperties_Used = 0; +} + +void vkGetRefreshCycleDurationGOOGLE_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetRefreshCycleDurationGOOGLE_CALL_INSTANCE)); + CMOCK_vkGetRefreshCycleDurationGOOGLE_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRefreshCycleDurationGOOGLE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetRefreshCycleDurationGOOGLE_CallInstance = CMock_Guts_MemChain(Mock.vkGetRefreshCycleDurationGOOGLE_CallInstance, cmock_guts_index); + Mock.vkGetRefreshCycleDurationGOOGLE_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetRefreshCycleDurationGOOGLE_IgnoreBool = (char)1; +} + +void vkGetRefreshCycleDurationGOOGLE_CMockStopIgnore(void) +{ + if(Mock.vkGetRefreshCycleDurationGOOGLE_IgnoreBool) + Mock.vkGetRefreshCycleDurationGOOGLE_CallInstance = CMock_Guts_MemNext(Mock.vkGetRefreshCycleDurationGOOGLE_CallInstance); + Mock.vkGetRefreshCycleDurationGOOGLE_IgnoreBool = (char)0; +} + +void vkGetRefreshCycleDurationGOOGLE_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetRefreshCycleDurationGOOGLE_CALL_INSTANCE)); + CMOCK_vkGetRefreshCycleDurationGOOGLE_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRefreshCycleDurationGOOGLE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetRefreshCycleDurationGOOGLE_CallInstance = CMock_Guts_MemChain(Mock.vkGetRefreshCycleDurationGOOGLE_CallInstance, cmock_guts_index); + Mock.vkGetRefreshCycleDurationGOOGLE_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetRefreshCycleDurationGOOGLE_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetRefreshCycleDurationGOOGLE_CALL_INSTANCE)); + CMOCK_vkGetRefreshCycleDurationGOOGLE_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRefreshCycleDurationGOOGLE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetRefreshCycleDurationGOOGLE_CallInstance = CMock_Guts_MemChain(Mock.vkGetRefreshCycleDurationGOOGLE_CallInstance, cmock_guts_index); + Mock.vkGetRefreshCycleDurationGOOGLE_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetRefreshCycleDurationGOOGLE(cmock_call_instance, device, swapchain, pDisplayTimingProperties); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetRefreshCycleDurationGOOGLE_AddCallback(CMOCK_vkGetRefreshCycleDurationGOOGLE_CALLBACK Callback) +{ + Mock.vkGetRefreshCycleDurationGOOGLE_IgnoreBool = (char)0; + Mock.vkGetRefreshCycleDurationGOOGLE_CallbackBool = (char)1; + Mock.vkGetRefreshCycleDurationGOOGLE_CallbackFunctionPointer = Callback; +} + +void vkGetRefreshCycleDurationGOOGLE_Stub(CMOCK_vkGetRefreshCycleDurationGOOGLE_CALLBACK Callback) +{ + Mock.vkGetRefreshCycleDurationGOOGLE_IgnoreBool = (char)0; + Mock.vkGetRefreshCycleDurationGOOGLE_CallbackBool = (char)0; + Mock.vkGetRefreshCycleDurationGOOGLE_CallbackFunctionPointer = Callback; +} + +void vkGetRefreshCycleDurationGOOGLE_CMockReturnMemThruPtr_pDisplayTimingProperties(UNITY_LINE_TYPE cmock_line, VkRefreshCycleDurationGOOGLE const* pDisplayTimingProperties, size_t cmock_size) +{ + CMOCK_vkGetRefreshCycleDurationGOOGLE_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRefreshCycleDurationGOOGLE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRefreshCycleDurationGOOGLE_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pDisplayTimingProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pDisplayTimingProperties_Val = pDisplayTimingProperties; + cmock_call_instance->ReturnThruPtr_pDisplayTimingProperties_Size = cmock_size; +} + +void vkGetRefreshCycleDurationGOOGLE_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetRefreshCycleDurationGOOGLE_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRefreshCycleDurationGOOGLE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRefreshCycleDurationGOOGLE_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetRefreshCycleDurationGOOGLE_CMockIgnoreArg_swapchain(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetRefreshCycleDurationGOOGLE_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRefreshCycleDurationGOOGLE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRefreshCycleDurationGOOGLE_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_swapchain = 1; +} + +void vkGetRefreshCycleDurationGOOGLE_CMockIgnoreArg_pDisplayTimingProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetRefreshCycleDurationGOOGLE_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRefreshCycleDurationGOOGLE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRefreshCycleDurationGOOGLE_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDisplayTimingProperties = 1; +} + +VkResult vkGetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPastPresentationTimingGOOGLE_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPastPresentationTimingGOOGLE); + cmock_call_instance = (CMOCK_vkGetPastPresentationTimingGOOGLE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPastPresentationTimingGOOGLE_CallInstance); + Mock.vkGetPastPresentationTimingGOOGLE_CallInstance = CMock_Guts_MemNext(Mock.vkGetPastPresentationTimingGOOGLE_CallInstance); + if (Mock.vkGetPastPresentationTimingGOOGLE_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPastPresentationTimingGOOGLE_FinalReturn; + memcpy((void*)(&Mock.vkGetPastPresentationTimingGOOGLE_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPastPresentationTimingGOOGLE_CallbackBool && + Mock.vkGetPastPresentationTimingGOOGLE_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPastPresentationTimingGOOGLE_CallbackFunctionPointer(device, swapchain, pPresentationTimingCount, pPresentationTimings, Mock.vkGetPastPresentationTimingGOOGLE_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetPastPresentationTimingGOOGLE,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_swapchain) + { + UNITY_SET_DETAILS(CMockString_vkGetPastPresentationTimingGOOGLE,CMockString_swapchain); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_swapchain), (void*)(&swapchain), sizeof(VkSwapchainKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPresentationTimingCount) + { + UNITY_SET_DETAILS(CMockString_vkGetPastPresentationTimingGOOGLE,CMockString_pPresentationTimingCount); + if (cmock_call_instance->Expected_pPresentationTimingCount == NULL) + { UNITY_TEST_ASSERT_NULL(pPresentationTimingCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pPresentationTimingCount, pPresentationTimingCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pPresentationTimings) + { + UNITY_SET_DETAILS(CMockString_vkGetPastPresentationTimingGOOGLE,CMockString_pPresentationTimings); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pPresentationTimings), (void*)(pPresentationTimings), sizeof(VkPastPresentationTimingGOOGLE), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPastPresentationTimingGOOGLE_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPastPresentationTimingGOOGLE_CallbackFunctionPointer(device, swapchain, pPresentationTimingCount, pPresentationTimings, Mock.vkGetPastPresentationTimingGOOGLE_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPresentationTimingCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPresentationTimingCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPresentationTimingCount, (const void*)cmock_call_instance->ReturnThruPtr_pPresentationTimingCount_Val, + cmock_call_instance->ReturnThruPtr_pPresentationTimingCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pPresentationTimings_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPresentationTimings, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPresentationTimings, (const void*)cmock_call_instance->ReturnThruPtr_pPresentationTimings_Val, + cmock_call_instance->ReturnThruPtr_pPresentationTimings_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPastPresentationTimingGOOGLE(CMOCK_vkGetPastPresentationTimingGOOGLE_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings); +void CMockExpectParameters_vkGetPastPresentationTimingGOOGLE(CMOCK_vkGetPastPresentationTimingGOOGLE_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_swapchain), (void*)(&swapchain), + sizeof(VkSwapchainKHR[sizeof(swapchain) == sizeof(VkSwapchainKHR) ? 1 : -1])); /* add VkSwapchainKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_swapchain = 0; + cmock_call_instance->Expected_pPresentationTimingCount = pPresentationTimingCount; + cmock_call_instance->IgnoreArg_pPresentationTimingCount = 0; + cmock_call_instance->ReturnThruPtr_pPresentationTimingCount_Used = 0; + cmock_call_instance->Expected_pPresentationTimings = pPresentationTimings; + cmock_call_instance->IgnoreArg_pPresentationTimings = 0; + cmock_call_instance->ReturnThruPtr_pPresentationTimings_Used = 0; +} + +void vkGetPastPresentationTimingGOOGLE_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPastPresentationTimingGOOGLE_CALL_INSTANCE)); + CMOCK_vkGetPastPresentationTimingGOOGLE_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPastPresentationTimingGOOGLE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPastPresentationTimingGOOGLE_CallInstance = CMock_Guts_MemChain(Mock.vkGetPastPresentationTimingGOOGLE_CallInstance, cmock_guts_index); + Mock.vkGetPastPresentationTimingGOOGLE_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPastPresentationTimingGOOGLE_IgnoreBool = (char)1; +} + +void vkGetPastPresentationTimingGOOGLE_CMockStopIgnore(void) +{ + if(Mock.vkGetPastPresentationTimingGOOGLE_IgnoreBool) + Mock.vkGetPastPresentationTimingGOOGLE_CallInstance = CMock_Guts_MemNext(Mock.vkGetPastPresentationTimingGOOGLE_CallInstance); + Mock.vkGetPastPresentationTimingGOOGLE_IgnoreBool = (char)0; +} + +void vkGetPastPresentationTimingGOOGLE_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPastPresentationTimingGOOGLE_CALL_INSTANCE)); + CMOCK_vkGetPastPresentationTimingGOOGLE_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPastPresentationTimingGOOGLE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPastPresentationTimingGOOGLE_CallInstance = CMock_Guts_MemChain(Mock.vkGetPastPresentationTimingGOOGLE_CallInstance, cmock_guts_index); + Mock.vkGetPastPresentationTimingGOOGLE_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPastPresentationTimingGOOGLE_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPastPresentationTimingGOOGLE_CALL_INSTANCE)); + CMOCK_vkGetPastPresentationTimingGOOGLE_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPastPresentationTimingGOOGLE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPastPresentationTimingGOOGLE_CallInstance = CMock_Guts_MemChain(Mock.vkGetPastPresentationTimingGOOGLE_CallInstance, cmock_guts_index); + Mock.vkGetPastPresentationTimingGOOGLE_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPastPresentationTimingGOOGLE(cmock_call_instance, device, swapchain, pPresentationTimingCount, pPresentationTimings); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPastPresentationTimingGOOGLE_AddCallback(CMOCK_vkGetPastPresentationTimingGOOGLE_CALLBACK Callback) +{ + Mock.vkGetPastPresentationTimingGOOGLE_IgnoreBool = (char)0; + Mock.vkGetPastPresentationTimingGOOGLE_CallbackBool = (char)1; + Mock.vkGetPastPresentationTimingGOOGLE_CallbackFunctionPointer = Callback; +} + +void vkGetPastPresentationTimingGOOGLE_Stub(CMOCK_vkGetPastPresentationTimingGOOGLE_CALLBACK Callback) +{ + Mock.vkGetPastPresentationTimingGOOGLE_IgnoreBool = (char)0; + Mock.vkGetPastPresentationTimingGOOGLE_CallbackBool = (char)0; + Mock.vkGetPastPresentationTimingGOOGLE_CallbackFunctionPointer = Callback; +} + +void vkGetPastPresentationTimingGOOGLE_CMockReturnMemThruPtr_pPresentationTimingCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPresentationTimingCount, size_t cmock_size) +{ + CMOCK_vkGetPastPresentationTimingGOOGLE_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPastPresentationTimingGOOGLE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPastPresentationTimingGOOGLE_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPresentationTimingCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pPresentationTimingCount_Val = pPresentationTimingCount; + cmock_call_instance->ReturnThruPtr_pPresentationTimingCount_Size = cmock_size; +} + +void vkGetPastPresentationTimingGOOGLE_CMockReturnMemThruPtr_pPresentationTimings(UNITY_LINE_TYPE cmock_line, VkPastPresentationTimingGOOGLE const* pPresentationTimings, size_t cmock_size) +{ + CMOCK_vkGetPastPresentationTimingGOOGLE_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPastPresentationTimingGOOGLE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPastPresentationTimingGOOGLE_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPresentationTimings_Used = 1; + cmock_call_instance->ReturnThruPtr_pPresentationTimings_Val = pPresentationTimings; + cmock_call_instance->ReturnThruPtr_pPresentationTimings_Size = cmock_size; +} + +void vkGetPastPresentationTimingGOOGLE_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPastPresentationTimingGOOGLE_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPastPresentationTimingGOOGLE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPastPresentationTimingGOOGLE_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetPastPresentationTimingGOOGLE_CMockIgnoreArg_swapchain(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPastPresentationTimingGOOGLE_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPastPresentationTimingGOOGLE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPastPresentationTimingGOOGLE_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_swapchain = 1; +} + +void vkGetPastPresentationTimingGOOGLE_CMockIgnoreArg_pPresentationTimingCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPastPresentationTimingGOOGLE_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPastPresentationTimingGOOGLE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPastPresentationTimingGOOGLE_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPresentationTimingCount = 1; +} + +void vkGetPastPresentationTimingGOOGLE_CMockIgnoreArg_pPresentationTimings(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPastPresentationTimingGOOGLE_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPastPresentationTimingGOOGLE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPastPresentationTimingGOOGLE_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPresentationTimings = 1; +} + +void vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetDiscardRectangleEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetDiscardRectangleEXT); + cmock_call_instance = (CMOCK_vkCmdSetDiscardRectangleEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetDiscardRectangleEXT_CallInstance); + Mock.vkCmdSetDiscardRectangleEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetDiscardRectangleEXT_CallInstance); + if (Mock.vkCmdSetDiscardRectangleEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetDiscardRectangleEXT_CallbackBool && + Mock.vkCmdSetDiscardRectangleEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDiscardRectangleEXT_CallbackFunctionPointer(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles, Mock.vkCmdSetDiscardRectangleEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDiscardRectangleEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstDiscardRectangle) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDiscardRectangleEXT,CMockString_firstDiscardRectangle); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstDiscardRectangle, firstDiscardRectangle, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_discardRectangleCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDiscardRectangleEXT,CMockString_discardRectangleCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_discardRectangleCount, discardRectangleCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDiscardRectangles) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDiscardRectangleEXT,CMockString_pDiscardRectangles); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDiscardRectangles), (void*)(pDiscardRectangles), sizeof(const VkRect2D), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetDiscardRectangleEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDiscardRectangleEXT_CallbackFunctionPointer(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles, Mock.vkCmdSetDiscardRectangleEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetDiscardRectangleEXT(CMOCK_vkCmdSetDiscardRectangleEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles); +void CMockExpectParameters_vkCmdSetDiscardRectangleEXT(CMOCK_vkCmdSetDiscardRectangleEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_firstDiscardRectangle = firstDiscardRectangle; + cmock_call_instance->IgnoreArg_firstDiscardRectangle = 0; + cmock_call_instance->Expected_discardRectangleCount = discardRectangleCount; + cmock_call_instance->IgnoreArg_discardRectangleCount = 0; + cmock_call_instance->Expected_pDiscardRectangles = pDiscardRectangles; + cmock_call_instance->IgnoreArg_pDiscardRectangles = 0; +} + +void vkCmdSetDiscardRectangleEXT_CMockIgnore(void) +{ + Mock.vkCmdSetDiscardRectangleEXT_IgnoreBool = (char)1; +} + +void vkCmdSetDiscardRectangleEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetDiscardRectangleEXT_IgnoreBool = (char)0; +} + +void vkCmdSetDiscardRectangleEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDiscardRectangleEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetDiscardRectangleEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDiscardRectangleEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDiscardRectangleEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDiscardRectangleEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetDiscardRectangleEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetDiscardRectangleEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDiscardRectangleEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetDiscardRectangleEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDiscardRectangleEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDiscardRectangleEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDiscardRectangleEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetDiscardRectangleEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetDiscardRectangleEXT(cmock_call_instance, commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles); +} + +void vkCmdSetDiscardRectangleEXT_AddCallback(CMOCK_vkCmdSetDiscardRectangleEXT_CALLBACK Callback) +{ + Mock.vkCmdSetDiscardRectangleEXT_IgnoreBool = (char)0; + Mock.vkCmdSetDiscardRectangleEXT_CallbackBool = (char)1; + Mock.vkCmdSetDiscardRectangleEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDiscardRectangleEXT_Stub(CMOCK_vkCmdSetDiscardRectangleEXT_CALLBACK Callback) +{ + Mock.vkCmdSetDiscardRectangleEXT_IgnoreBool = (char)0; + Mock.vkCmdSetDiscardRectangleEXT_CallbackBool = (char)0; + Mock.vkCmdSetDiscardRectangleEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDiscardRectangleEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDiscardRectangleEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDiscardRectangleEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDiscardRectangleEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetDiscardRectangleEXT_CMockIgnoreArg_firstDiscardRectangle(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDiscardRectangleEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDiscardRectangleEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDiscardRectangleEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstDiscardRectangle = 1; +} + +void vkCmdSetDiscardRectangleEXT_CMockIgnoreArg_discardRectangleCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDiscardRectangleEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDiscardRectangleEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDiscardRectangleEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_discardRectangleCount = 1; +} + +void vkCmdSetDiscardRectangleEXT_CMockIgnoreArg_pDiscardRectangles(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDiscardRectangleEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDiscardRectangleEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDiscardRectangleEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDiscardRectangles = 1; +} + +void vkCmdSetDiscardRectangleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetDiscardRectangleEnableEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetDiscardRectangleEnableEXT); + cmock_call_instance = (CMOCK_vkCmdSetDiscardRectangleEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetDiscardRectangleEnableEXT_CallInstance); + Mock.vkCmdSetDiscardRectangleEnableEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetDiscardRectangleEnableEXT_CallInstance); + if (Mock.vkCmdSetDiscardRectangleEnableEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetDiscardRectangleEnableEXT_CallbackBool && + Mock.vkCmdSetDiscardRectangleEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDiscardRectangleEnableEXT_CallbackFunctionPointer(commandBuffer, discardRectangleEnable, Mock.vkCmdSetDiscardRectangleEnableEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDiscardRectangleEnableEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_discardRectangleEnable) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDiscardRectangleEnableEXT,CMockString_discardRectangleEnable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_discardRectangleEnable), (void*)(&discardRectangleEnable), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetDiscardRectangleEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDiscardRectangleEnableEXT_CallbackFunctionPointer(commandBuffer, discardRectangleEnable, Mock.vkCmdSetDiscardRectangleEnableEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetDiscardRectangleEnableEXT(CMOCK_vkCmdSetDiscardRectangleEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable); +void CMockExpectParameters_vkCmdSetDiscardRectangleEnableEXT(CMOCK_vkCmdSetDiscardRectangleEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_discardRectangleEnable), (void*)(&discardRectangleEnable), + sizeof(VkBool32[sizeof(discardRectangleEnable) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_discardRectangleEnable = 0; +} + +void vkCmdSetDiscardRectangleEnableEXT_CMockIgnore(void) +{ + Mock.vkCmdSetDiscardRectangleEnableEXT_IgnoreBool = (char)1; +} + +void vkCmdSetDiscardRectangleEnableEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetDiscardRectangleEnableEXT_IgnoreBool = (char)0; +} + +void vkCmdSetDiscardRectangleEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDiscardRectangleEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetDiscardRectangleEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDiscardRectangleEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDiscardRectangleEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDiscardRectangleEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetDiscardRectangleEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetDiscardRectangleEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDiscardRectangleEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetDiscardRectangleEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDiscardRectangleEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDiscardRectangleEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDiscardRectangleEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetDiscardRectangleEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetDiscardRectangleEnableEXT(cmock_call_instance, commandBuffer, discardRectangleEnable); +} + +void vkCmdSetDiscardRectangleEnableEXT_AddCallback(CMOCK_vkCmdSetDiscardRectangleEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetDiscardRectangleEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetDiscardRectangleEnableEXT_CallbackBool = (char)1; + Mock.vkCmdSetDiscardRectangleEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDiscardRectangleEnableEXT_Stub(CMOCK_vkCmdSetDiscardRectangleEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetDiscardRectangleEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetDiscardRectangleEnableEXT_CallbackBool = (char)0; + Mock.vkCmdSetDiscardRectangleEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDiscardRectangleEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDiscardRectangleEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDiscardRectangleEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDiscardRectangleEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetDiscardRectangleEnableEXT_CMockIgnoreArg_discardRectangleEnable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDiscardRectangleEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDiscardRectangleEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDiscardRectangleEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_discardRectangleEnable = 1; +} + +void vkCmdSetDiscardRectangleModeEXT(VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetDiscardRectangleModeEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetDiscardRectangleModeEXT); + cmock_call_instance = (CMOCK_vkCmdSetDiscardRectangleModeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetDiscardRectangleModeEXT_CallInstance); + Mock.vkCmdSetDiscardRectangleModeEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetDiscardRectangleModeEXT_CallInstance); + if (Mock.vkCmdSetDiscardRectangleModeEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetDiscardRectangleModeEXT_CallbackBool && + Mock.vkCmdSetDiscardRectangleModeEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDiscardRectangleModeEXT_CallbackFunctionPointer(commandBuffer, discardRectangleMode, Mock.vkCmdSetDiscardRectangleModeEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDiscardRectangleModeEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_discardRectangleMode) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDiscardRectangleModeEXT,CMockString_discardRectangleMode); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_discardRectangleMode), (void*)(&discardRectangleMode), sizeof(VkDiscardRectangleModeEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetDiscardRectangleModeEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDiscardRectangleModeEXT_CallbackFunctionPointer(commandBuffer, discardRectangleMode, Mock.vkCmdSetDiscardRectangleModeEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetDiscardRectangleModeEXT(CMOCK_vkCmdSetDiscardRectangleModeEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode); +void CMockExpectParameters_vkCmdSetDiscardRectangleModeEXT(CMOCK_vkCmdSetDiscardRectangleModeEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_discardRectangleMode), (void*)(&discardRectangleMode), + sizeof(VkDiscardRectangleModeEXT[sizeof(discardRectangleMode) == sizeof(VkDiscardRectangleModeEXT) ? 1 : -1])); /* add VkDiscardRectangleModeEXT to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_discardRectangleMode = 0; +} + +void vkCmdSetDiscardRectangleModeEXT_CMockIgnore(void) +{ + Mock.vkCmdSetDiscardRectangleModeEXT_IgnoreBool = (char)1; +} + +void vkCmdSetDiscardRectangleModeEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetDiscardRectangleModeEXT_IgnoreBool = (char)0; +} + +void vkCmdSetDiscardRectangleModeEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDiscardRectangleModeEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetDiscardRectangleModeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDiscardRectangleModeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDiscardRectangleModeEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDiscardRectangleModeEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetDiscardRectangleModeEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetDiscardRectangleModeEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDiscardRectangleModeEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetDiscardRectangleModeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDiscardRectangleModeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDiscardRectangleModeEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDiscardRectangleModeEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetDiscardRectangleModeEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetDiscardRectangleModeEXT(cmock_call_instance, commandBuffer, discardRectangleMode); +} + +void vkCmdSetDiscardRectangleModeEXT_AddCallback(CMOCK_vkCmdSetDiscardRectangleModeEXT_CALLBACK Callback) +{ + Mock.vkCmdSetDiscardRectangleModeEXT_IgnoreBool = (char)0; + Mock.vkCmdSetDiscardRectangleModeEXT_CallbackBool = (char)1; + Mock.vkCmdSetDiscardRectangleModeEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDiscardRectangleModeEXT_Stub(CMOCK_vkCmdSetDiscardRectangleModeEXT_CALLBACK Callback) +{ + Mock.vkCmdSetDiscardRectangleModeEXT_IgnoreBool = (char)0; + Mock.vkCmdSetDiscardRectangleModeEXT_CallbackBool = (char)0; + Mock.vkCmdSetDiscardRectangleModeEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDiscardRectangleModeEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDiscardRectangleModeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDiscardRectangleModeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDiscardRectangleModeEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetDiscardRectangleModeEXT_CMockIgnoreArg_discardRectangleMode(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDiscardRectangleModeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDiscardRectangleModeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDiscardRectangleModeEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_discardRectangleMode = 1; +} + +void vkSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkSetHdrMetadataEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkSetHdrMetadataEXT); + cmock_call_instance = (CMOCK_vkSetHdrMetadataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkSetHdrMetadataEXT_CallInstance); + Mock.vkSetHdrMetadataEXT_CallInstance = CMock_Guts_MemNext(Mock.vkSetHdrMetadataEXT_CallInstance); + if (Mock.vkSetHdrMetadataEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkSetHdrMetadataEXT_CallbackBool && + Mock.vkSetHdrMetadataEXT_CallbackFunctionPointer != NULL) + { + Mock.vkSetHdrMetadataEXT_CallbackFunctionPointer(device, swapchainCount, pSwapchains, pMetadata, Mock.vkSetHdrMetadataEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkSetHdrMetadataEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_swapchainCount) + { + UNITY_SET_DETAILS(CMockString_vkSetHdrMetadataEXT,CMockString_swapchainCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_swapchainCount, swapchainCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSwapchains) + { + UNITY_SET_DETAILS(CMockString_vkSetHdrMetadataEXT,CMockString_pSwapchains); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSwapchains), (void*)(pSwapchains), sizeof(const VkSwapchainKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMetadata) + { + UNITY_SET_DETAILS(CMockString_vkSetHdrMetadataEXT,CMockString_pMetadata); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMetadata), (void*)(pMetadata), sizeof(const VkHdrMetadataEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkSetHdrMetadataEXT_CallbackFunctionPointer != NULL) + { + Mock.vkSetHdrMetadataEXT_CallbackFunctionPointer(device, swapchainCount, pSwapchains, pMetadata, Mock.vkSetHdrMetadataEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkSetHdrMetadataEXT(CMOCK_vkSetHdrMetadataEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata); +void CMockExpectParameters_vkSetHdrMetadataEXT(CMOCK_vkSetHdrMetadataEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_swapchainCount = swapchainCount; + cmock_call_instance->IgnoreArg_swapchainCount = 0; + cmock_call_instance->Expected_pSwapchains = pSwapchains; + cmock_call_instance->IgnoreArg_pSwapchains = 0; + cmock_call_instance->Expected_pMetadata = pMetadata; + cmock_call_instance->IgnoreArg_pMetadata = 0; +} + +void vkSetHdrMetadataEXT_CMockIgnore(void) +{ + Mock.vkSetHdrMetadataEXT_IgnoreBool = (char)1; +} + +void vkSetHdrMetadataEXT_CMockStopIgnore(void) +{ + Mock.vkSetHdrMetadataEXT_IgnoreBool = (char)0; +} + +void vkSetHdrMetadataEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkSetHdrMetadataEXT_CALL_INSTANCE)); + CMOCK_vkSetHdrMetadataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetHdrMetadataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkSetHdrMetadataEXT_CallInstance = CMock_Guts_MemChain(Mock.vkSetHdrMetadataEXT_CallInstance, cmock_guts_index); + Mock.vkSetHdrMetadataEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkSetHdrMetadataEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkSetHdrMetadataEXT_CALL_INSTANCE)); + CMOCK_vkSetHdrMetadataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetHdrMetadataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkSetHdrMetadataEXT_CallInstance = CMock_Guts_MemChain(Mock.vkSetHdrMetadataEXT_CallInstance, cmock_guts_index); + Mock.vkSetHdrMetadataEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkSetHdrMetadataEXT(cmock_call_instance, device, swapchainCount, pSwapchains, pMetadata); +} + +void vkSetHdrMetadataEXT_AddCallback(CMOCK_vkSetHdrMetadataEXT_CALLBACK Callback) +{ + Mock.vkSetHdrMetadataEXT_IgnoreBool = (char)0; + Mock.vkSetHdrMetadataEXT_CallbackBool = (char)1; + Mock.vkSetHdrMetadataEXT_CallbackFunctionPointer = Callback; +} + +void vkSetHdrMetadataEXT_Stub(CMOCK_vkSetHdrMetadataEXT_CALLBACK Callback) +{ + Mock.vkSetHdrMetadataEXT_IgnoreBool = (char)0; + Mock.vkSetHdrMetadataEXT_CallbackBool = (char)0; + Mock.vkSetHdrMetadataEXT_CallbackFunctionPointer = Callback; +} + +void vkSetHdrMetadataEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSetHdrMetadataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetHdrMetadataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSetHdrMetadataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkSetHdrMetadataEXT_CMockIgnoreArg_swapchainCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSetHdrMetadataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetHdrMetadataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSetHdrMetadataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_swapchainCount = 1; +} + +void vkSetHdrMetadataEXT_CMockIgnoreArg_pSwapchains(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSetHdrMetadataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetHdrMetadataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSetHdrMetadataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSwapchains = 1; +} + +void vkSetHdrMetadataEXT_CMockIgnoreArg_pMetadata(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSetHdrMetadataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetHdrMetadataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSetHdrMetadataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMetadata = 1; +} + +VkResult vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkSetDebugUtilsObjectNameEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkSetDebugUtilsObjectNameEXT); + cmock_call_instance = (CMOCK_vkSetDebugUtilsObjectNameEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkSetDebugUtilsObjectNameEXT_CallInstance); + Mock.vkSetDebugUtilsObjectNameEXT_CallInstance = CMock_Guts_MemNext(Mock.vkSetDebugUtilsObjectNameEXT_CallInstance); + if (Mock.vkSetDebugUtilsObjectNameEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkSetDebugUtilsObjectNameEXT_FinalReturn; + memcpy((void*)(&Mock.vkSetDebugUtilsObjectNameEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkSetDebugUtilsObjectNameEXT_CallbackBool && + Mock.vkSetDebugUtilsObjectNameEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkSetDebugUtilsObjectNameEXT_CallbackFunctionPointer(device, pNameInfo, Mock.vkSetDebugUtilsObjectNameEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkSetDebugUtilsObjectNameEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pNameInfo) + { + UNITY_SET_DETAILS(CMockString_vkSetDebugUtilsObjectNameEXT,CMockString_pNameInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pNameInfo), (void*)(pNameInfo), sizeof(const VkDebugUtilsObjectNameInfoEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkSetDebugUtilsObjectNameEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkSetDebugUtilsObjectNameEXT_CallbackFunctionPointer(device, pNameInfo, Mock.vkSetDebugUtilsObjectNameEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkSetDebugUtilsObjectNameEXT(CMOCK_vkSetDebugUtilsObjectNameEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo); +void CMockExpectParameters_vkSetDebugUtilsObjectNameEXT(CMOCK_vkSetDebugUtilsObjectNameEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pNameInfo = pNameInfo; + cmock_call_instance->IgnoreArg_pNameInfo = 0; +} + +void vkSetDebugUtilsObjectNameEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkSetDebugUtilsObjectNameEXT_CALL_INSTANCE)); + CMOCK_vkSetDebugUtilsObjectNameEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetDebugUtilsObjectNameEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkSetDebugUtilsObjectNameEXT_CallInstance = CMock_Guts_MemChain(Mock.vkSetDebugUtilsObjectNameEXT_CallInstance, cmock_guts_index); + Mock.vkSetDebugUtilsObjectNameEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkSetDebugUtilsObjectNameEXT_IgnoreBool = (char)1; +} + +void vkSetDebugUtilsObjectNameEXT_CMockStopIgnore(void) +{ + if(Mock.vkSetDebugUtilsObjectNameEXT_IgnoreBool) + Mock.vkSetDebugUtilsObjectNameEXT_CallInstance = CMock_Guts_MemNext(Mock.vkSetDebugUtilsObjectNameEXT_CallInstance); + Mock.vkSetDebugUtilsObjectNameEXT_IgnoreBool = (char)0; +} + +void vkSetDebugUtilsObjectNameEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkSetDebugUtilsObjectNameEXT_CALL_INSTANCE)); + CMOCK_vkSetDebugUtilsObjectNameEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetDebugUtilsObjectNameEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkSetDebugUtilsObjectNameEXT_CallInstance = CMock_Guts_MemChain(Mock.vkSetDebugUtilsObjectNameEXT_CallInstance, cmock_guts_index); + Mock.vkSetDebugUtilsObjectNameEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkSetDebugUtilsObjectNameEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkSetDebugUtilsObjectNameEXT_CALL_INSTANCE)); + CMOCK_vkSetDebugUtilsObjectNameEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetDebugUtilsObjectNameEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkSetDebugUtilsObjectNameEXT_CallInstance = CMock_Guts_MemChain(Mock.vkSetDebugUtilsObjectNameEXT_CallInstance, cmock_guts_index); + Mock.vkSetDebugUtilsObjectNameEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkSetDebugUtilsObjectNameEXT(cmock_call_instance, device, pNameInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkSetDebugUtilsObjectNameEXT_AddCallback(CMOCK_vkSetDebugUtilsObjectNameEXT_CALLBACK Callback) +{ + Mock.vkSetDebugUtilsObjectNameEXT_IgnoreBool = (char)0; + Mock.vkSetDebugUtilsObjectNameEXT_CallbackBool = (char)1; + Mock.vkSetDebugUtilsObjectNameEXT_CallbackFunctionPointer = Callback; +} + +void vkSetDebugUtilsObjectNameEXT_Stub(CMOCK_vkSetDebugUtilsObjectNameEXT_CALLBACK Callback) +{ + Mock.vkSetDebugUtilsObjectNameEXT_IgnoreBool = (char)0; + Mock.vkSetDebugUtilsObjectNameEXT_CallbackBool = (char)0; + Mock.vkSetDebugUtilsObjectNameEXT_CallbackFunctionPointer = Callback; +} + +void vkSetDebugUtilsObjectNameEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSetDebugUtilsObjectNameEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetDebugUtilsObjectNameEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSetDebugUtilsObjectNameEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkSetDebugUtilsObjectNameEXT_CMockIgnoreArg_pNameInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSetDebugUtilsObjectNameEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetDebugUtilsObjectNameEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSetDebugUtilsObjectNameEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pNameInfo = 1; +} + +VkResult vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkSetDebugUtilsObjectTagEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkSetDebugUtilsObjectTagEXT); + cmock_call_instance = (CMOCK_vkSetDebugUtilsObjectTagEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkSetDebugUtilsObjectTagEXT_CallInstance); + Mock.vkSetDebugUtilsObjectTagEXT_CallInstance = CMock_Guts_MemNext(Mock.vkSetDebugUtilsObjectTagEXT_CallInstance); + if (Mock.vkSetDebugUtilsObjectTagEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkSetDebugUtilsObjectTagEXT_FinalReturn; + memcpy((void*)(&Mock.vkSetDebugUtilsObjectTagEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkSetDebugUtilsObjectTagEXT_CallbackBool && + Mock.vkSetDebugUtilsObjectTagEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkSetDebugUtilsObjectTagEXT_CallbackFunctionPointer(device, pTagInfo, Mock.vkSetDebugUtilsObjectTagEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkSetDebugUtilsObjectTagEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pTagInfo) + { + UNITY_SET_DETAILS(CMockString_vkSetDebugUtilsObjectTagEXT,CMockString_pTagInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pTagInfo), (void*)(pTagInfo), sizeof(const VkDebugUtilsObjectTagInfoEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkSetDebugUtilsObjectTagEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkSetDebugUtilsObjectTagEXT_CallbackFunctionPointer(device, pTagInfo, Mock.vkSetDebugUtilsObjectTagEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkSetDebugUtilsObjectTagEXT(CMOCK_vkSetDebugUtilsObjectTagEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo); +void CMockExpectParameters_vkSetDebugUtilsObjectTagEXT(CMOCK_vkSetDebugUtilsObjectTagEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pTagInfo = pTagInfo; + cmock_call_instance->IgnoreArg_pTagInfo = 0; +} + +void vkSetDebugUtilsObjectTagEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkSetDebugUtilsObjectTagEXT_CALL_INSTANCE)); + CMOCK_vkSetDebugUtilsObjectTagEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetDebugUtilsObjectTagEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkSetDebugUtilsObjectTagEXT_CallInstance = CMock_Guts_MemChain(Mock.vkSetDebugUtilsObjectTagEXT_CallInstance, cmock_guts_index); + Mock.vkSetDebugUtilsObjectTagEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkSetDebugUtilsObjectTagEXT_IgnoreBool = (char)1; +} + +void vkSetDebugUtilsObjectTagEXT_CMockStopIgnore(void) +{ + if(Mock.vkSetDebugUtilsObjectTagEXT_IgnoreBool) + Mock.vkSetDebugUtilsObjectTagEXT_CallInstance = CMock_Guts_MemNext(Mock.vkSetDebugUtilsObjectTagEXT_CallInstance); + Mock.vkSetDebugUtilsObjectTagEXT_IgnoreBool = (char)0; +} + +void vkSetDebugUtilsObjectTagEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkSetDebugUtilsObjectTagEXT_CALL_INSTANCE)); + CMOCK_vkSetDebugUtilsObjectTagEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetDebugUtilsObjectTagEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkSetDebugUtilsObjectTagEXT_CallInstance = CMock_Guts_MemChain(Mock.vkSetDebugUtilsObjectTagEXT_CallInstance, cmock_guts_index); + Mock.vkSetDebugUtilsObjectTagEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkSetDebugUtilsObjectTagEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkSetDebugUtilsObjectTagEXT_CALL_INSTANCE)); + CMOCK_vkSetDebugUtilsObjectTagEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetDebugUtilsObjectTagEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkSetDebugUtilsObjectTagEXT_CallInstance = CMock_Guts_MemChain(Mock.vkSetDebugUtilsObjectTagEXT_CallInstance, cmock_guts_index); + Mock.vkSetDebugUtilsObjectTagEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkSetDebugUtilsObjectTagEXT(cmock_call_instance, device, pTagInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkSetDebugUtilsObjectTagEXT_AddCallback(CMOCK_vkSetDebugUtilsObjectTagEXT_CALLBACK Callback) +{ + Mock.vkSetDebugUtilsObjectTagEXT_IgnoreBool = (char)0; + Mock.vkSetDebugUtilsObjectTagEXT_CallbackBool = (char)1; + Mock.vkSetDebugUtilsObjectTagEXT_CallbackFunctionPointer = Callback; +} + +void vkSetDebugUtilsObjectTagEXT_Stub(CMOCK_vkSetDebugUtilsObjectTagEXT_CALLBACK Callback) +{ + Mock.vkSetDebugUtilsObjectTagEXT_IgnoreBool = (char)0; + Mock.vkSetDebugUtilsObjectTagEXT_CallbackBool = (char)0; + Mock.vkSetDebugUtilsObjectTagEXT_CallbackFunctionPointer = Callback; +} + +void vkSetDebugUtilsObjectTagEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSetDebugUtilsObjectTagEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetDebugUtilsObjectTagEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSetDebugUtilsObjectTagEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkSetDebugUtilsObjectTagEXT_CMockIgnoreArg_pTagInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSetDebugUtilsObjectTagEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetDebugUtilsObjectTagEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSetDebugUtilsObjectTagEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pTagInfo = 1; +} + +void vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkQueueBeginDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkQueueBeginDebugUtilsLabelEXT); + cmock_call_instance = (CMOCK_vkQueueBeginDebugUtilsLabelEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkQueueBeginDebugUtilsLabelEXT_CallInstance); + Mock.vkQueueBeginDebugUtilsLabelEXT_CallInstance = CMock_Guts_MemNext(Mock.vkQueueBeginDebugUtilsLabelEXT_CallInstance); + if (Mock.vkQueueBeginDebugUtilsLabelEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkQueueBeginDebugUtilsLabelEXT_CallbackBool && + Mock.vkQueueBeginDebugUtilsLabelEXT_CallbackFunctionPointer != NULL) + { + Mock.vkQueueBeginDebugUtilsLabelEXT_CallbackFunctionPointer(queue, pLabelInfo, Mock.vkQueueBeginDebugUtilsLabelEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_queue) + { + UNITY_SET_DETAILS(CMockString_vkQueueBeginDebugUtilsLabelEXT,CMockString_queue); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queue), (void*)(&queue), sizeof(VkQueue), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pLabelInfo) + { + UNITY_SET_DETAILS(CMockString_vkQueueBeginDebugUtilsLabelEXT,CMockString_pLabelInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pLabelInfo), (void*)(pLabelInfo), sizeof(const VkDebugUtilsLabelEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkQueueBeginDebugUtilsLabelEXT_CallbackFunctionPointer != NULL) + { + Mock.vkQueueBeginDebugUtilsLabelEXT_CallbackFunctionPointer(queue, pLabelInfo, Mock.vkQueueBeginDebugUtilsLabelEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkQueueBeginDebugUtilsLabelEXT(CMOCK_vkQueueBeginDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance, VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); +void CMockExpectParameters_vkQueueBeginDebugUtilsLabelEXT(CMOCK_vkQueueBeginDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance, VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_queue), (void*)(&queue), + sizeof(VkQueue[sizeof(queue) == sizeof(VkQueue) ? 1 : -1])); /* add VkQueue to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queue = 0; + cmock_call_instance->Expected_pLabelInfo = pLabelInfo; + cmock_call_instance->IgnoreArg_pLabelInfo = 0; +} + +void vkQueueBeginDebugUtilsLabelEXT_CMockIgnore(void) +{ + Mock.vkQueueBeginDebugUtilsLabelEXT_IgnoreBool = (char)1; +} + +void vkQueueBeginDebugUtilsLabelEXT_CMockStopIgnore(void) +{ + Mock.vkQueueBeginDebugUtilsLabelEXT_IgnoreBool = (char)0; +} + +void vkQueueBeginDebugUtilsLabelEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkQueueBeginDebugUtilsLabelEXT_CALL_INSTANCE)); + CMOCK_vkQueueBeginDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueBeginDebugUtilsLabelEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkQueueBeginDebugUtilsLabelEXT_CallInstance = CMock_Guts_MemChain(Mock.vkQueueBeginDebugUtilsLabelEXT_CallInstance, cmock_guts_index); + Mock.vkQueueBeginDebugUtilsLabelEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkQueueBeginDebugUtilsLabelEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkQueueBeginDebugUtilsLabelEXT_CALL_INSTANCE)); + CMOCK_vkQueueBeginDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueBeginDebugUtilsLabelEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkQueueBeginDebugUtilsLabelEXT_CallInstance = CMock_Guts_MemChain(Mock.vkQueueBeginDebugUtilsLabelEXT_CallInstance, cmock_guts_index); + Mock.vkQueueBeginDebugUtilsLabelEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkQueueBeginDebugUtilsLabelEXT(cmock_call_instance, queue, pLabelInfo); +} + +void vkQueueBeginDebugUtilsLabelEXT_AddCallback(CMOCK_vkQueueBeginDebugUtilsLabelEXT_CALLBACK Callback) +{ + Mock.vkQueueBeginDebugUtilsLabelEXT_IgnoreBool = (char)0; + Mock.vkQueueBeginDebugUtilsLabelEXT_CallbackBool = (char)1; + Mock.vkQueueBeginDebugUtilsLabelEXT_CallbackFunctionPointer = Callback; +} + +void vkQueueBeginDebugUtilsLabelEXT_Stub(CMOCK_vkQueueBeginDebugUtilsLabelEXT_CALLBACK Callback) +{ + Mock.vkQueueBeginDebugUtilsLabelEXT_IgnoreBool = (char)0; + Mock.vkQueueBeginDebugUtilsLabelEXT_CallbackBool = (char)0; + Mock.vkQueueBeginDebugUtilsLabelEXT_CallbackFunctionPointer = Callback; +} + +void vkQueueBeginDebugUtilsLabelEXT_CMockIgnoreArg_queue(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkQueueBeginDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueBeginDebugUtilsLabelEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkQueueBeginDebugUtilsLabelEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queue = 1; +} + +void vkQueueBeginDebugUtilsLabelEXT_CMockIgnoreArg_pLabelInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkQueueBeginDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueBeginDebugUtilsLabelEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkQueueBeginDebugUtilsLabelEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pLabelInfo = 1; +} + +void vkQueueEndDebugUtilsLabelEXT(VkQueue queue) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkQueueEndDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkQueueEndDebugUtilsLabelEXT); + cmock_call_instance = (CMOCK_vkQueueEndDebugUtilsLabelEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkQueueEndDebugUtilsLabelEXT_CallInstance); + Mock.vkQueueEndDebugUtilsLabelEXT_CallInstance = CMock_Guts_MemNext(Mock.vkQueueEndDebugUtilsLabelEXT_CallInstance); + if (Mock.vkQueueEndDebugUtilsLabelEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkQueueEndDebugUtilsLabelEXT_CallbackBool && + Mock.vkQueueEndDebugUtilsLabelEXT_CallbackFunctionPointer != NULL) + { + Mock.vkQueueEndDebugUtilsLabelEXT_CallbackFunctionPointer(queue, Mock.vkQueueEndDebugUtilsLabelEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_queue) + { + UNITY_SET_DETAILS(CMockString_vkQueueEndDebugUtilsLabelEXT,CMockString_queue); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queue), (void*)(&queue), sizeof(VkQueue), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkQueueEndDebugUtilsLabelEXT_CallbackFunctionPointer != NULL) + { + Mock.vkQueueEndDebugUtilsLabelEXT_CallbackFunctionPointer(queue, Mock.vkQueueEndDebugUtilsLabelEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkQueueEndDebugUtilsLabelEXT(CMOCK_vkQueueEndDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance, VkQueue queue); +void CMockExpectParameters_vkQueueEndDebugUtilsLabelEXT(CMOCK_vkQueueEndDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance, VkQueue queue) +{ + memcpy((void*)(&cmock_call_instance->Expected_queue), (void*)(&queue), + sizeof(VkQueue[sizeof(queue) == sizeof(VkQueue) ? 1 : -1])); /* add VkQueue to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queue = 0; +} + +void vkQueueEndDebugUtilsLabelEXT_CMockIgnore(void) +{ + Mock.vkQueueEndDebugUtilsLabelEXT_IgnoreBool = (char)1; +} + +void vkQueueEndDebugUtilsLabelEXT_CMockStopIgnore(void) +{ + Mock.vkQueueEndDebugUtilsLabelEXT_IgnoreBool = (char)0; +} + +void vkQueueEndDebugUtilsLabelEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkQueueEndDebugUtilsLabelEXT_CALL_INSTANCE)); + CMOCK_vkQueueEndDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueEndDebugUtilsLabelEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkQueueEndDebugUtilsLabelEXT_CallInstance = CMock_Guts_MemChain(Mock.vkQueueEndDebugUtilsLabelEXT_CallInstance, cmock_guts_index); + Mock.vkQueueEndDebugUtilsLabelEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkQueueEndDebugUtilsLabelEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkQueue queue) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkQueueEndDebugUtilsLabelEXT_CALL_INSTANCE)); + CMOCK_vkQueueEndDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueEndDebugUtilsLabelEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkQueueEndDebugUtilsLabelEXT_CallInstance = CMock_Guts_MemChain(Mock.vkQueueEndDebugUtilsLabelEXT_CallInstance, cmock_guts_index); + Mock.vkQueueEndDebugUtilsLabelEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkQueueEndDebugUtilsLabelEXT(cmock_call_instance, queue); +} + +void vkQueueEndDebugUtilsLabelEXT_AddCallback(CMOCK_vkQueueEndDebugUtilsLabelEXT_CALLBACK Callback) +{ + Mock.vkQueueEndDebugUtilsLabelEXT_IgnoreBool = (char)0; + Mock.vkQueueEndDebugUtilsLabelEXT_CallbackBool = (char)1; + Mock.vkQueueEndDebugUtilsLabelEXT_CallbackFunctionPointer = Callback; +} + +void vkQueueEndDebugUtilsLabelEXT_Stub(CMOCK_vkQueueEndDebugUtilsLabelEXT_CALLBACK Callback) +{ + Mock.vkQueueEndDebugUtilsLabelEXT_IgnoreBool = (char)0; + Mock.vkQueueEndDebugUtilsLabelEXT_CallbackBool = (char)0; + Mock.vkQueueEndDebugUtilsLabelEXT_CallbackFunctionPointer = Callback; +} + +void vkQueueEndDebugUtilsLabelEXT_CMockIgnoreArg_queue(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkQueueEndDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueEndDebugUtilsLabelEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkQueueEndDebugUtilsLabelEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queue = 1; +} + +void vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkQueueInsertDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkQueueInsertDebugUtilsLabelEXT); + cmock_call_instance = (CMOCK_vkQueueInsertDebugUtilsLabelEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkQueueInsertDebugUtilsLabelEXT_CallInstance); + Mock.vkQueueInsertDebugUtilsLabelEXT_CallInstance = CMock_Guts_MemNext(Mock.vkQueueInsertDebugUtilsLabelEXT_CallInstance); + if (Mock.vkQueueInsertDebugUtilsLabelEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkQueueInsertDebugUtilsLabelEXT_CallbackBool && + Mock.vkQueueInsertDebugUtilsLabelEXT_CallbackFunctionPointer != NULL) + { + Mock.vkQueueInsertDebugUtilsLabelEXT_CallbackFunctionPointer(queue, pLabelInfo, Mock.vkQueueInsertDebugUtilsLabelEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_queue) + { + UNITY_SET_DETAILS(CMockString_vkQueueInsertDebugUtilsLabelEXT,CMockString_queue); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queue), (void*)(&queue), sizeof(VkQueue), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pLabelInfo) + { + UNITY_SET_DETAILS(CMockString_vkQueueInsertDebugUtilsLabelEXT,CMockString_pLabelInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pLabelInfo), (void*)(pLabelInfo), sizeof(const VkDebugUtilsLabelEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkQueueInsertDebugUtilsLabelEXT_CallbackFunctionPointer != NULL) + { + Mock.vkQueueInsertDebugUtilsLabelEXT_CallbackFunctionPointer(queue, pLabelInfo, Mock.vkQueueInsertDebugUtilsLabelEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkQueueInsertDebugUtilsLabelEXT(CMOCK_vkQueueInsertDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance, VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); +void CMockExpectParameters_vkQueueInsertDebugUtilsLabelEXT(CMOCK_vkQueueInsertDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance, VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_queue), (void*)(&queue), + sizeof(VkQueue[sizeof(queue) == sizeof(VkQueue) ? 1 : -1])); /* add VkQueue to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queue = 0; + cmock_call_instance->Expected_pLabelInfo = pLabelInfo; + cmock_call_instance->IgnoreArg_pLabelInfo = 0; +} + +void vkQueueInsertDebugUtilsLabelEXT_CMockIgnore(void) +{ + Mock.vkQueueInsertDebugUtilsLabelEXT_IgnoreBool = (char)1; +} + +void vkQueueInsertDebugUtilsLabelEXT_CMockStopIgnore(void) +{ + Mock.vkQueueInsertDebugUtilsLabelEXT_IgnoreBool = (char)0; +} + +void vkQueueInsertDebugUtilsLabelEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkQueueInsertDebugUtilsLabelEXT_CALL_INSTANCE)); + CMOCK_vkQueueInsertDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueInsertDebugUtilsLabelEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkQueueInsertDebugUtilsLabelEXT_CallInstance = CMock_Guts_MemChain(Mock.vkQueueInsertDebugUtilsLabelEXT_CallInstance, cmock_guts_index); + Mock.vkQueueInsertDebugUtilsLabelEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkQueueInsertDebugUtilsLabelEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkQueueInsertDebugUtilsLabelEXT_CALL_INSTANCE)); + CMOCK_vkQueueInsertDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueInsertDebugUtilsLabelEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkQueueInsertDebugUtilsLabelEXT_CallInstance = CMock_Guts_MemChain(Mock.vkQueueInsertDebugUtilsLabelEXT_CallInstance, cmock_guts_index); + Mock.vkQueueInsertDebugUtilsLabelEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkQueueInsertDebugUtilsLabelEXT(cmock_call_instance, queue, pLabelInfo); +} + +void vkQueueInsertDebugUtilsLabelEXT_AddCallback(CMOCK_vkQueueInsertDebugUtilsLabelEXT_CALLBACK Callback) +{ + Mock.vkQueueInsertDebugUtilsLabelEXT_IgnoreBool = (char)0; + Mock.vkQueueInsertDebugUtilsLabelEXT_CallbackBool = (char)1; + Mock.vkQueueInsertDebugUtilsLabelEXT_CallbackFunctionPointer = Callback; +} + +void vkQueueInsertDebugUtilsLabelEXT_Stub(CMOCK_vkQueueInsertDebugUtilsLabelEXT_CALLBACK Callback) +{ + Mock.vkQueueInsertDebugUtilsLabelEXT_IgnoreBool = (char)0; + Mock.vkQueueInsertDebugUtilsLabelEXT_CallbackBool = (char)0; + Mock.vkQueueInsertDebugUtilsLabelEXT_CallbackFunctionPointer = Callback; +} + +void vkQueueInsertDebugUtilsLabelEXT_CMockIgnoreArg_queue(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkQueueInsertDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueInsertDebugUtilsLabelEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkQueueInsertDebugUtilsLabelEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queue = 1; +} + +void vkQueueInsertDebugUtilsLabelEXT_CMockIgnoreArg_pLabelInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkQueueInsertDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueInsertDebugUtilsLabelEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkQueueInsertDebugUtilsLabelEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pLabelInfo = 1; +} + +void vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBeginDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBeginDebugUtilsLabelEXT); + cmock_call_instance = (CMOCK_vkCmdBeginDebugUtilsLabelEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBeginDebugUtilsLabelEXT_CallInstance); + Mock.vkCmdBeginDebugUtilsLabelEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBeginDebugUtilsLabelEXT_CallInstance); + if (Mock.vkCmdBeginDebugUtilsLabelEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBeginDebugUtilsLabelEXT_CallbackBool && + Mock.vkCmdBeginDebugUtilsLabelEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBeginDebugUtilsLabelEXT_CallbackFunctionPointer(commandBuffer, pLabelInfo, Mock.vkCmdBeginDebugUtilsLabelEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginDebugUtilsLabelEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pLabelInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdBeginDebugUtilsLabelEXT,CMockString_pLabelInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pLabelInfo), (void*)(pLabelInfo), sizeof(const VkDebugUtilsLabelEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdBeginDebugUtilsLabelEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBeginDebugUtilsLabelEXT_CallbackFunctionPointer(commandBuffer, pLabelInfo, Mock.vkCmdBeginDebugUtilsLabelEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBeginDebugUtilsLabelEXT(CMOCK_vkCmdBeginDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); +void CMockExpectParameters_vkCmdBeginDebugUtilsLabelEXT(CMOCK_vkCmdBeginDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pLabelInfo = pLabelInfo; + cmock_call_instance->IgnoreArg_pLabelInfo = 0; +} + +void vkCmdBeginDebugUtilsLabelEXT_CMockIgnore(void) +{ + Mock.vkCmdBeginDebugUtilsLabelEXT_IgnoreBool = (char)1; +} + +void vkCmdBeginDebugUtilsLabelEXT_CMockStopIgnore(void) +{ + Mock.vkCmdBeginDebugUtilsLabelEXT_IgnoreBool = (char)0; +} + +void vkCmdBeginDebugUtilsLabelEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBeginDebugUtilsLabelEXT_CALL_INSTANCE)); + CMOCK_vkCmdBeginDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginDebugUtilsLabelEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBeginDebugUtilsLabelEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBeginDebugUtilsLabelEXT_CallInstance, cmock_guts_index); + Mock.vkCmdBeginDebugUtilsLabelEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBeginDebugUtilsLabelEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBeginDebugUtilsLabelEXT_CALL_INSTANCE)); + CMOCK_vkCmdBeginDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginDebugUtilsLabelEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBeginDebugUtilsLabelEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBeginDebugUtilsLabelEXT_CallInstance, cmock_guts_index); + Mock.vkCmdBeginDebugUtilsLabelEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBeginDebugUtilsLabelEXT(cmock_call_instance, commandBuffer, pLabelInfo); +} + +void vkCmdBeginDebugUtilsLabelEXT_AddCallback(CMOCK_vkCmdBeginDebugUtilsLabelEXT_CALLBACK Callback) +{ + Mock.vkCmdBeginDebugUtilsLabelEXT_IgnoreBool = (char)0; + Mock.vkCmdBeginDebugUtilsLabelEXT_CallbackBool = (char)1; + Mock.vkCmdBeginDebugUtilsLabelEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdBeginDebugUtilsLabelEXT_Stub(CMOCK_vkCmdBeginDebugUtilsLabelEXT_CALLBACK Callback) +{ + Mock.vkCmdBeginDebugUtilsLabelEXT_IgnoreBool = (char)0; + Mock.vkCmdBeginDebugUtilsLabelEXT_CallbackBool = (char)0; + Mock.vkCmdBeginDebugUtilsLabelEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdBeginDebugUtilsLabelEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginDebugUtilsLabelEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginDebugUtilsLabelEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBeginDebugUtilsLabelEXT_CMockIgnoreArg_pLabelInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBeginDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBeginDebugUtilsLabelEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBeginDebugUtilsLabelEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pLabelInfo = 1; +} + +void vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdEndDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdEndDebugUtilsLabelEXT); + cmock_call_instance = (CMOCK_vkCmdEndDebugUtilsLabelEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdEndDebugUtilsLabelEXT_CallInstance); + Mock.vkCmdEndDebugUtilsLabelEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdEndDebugUtilsLabelEXT_CallInstance); + if (Mock.vkCmdEndDebugUtilsLabelEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdEndDebugUtilsLabelEXT_CallbackBool && + Mock.vkCmdEndDebugUtilsLabelEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdEndDebugUtilsLabelEXT_CallbackFunctionPointer(commandBuffer, Mock.vkCmdEndDebugUtilsLabelEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdEndDebugUtilsLabelEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdEndDebugUtilsLabelEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdEndDebugUtilsLabelEXT_CallbackFunctionPointer(commandBuffer, Mock.vkCmdEndDebugUtilsLabelEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdEndDebugUtilsLabelEXT(CMOCK_vkCmdEndDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer); +void CMockExpectParameters_vkCmdEndDebugUtilsLabelEXT(CMOCK_vkCmdEndDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; +} + +void vkCmdEndDebugUtilsLabelEXT_CMockIgnore(void) +{ + Mock.vkCmdEndDebugUtilsLabelEXT_IgnoreBool = (char)1; +} + +void vkCmdEndDebugUtilsLabelEXT_CMockStopIgnore(void) +{ + Mock.vkCmdEndDebugUtilsLabelEXT_IgnoreBool = (char)0; +} + +void vkCmdEndDebugUtilsLabelEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdEndDebugUtilsLabelEXT_CALL_INSTANCE)); + CMOCK_vkCmdEndDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndDebugUtilsLabelEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdEndDebugUtilsLabelEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdEndDebugUtilsLabelEXT_CallInstance, cmock_guts_index); + Mock.vkCmdEndDebugUtilsLabelEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdEndDebugUtilsLabelEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdEndDebugUtilsLabelEXT_CALL_INSTANCE)); + CMOCK_vkCmdEndDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndDebugUtilsLabelEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdEndDebugUtilsLabelEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdEndDebugUtilsLabelEXT_CallInstance, cmock_guts_index); + Mock.vkCmdEndDebugUtilsLabelEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdEndDebugUtilsLabelEXT(cmock_call_instance, commandBuffer); +} + +void vkCmdEndDebugUtilsLabelEXT_AddCallback(CMOCK_vkCmdEndDebugUtilsLabelEXT_CALLBACK Callback) +{ + Mock.vkCmdEndDebugUtilsLabelEXT_IgnoreBool = (char)0; + Mock.vkCmdEndDebugUtilsLabelEXT_CallbackBool = (char)1; + Mock.vkCmdEndDebugUtilsLabelEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdEndDebugUtilsLabelEXT_Stub(CMOCK_vkCmdEndDebugUtilsLabelEXT_CALLBACK Callback) +{ + Mock.vkCmdEndDebugUtilsLabelEXT_IgnoreBool = (char)0; + Mock.vkCmdEndDebugUtilsLabelEXT_CallbackBool = (char)0; + Mock.vkCmdEndDebugUtilsLabelEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdEndDebugUtilsLabelEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdEndDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdEndDebugUtilsLabelEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdEndDebugUtilsLabelEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdInsertDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdInsertDebugUtilsLabelEXT); + cmock_call_instance = (CMOCK_vkCmdInsertDebugUtilsLabelEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdInsertDebugUtilsLabelEXT_CallInstance); + Mock.vkCmdInsertDebugUtilsLabelEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdInsertDebugUtilsLabelEXT_CallInstance); + if (Mock.vkCmdInsertDebugUtilsLabelEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdInsertDebugUtilsLabelEXT_CallbackBool && + Mock.vkCmdInsertDebugUtilsLabelEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdInsertDebugUtilsLabelEXT_CallbackFunctionPointer(commandBuffer, pLabelInfo, Mock.vkCmdInsertDebugUtilsLabelEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdInsertDebugUtilsLabelEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pLabelInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdInsertDebugUtilsLabelEXT,CMockString_pLabelInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pLabelInfo), (void*)(pLabelInfo), sizeof(const VkDebugUtilsLabelEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdInsertDebugUtilsLabelEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdInsertDebugUtilsLabelEXT_CallbackFunctionPointer(commandBuffer, pLabelInfo, Mock.vkCmdInsertDebugUtilsLabelEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdInsertDebugUtilsLabelEXT(CMOCK_vkCmdInsertDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); +void CMockExpectParameters_vkCmdInsertDebugUtilsLabelEXT(CMOCK_vkCmdInsertDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pLabelInfo = pLabelInfo; + cmock_call_instance->IgnoreArg_pLabelInfo = 0; +} + +void vkCmdInsertDebugUtilsLabelEXT_CMockIgnore(void) +{ + Mock.vkCmdInsertDebugUtilsLabelEXT_IgnoreBool = (char)1; +} + +void vkCmdInsertDebugUtilsLabelEXT_CMockStopIgnore(void) +{ + Mock.vkCmdInsertDebugUtilsLabelEXT_IgnoreBool = (char)0; +} + +void vkCmdInsertDebugUtilsLabelEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdInsertDebugUtilsLabelEXT_CALL_INSTANCE)); + CMOCK_vkCmdInsertDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdInsertDebugUtilsLabelEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdInsertDebugUtilsLabelEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdInsertDebugUtilsLabelEXT_CallInstance, cmock_guts_index); + Mock.vkCmdInsertDebugUtilsLabelEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdInsertDebugUtilsLabelEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdInsertDebugUtilsLabelEXT_CALL_INSTANCE)); + CMOCK_vkCmdInsertDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdInsertDebugUtilsLabelEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdInsertDebugUtilsLabelEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdInsertDebugUtilsLabelEXT_CallInstance, cmock_guts_index); + Mock.vkCmdInsertDebugUtilsLabelEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdInsertDebugUtilsLabelEXT(cmock_call_instance, commandBuffer, pLabelInfo); +} + +void vkCmdInsertDebugUtilsLabelEXT_AddCallback(CMOCK_vkCmdInsertDebugUtilsLabelEXT_CALLBACK Callback) +{ + Mock.vkCmdInsertDebugUtilsLabelEXT_IgnoreBool = (char)0; + Mock.vkCmdInsertDebugUtilsLabelEXT_CallbackBool = (char)1; + Mock.vkCmdInsertDebugUtilsLabelEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdInsertDebugUtilsLabelEXT_Stub(CMOCK_vkCmdInsertDebugUtilsLabelEXT_CALLBACK Callback) +{ + Mock.vkCmdInsertDebugUtilsLabelEXT_IgnoreBool = (char)0; + Mock.vkCmdInsertDebugUtilsLabelEXT_CallbackBool = (char)0; + Mock.vkCmdInsertDebugUtilsLabelEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdInsertDebugUtilsLabelEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdInsertDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdInsertDebugUtilsLabelEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdInsertDebugUtilsLabelEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdInsertDebugUtilsLabelEXT_CMockIgnoreArg_pLabelInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdInsertDebugUtilsLabelEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdInsertDebugUtilsLabelEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdInsertDebugUtilsLabelEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pLabelInfo = 1; +} + +VkResult vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateDebugUtilsMessengerEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateDebugUtilsMessengerEXT); + cmock_call_instance = (CMOCK_vkCreateDebugUtilsMessengerEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateDebugUtilsMessengerEXT_CallInstance); + Mock.vkCreateDebugUtilsMessengerEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCreateDebugUtilsMessengerEXT_CallInstance); + if (Mock.vkCreateDebugUtilsMessengerEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateDebugUtilsMessengerEXT_FinalReturn; + memcpy((void*)(&Mock.vkCreateDebugUtilsMessengerEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateDebugUtilsMessengerEXT_CallbackBool && + Mock.vkCreateDebugUtilsMessengerEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateDebugUtilsMessengerEXT_CallbackFunctionPointer(instance, pCreateInfo, pAllocator, pMessenger, Mock.vkCreateDebugUtilsMessengerEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_instance) + { + UNITY_SET_DETAILS(CMockString_vkCreateDebugUtilsMessengerEXT,CMockString_instance); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), sizeof(VkInstance), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateDebugUtilsMessengerEXT,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkDebugUtilsMessengerCreateInfoEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateDebugUtilsMessengerEXT,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMessenger) + { + UNITY_SET_DETAILS(CMockString_vkCreateDebugUtilsMessengerEXT,CMockString_pMessenger); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMessenger), (void*)(pMessenger), sizeof(VkDebugUtilsMessengerEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateDebugUtilsMessengerEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateDebugUtilsMessengerEXT_CallbackFunctionPointer(instance, pCreateInfo, pAllocator, pMessenger, Mock.vkCreateDebugUtilsMessengerEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pMessenger_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pMessenger, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pMessenger, (const void*)cmock_call_instance->ReturnThruPtr_pMessenger_Val, + cmock_call_instance->ReturnThruPtr_pMessenger_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateDebugUtilsMessengerEXT(CMOCK_vkCreateDebugUtilsMessengerEXT_CALL_INSTANCE* cmock_call_instance, VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger); +void CMockExpectParameters_vkCreateDebugUtilsMessengerEXT(CMOCK_vkCreateDebugUtilsMessengerEXT_CALL_INSTANCE* cmock_call_instance, VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger) +{ + memcpy((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), + sizeof(VkInstance[sizeof(instance) == sizeof(VkInstance) ? 1 : -1])); /* add VkInstance to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_instance = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pMessenger = pMessenger; + cmock_call_instance->IgnoreArg_pMessenger = 0; + cmock_call_instance->ReturnThruPtr_pMessenger_Used = 0; +} + +void vkCreateDebugUtilsMessengerEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateDebugUtilsMessengerEXT_CALL_INSTANCE)); + CMOCK_vkCreateDebugUtilsMessengerEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDebugUtilsMessengerEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateDebugUtilsMessengerEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCreateDebugUtilsMessengerEXT_CallInstance, cmock_guts_index); + Mock.vkCreateDebugUtilsMessengerEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateDebugUtilsMessengerEXT_IgnoreBool = (char)1; +} + +void vkCreateDebugUtilsMessengerEXT_CMockStopIgnore(void) +{ + if(Mock.vkCreateDebugUtilsMessengerEXT_IgnoreBool) + Mock.vkCreateDebugUtilsMessengerEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCreateDebugUtilsMessengerEXT_CallInstance); + Mock.vkCreateDebugUtilsMessengerEXT_IgnoreBool = (char)0; +} + +void vkCreateDebugUtilsMessengerEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateDebugUtilsMessengerEXT_CALL_INSTANCE)); + CMOCK_vkCreateDebugUtilsMessengerEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDebugUtilsMessengerEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateDebugUtilsMessengerEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCreateDebugUtilsMessengerEXT_CallInstance, cmock_guts_index); + Mock.vkCreateDebugUtilsMessengerEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateDebugUtilsMessengerEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateDebugUtilsMessengerEXT_CALL_INSTANCE)); + CMOCK_vkCreateDebugUtilsMessengerEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDebugUtilsMessengerEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateDebugUtilsMessengerEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCreateDebugUtilsMessengerEXT_CallInstance, cmock_guts_index); + Mock.vkCreateDebugUtilsMessengerEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateDebugUtilsMessengerEXT(cmock_call_instance, instance, pCreateInfo, pAllocator, pMessenger); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateDebugUtilsMessengerEXT_AddCallback(CMOCK_vkCreateDebugUtilsMessengerEXT_CALLBACK Callback) +{ + Mock.vkCreateDebugUtilsMessengerEXT_IgnoreBool = (char)0; + Mock.vkCreateDebugUtilsMessengerEXT_CallbackBool = (char)1; + Mock.vkCreateDebugUtilsMessengerEXT_CallbackFunctionPointer = Callback; +} + +void vkCreateDebugUtilsMessengerEXT_Stub(CMOCK_vkCreateDebugUtilsMessengerEXT_CALLBACK Callback) +{ + Mock.vkCreateDebugUtilsMessengerEXT_IgnoreBool = (char)0; + Mock.vkCreateDebugUtilsMessengerEXT_CallbackBool = (char)0; + Mock.vkCreateDebugUtilsMessengerEXT_CallbackFunctionPointer = Callback; +} + +void vkCreateDebugUtilsMessengerEXT_CMockReturnMemThruPtr_pMessenger(UNITY_LINE_TYPE cmock_line, VkDebugUtilsMessengerEXT const* pMessenger, size_t cmock_size) +{ + CMOCK_vkCreateDebugUtilsMessengerEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDebugUtilsMessengerEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDebugUtilsMessengerEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pMessenger_Used = 1; + cmock_call_instance->ReturnThruPtr_pMessenger_Val = pMessenger; + cmock_call_instance->ReturnThruPtr_pMessenger_Size = cmock_size; +} + +void vkCreateDebugUtilsMessengerEXT_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDebugUtilsMessengerEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDebugUtilsMessengerEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDebugUtilsMessengerEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_instance = 1; +} + +void vkCreateDebugUtilsMessengerEXT_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDebugUtilsMessengerEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDebugUtilsMessengerEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDebugUtilsMessengerEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateDebugUtilsMessengerEXT_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDebugUtilsMessengerEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDebugUtilsMessengerEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDebugUtilsMessengerEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateDebugUtilsMessengerEXT_CMockIgnoreArg_pMessenger(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateDebugUtilsMessengerEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateDebugUtilsMessengerEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateDebugUtilsMessengerEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMessenger = 1; +} + +void vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyDebugUtilsMessengerEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyDebugUtilsMessengerEXT); + cmock_call_instance = (CMOCK_vkDestroyDebugUtilsMessengerEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyDebugUtilsMessengerEXT_CallInstance); + Mock.vkDestroyDebugUtilsMessengerEXT_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyDebugUtilsMessengerEXT_CallInstance); + if (Mock.vkDestroyDebugUtilsMessengerEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyDebugUtilsMessengerEXT_CallbackBool && + Mock.vkDestroyDebugUtilsMessengerEXT_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyDebugUtilsMessengerEXT_CallbackFunctionPointer(instance, messenger, pAllocator, Mock.vkDestroyDebugUtilsMessengerEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_instance) + { + UNITY_SET_DETAILS(CMockString_vkDestroyDebugUtilsMessengerEXT,CMockString_instance); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), sizeof(VkInstance), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_messenger) + { + UNITY_SET_DETAILS(CMockString_vkDestroyDebugUtilsMessengerEXT,CMockString_messenger); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_messenger), (void*)(&messenger), sizeof(VkDebugUtilsMessengerEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyDebugUtilsMessengerEXT,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyDebugUtilsMessengerEXT_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyDebugUtilsMessengerEXT_CallbackFunctionPointer(instance, messenger, pAllocator, Mock.vkDestroyDebugUtilsMessengerEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyDebugUtilsMessengerEXT(CMOCK_vkDestroyDebugUtilsMessengerEXT_CALL_INSTANCE* cmock_call_instance, VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyDebugUtilsMessengerEXT(CMOCK_vkDestroyDebugUtilsMessengerEXT_CALL_INSTANCE* cmock_call_instance, VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), + sizeof(VkInstance[sizeof(instance) == sizeof(VkInstance) ? 1 : -1])); /* add VkInstance to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_instance = 0; + memcpy((void*)(&cmock_call_instance->Expected_messenger), (void*)(&messenger), + sizeof(VkDebugUtilsMessengerEXT[sizeof(messenger) == sizeof(VkDebugUtilsMessengerEXT) ? 1 : -1])); /* add VkDebugUtilsMessengerEXT to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_messenger = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyDebugUtilsMessengerEXT_CMockIgnore(void) +{ + Mock.vkDestroyDebugUtilsMessengerEXT_IgnoreBool = (char)1; +} + +void vkDestroyDebugUtilsMessengerEXT_CMockStopIgnore(void) +{ + Mock.vkDestroyDebugUtilsMessengerEXT_IgnoreBool = (char)0; +} + +void vkDestroyDebugUtilsMessengerEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyDebugUtilsMessengerEXT_CALL_INSTANCE)); + CMOCK_vkDestroyDebugUtilsMessengerEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDebugUtilsMessengerEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyDebugUtilsMessengerEXT_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyDebugUtilsMessengerEXT_CallInstance, cmock_guts_index); + Mock.vkDestroyDebugUtilsMessengerEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyDebugUtilsMessengerEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyDebugUtilsMessengerEXT_CALL_INSTANCE)); + CMOCK_vkDestroyDebugUtilsMessengerEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDebugUtilsMessengerEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyDebugUtilsMessengerEXT_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyDebugUtilsMessengerEXT_CallInstance, cmock_guts_index); + Mock.vkDestroyDebugUtilsMessengerEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyDebugUtilsMessengerEXT(cmock_call_instance, instance, messenger, pAllocator); +} + +void vkDestroyDebugUtilsMessengerEXT_AddCallback(CMOCK_vkDestroyDebugUtilsMessengerEXT_CALLBACK Callback) +{ + Mock.vkDestroyDebugUtilsMessengerEXT_IgnoreBool = (char)0; + Mock.vkDestroyDebugUtilsMessengerEXT_CallbackBool = (char)1; + Mock.vkDestroyDebugUtilsMessengerEXT_CallbackFunctionPointer = Callback; +} + +void vkDestroyDebugUtilsMessengerEXT_Stub(CMOCK_vkDestroyDebugUtilsMessengerEXT_CALLBACK Callback) +{ + Mock.vkDestroyDebugUtilsMessengerEXT_IgnoreBool = (char)0; + Mock.vkDestroyDebugUtilsMessengerEXT_CallbackBool = (char)0; + Mock.vkDestroyDebugUtilsMessengerEXT_CallbackFunctionPointer = Callback; +} + +void vkDestroyDebugUtilsMessengerEXT_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyDebugUtilsMessengerEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDebugUtilsMessengerEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyDebugUtilsMessengerEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_instance = 1; +} + +void vkDestroyDebugUtilsMessengerEXT_CMockIgnoreArg_messenger(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyDebugUtilsMessengerEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDebugUtilsMessengerEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyDebugUtilsMessengerEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_messenger = 1; +} + +void vkDestroyDebugUtilsMessengerEXT_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyDebugUtilsMessengerEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyDebugUtilsMessengerEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyDebugUtilsMessengerEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkSubmitDebugUtilsMessageEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkSubmitDebugUtilsMessageEXT); + cmock_call_instance = (CMOCK_vkSubmitDebugUtilsMessageEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkSubmitDebugUtilsMessageEXT_CallInstance); + Mock.vkSubmitDebugUtilsMessageEXT_CallInstance = CMock_Guts_MemNext(Mock.vkSubmitDebugUtilsMessageEXT_CallInstance); + if (Mock.vkSubmitDebugUtilsMessageEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkSubmitDebugUtilsMessageEXT_CallbackBool && + Mock.vkSubmitDebugUtilsMessageEXT_CallbackFunctionPointer != NULL) + { + Mock.vkSubmitDebugUtilsMessageEXT_CallbackFunctionPointer(instance, messageSeverity, messageTypes, pCallbackData, Mock.vkSubmitDebugUtilsMessageEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_instance) + { + UNITY_SET_DETAILS(CMockString_vkSubmitDebugUtilsMessageEXT,CMockString_instance); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), sizeof(VkInstance), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_messageSeverity) + { + UNITY_SET_DETAILS(CMockString_vkSubmitDebugUtilsMessageEXT,CMockString_messageSeverity); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_messageSeverity), (void*)(&messageSeverity), sizeof(VkDebugUtilsMessageSeverityFlagBitsEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_messageTypes) + { + UNITY_SET_DETAILS(CMockString_vkSubmitDebugUtilsMessageEXT,CMockString_messageTypes); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_messageTypes), (void*)(&messageTypes), sizeof(VkDebugUtilsMessageTypeFlagsEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCallbackData) + { + UNITY_SET_DETAILS(CMockString_vkSubmitDebugUtilsMessageEXT,CMockString_pCallbackData); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCallbackData), (void*)(pCallbackData), sizeof(const VkDebugUtilsMessengerCallbackDataEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkSubmitDebugUtilsMessageEXT_CallbackFunctionPointer != NULL) + { + Mock.vkSubmitDebugUtilsMessageEXT_CallbackFunctionPointer(instance, messageSeverity, messageTypes, pCallbackData, Mock.vkSubmitDebugUtilsMessageEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkSubmitDebugUtilsMessageEXT(CMOCK_vkSubmitDebugUtilsMessageEXT_CALL_INSTANCE* cmock_call_instance, VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); +void CMockExpectParameters_vkSubmitDebugUtilsMessageEXT(CMOCK_vkSubmitDebugUtilsMessageEXT_CALL_INSTANCE* cmock_call_instance, VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) +{ + memcpy((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), + sizeof(VkInstance[sizeof(instance) == sizeof(VkInstance) ? 1 : -1])); /* add VkInstance to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_instance = 0; + memcpy((void*)(&cmock_call_instance->Expected_messageSeverity), (void*)(&messageSeverity), + sizeof(VkDebugUtilsMessageSeverityFlagBitsEXT[sizeof(messageSeverity) == sizeof(VkDebugUtilsMessageSeverityFlagBitsEXT) ? 1 : -1])); /* add VkDebugUtilsMessageSeverityFlagBitsEXT to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_messageSeverity = 0; + memcpy((void*)(&cmock_call_instance->Expected_messageTypes), (void*)(&messageTypes), + sizeof(VkDebugUtilsMessageTypeFlagsEXT[sizeof(messageTypes) == sizeof(VkDebugUtilsMessageTypeFlagsEXT) ? 1 : -1])); /* add VkDebugUtilsMessageTypeFlagsEXT to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_messageTypes = 0; + cmock_call_instance->Expected_pCallbackData = pCallbackData; + cmock_call_instance->IgnoreArg_pCallbackData = 0; +} + +void vkSubmitDebugUtilsMessageEXT_CMockIgnore(void) +{ + Mock.vkSubmitDebugUtilsMessageEXT_IgnoreBool = (char)1; +} + +void vkSubmitDebugUtilsMessageEXT_CMockStopIgnore(void) +{ + Mock.vkSubmitDebugUtilsMessageEXT_IgnoreBool = (char)0; +} + +void vkSubmitDebugUtilsMessageEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkSubmitDebugUtilsMessageEXT_CALL_INSTANCE)); + CMOCK_vkSubmitDebugUtilsMessageEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSubmitDebugUtilsMessageEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkSubmitDebugUtilsMessageEXT_CallInstance = CMock_Guts_MemChain(Mock.vkSubmitDebugUtilsMessageEXT_CallInstance, cmock_guts_index); + Mock.vkSubmitDebugUtilsMessageEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkSubmitDebugUtilsMessageEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkSubmitDebugUtilsMessageEXT_CALL_INSTANCE)); + CMOCK_vkSubmitDebugUtilsMessageEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSubmitDebugUtilsMessageEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkSubmitDebugUtilsMessageEXT_CallInstance = CMock_Guts_MemChain(Mock.vkSubmitDebugUtilsMessageEXT_CallInstance, cmock_guts_index); + Mock.vkSubmitDebugUtilsMessageEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkSubmitDebugUtilsMessageEXT(cmock_call_instance, instance, messageSeverity, messageTypes, pCallbackData); +} + +void vkSubmitDebugUtilsMessageEXT_AddCallback(CMOCK_vkSubmitDebugUtilsMessageEXT_CALLBACK Callback) +{ + Mock.vkSubmitDebugUtilsMessageEXT_IgnoreBool = (char)0; + Mock.vkSubmitDebugUtilsMessageEXT_CallbackBool = (char)1; + Mock.vkSubmitDebugUtilsMessageEXT_CallbackFunctionPointer = Callback; +} + +void vkSubmitDebugUtilsMessageEXT_Stub(CMOCK_vkSubmitDebugUtilsMessageEXT_CALLBACK Callback) +{ + Mock.vkSubmitDebugUtilsMessageEXT_IgnoreBool = (char)0; + Mock.vkSubmitDebugUtilsMessageEXT_CallbackBool = (char)0; + Mock.vkSubmitDebugUtilsMessageEXT_CallbackFunctionPointer = Callback; +} + +void vkSubmitDebugUtilsMessageEXT_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSubmitDebugUtilsMessageEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSubmitDebugUtilsMessageEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSubmitDebugUtilsMessageEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_instance = 1; +} + +void vkSubmitDebugUtilsMessageEXT_CMockIgnoreArg_messageSeverity(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSubmitDebugUtilsMessageEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSubmitDebugUtilsMessageEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSubmitDebugUtilsMessageEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_messageSeverity = 1; +} + +void vkSubmitDebugUtilsMessageEXT_CMockIgnoreArg_messageTypes(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSubmitDebugUtilsMessageEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSubmitDebugUtilsMessageEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSubmitDebugUtilsMessageEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_messageTypes = 1; +} + +void vkSubmitDebugUtilsMessageEXT_CMockIgnoreArg_pCallbackData(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSubmitDebugUtilsMessageEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSubmitDebugUtilsMessageEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSubmitDebugUtilsMessageEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCallbackData = 1; +} + +void vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetSampleLocationsEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetSampleLocationsEXT); + cmock_call_instance = (CMOCK_vkCmdSetSampleLocationsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetSampleLocationsEXT_CallInstance); + Mock.vkCmdSetSampleLocationsEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetSampleLocationsEXT_CallInstance); + if (Mock.vkCmdSetSampleLocationsEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetSampleLocationsEXT_CallbackBool && + Mock.vkCmdSetSampleLocationsEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetSampleLocationsEXT_CallbackFunctionPointer(commandBuffer, pSampleLocationsInfo, Mock.vkCmdSetSampleLocationsEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetSampleLocationsEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSampleLocationsInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetSampleLocationsEXT,CMockString_pSampleLocationsInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSampleLocationsInfo), (void*)(pSampleLocationsInfo), sizeof(const VkSampleLocationsInfoEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetSampleLocationsEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetSampleLocationsEXT_CallbackFunctionPointer(commandBuffer, pSampleLocationsInfo, Mock.vkCmdSetSampleLocationsEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetSampleLocationsEXT(CMOCK_vkCmdSetSampleLocationsEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo); +void CMockExpectParameters_vkCmdSetSampleLocationsEXT(CMOCK_vkCmdSetSampleLocationsEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pSampleLocationsInfo = pSampleLocationsInfo; + cmock_call_instance->IgnoreArg_pSampleLocationsInfo = 0; +} + +void vkCmdSetSampleLocationsEXT_CMockIgnore(void) +{ + Mock.vkCmdSetSampleLocationsEXT_IgnoreBool = (char)1; +} + +void vkCmdSetSampleLocationsEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetSampleLocationsEXT_IgnoreBool = (char)0; +} + +void vkCmdSetSampleLocationsEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetSampleLocationsEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetSampleLocationsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetSampleLocationsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetSampleLocationsEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetSampleLocationsEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetSampleLocationsEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetSampleLocationsEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetSampleLocationsEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetSampleLocationsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetSampleLocationsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetSampleLocationsEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetSampleLocationsEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetSampleLocationsEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetSampleLocationsEXT(cmock_call_instance, commandBuffer, pSampleLocationsInfo); +} + +void vkCmdSetSampleLocationsEXT_AddCallback(CMOCK_vkCmdSetSampleLocationsEXT_CALLBACK Callback) +{ + Mock.vkCmdSetSampleLocationsEXT_IgnoreBool = (char)0; + Mock.vkCmdSetSampleLocationsEXT_CallbackBool = (char)1; + Mock.vkCmdSetSampleLocationsEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetSampleLocationsEXT_Stub(CMOCK_vkCmdSetSampleLocationsEXT_CALLBACK Callback) +{ + Mock.vkCmdSetSampleLocationsEXT_IgnoreBool = (char)0; + Mock.vkCmdSetSampleLocationsEXT_CallbackBool = (char)0; + Mock.vkCmdSetSampleLocationsEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetSampleLocationsEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetSampleLocationsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetSampleLocationsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetSampleLocationsEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetSampleLocationsEXT_CMockIgnoreArg_pSampleLocationsInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetSampleLocationsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetSampleLocationsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetSampleLocationsEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSampleLocationsInfo = 1; +} + +void vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceMultisamplePropertiesEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceMultisamplePropertiesEXT); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceMultisamplePropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_CallInstance); + Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_CallInstance); + if (Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_CallbackBool && + Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_CallbackFunctionPointer(physicalDevice, samples, pMultisampleProperties, Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceMultisamplePropertiesEXT,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_samples) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceMultisamplePropertiesEXT,CMockString_samples); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_samples), (void*)(&samples), sizeof(VkSampleCountFlagBits), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMultisampleProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceMultisamplePropertiesEXT,CMockString_pMultisampleProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMultisampleProperties), (void*)(pMultisampleProperties), sizeof(VkMultisamplePropertiesEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_CallbackFunctionPointer != NULL) + { + Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_CallbackFunctionPointer(physicalDevice, samples, pMultisampleProperties, Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pMultisampleProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pMultisampleProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pMultisampleProperties, (const void*)cmock_call_instance->ReturnThruPtr_pMultisampleProperties_Val, + cmock_call_instance->ReturnThruPtr_pMultisampleProperties_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetPhysicalDeviceMultisamplePropertiesEXT(CMOCK_vkGetPhysicalDeviceMultisamplePropertiesEXT_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties); +void CMockExpectParameters_vkGetPhysicalDeviceMultisamplePropertiesEXT(CMOCK_vkGetPhysicalDeviceMultisamplePropertiesEXT_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + memcpy((void*)(&cmock_call_instance->Expected_samples), (void*)(&samples), + sizeof(VkSampleCountFlagBits[sizeof(samples) == sizeof(VkSampleCountFlagBits) ? 1 : -1])); /* add VkSampleCountFlagBits to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_samples = 0; + cmock_call_instance->Expected_pMultisampleProperties = pMultisampleProperties; + cmock_call_instance->IgnoreArg_pMultisampleProperties = 0; + cmock_call_instance->ReturnThruPtr_pMultisampleProperties_Used = 0; +} + +void vkGetPhysicalDeviceMultisamplePropertiesEXT_CMockIgnore(void) +{ + Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceMultisamplePropertiesEXT_CMockStopIgnore(void) +{ + Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceMultisamplePropertiesEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceMultisamplePropertiesEXT_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceMultisamplePropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceMultisamplePropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceMultisamplePropertiesEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceMultisamplePropertiesEXT_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceMultisamplePropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceMultisamplePropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceMultisamplePropertiesEXT(cmock_call_instance, physicalDevice, samples, pMultisampleProperties); +} + +void vkGetPhysicalDeviceMultisamplePropertiesEXT_AddCallback(CMOCK_vkGetPhysicalDeviceMultisamplePropertiesEXT_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceMultisamplePropertiesEXT_Stub(CMOCK_vkGetPhysicalDeviceMultisamplePropertiesEXT_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceMultisamplePropertiesEXT_CMockReturnMemThruPtr_pMultisampleProperties(UNITY_LINE_TYPE cmock_line, VkMultisamplePropertiesEXT const* pMultisampleProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceMultisamplePropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceMultisamplePropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pMultisampleProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pMultisampleProperties_Val = pMultisampleProperties; + cmock_call_instance->ReturnThruPtr_pMultisampleProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceMultisamplePropertiesEXT_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceMultisamplePropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceMultisamplePropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceMultisamplePropertiesEXT_CMockIgnoreArg_samples(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceMultisamplePropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceMultisamplePropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_samples = 1; +} + +void vkGetPhysicalDeviceMultisamplePropertiesEXT_CMockIgnoreArg_pMultisampleProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceMultisamplePropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceMultisamplePropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceMultisamplePropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMultisampleProperties = 1; +} + +VkResult vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetImageDrmFormatModifierPropertiesEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetImageDrmFormatModifierPropertiesEXT); + cmock_call_instance = (CMOCK_vkGetImageDrmFormatModifierPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetImageDrmFormatModifierPropertiesEXT_CallInstance); + Mock.vkGetImageDrmFormatModifierPropertiesEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetImageDrmFormatModifierPropertiesEXT_CallInstance); + if (Mock.vkGetImageDrmFormatModifierPropertiesEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetImageDrmFormatModifierPropertiesEXT_FinalReturn; + memcpy((void*)(&Mock.vkGetImageDrmFormatModifierPropertiesEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetImageDrmFormatModifierPropertiesEXT_CallbackBool && + Mock.vkGetImageDrmFormatModifierPropertiesEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetImageDrmFormatModifierPropertiesEXT_CallbackFunctionPointer(device, image, pProperties, Mock.vkGetImageDrmFormatModifierPropertiesEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetImageDrmFormatModifierPropertiesEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_image) + { + UNITY_SET_DETAILS(CMockString_vkGetImageDrmFormatModifierPropertiesEXT,CMockString_image); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_image), (void*)(&image), sizeof(VkImage), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetImageDrmFormatModifierPropertiesEXT,CMockString_pProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pProperties), (void*)(pProperties), sizeof(VkImageDrmFormatModifierPropertiesEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetImageDrmFormatModifierPropertiesEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetImageDrmFormatModifierPropertiesEXT_CallbackFunctionPointer(device, image, pProperties, Mock.vkGetImageDrmFormatModifierPropertiesEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pProperties, (const void*)cmock_call_instance->ReturnThruPtr_pProperties_Val, + cmock_call_instance->ReturnThruPtr_pProperties_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetImageDrmFormatModifierPropertiesEXT(CMOCK_vkGetImageDrmFormatModifierPropertiesEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties); +void CMockExpectParameters_vkGetImageDrmFormatModifierPropertiesEXT(CMOCK_vkGetImageDrmFormatModifierPropertiesEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_image), (void*)(&image), + sizeof(VkImage[sizeof(image) == sizeof(VkImage) ? 1 : -1])); /* add VkImage to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_image = 0; + cmock_call_instance->Expected_pProperties = pProperties; + cmock_call_instance->IgnoreArg_pProperties = 0; + cmock_call_instance->ReturnThruPtr_pProperties_Used = 0; +} + +void vkGetImageDrmFormatModifierPropertiesEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageDrmFormatModifierPropertiesEXT_CALL_INSTANCE)); + CMOCK_vkGetImageDrmFormatModifierPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageDrmFormatModifierPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageDrmFormatModifierPropertiesEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageDrmFormatModifierPropertiesEXT_CallInstance, cmock_guts_index); + Mock.vkGetImageDrmFormatModifierPropertiesEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetImageDrmFormatModifierPropertiesEXT_IgnoreBool = (char)1; +} + +void vkGetImageDrmFormatModifierPropertiesEXT_CMockStopIgnore(void) +{ + if(Mock.vkGetImageDrmFormatModifierPropertiesEXT_IgnoreBool) + Mock.vkGetImageDrmFormatModifierPropertiesEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetImageDrmFormatModifierPropertiesEXT_CallInstance); + Mock.vkGetImageDrmFormatModifierPropertiesEXT_IgnoreBool = (char)0; +} + +void vkGetImageDrmFormatModifierPropertiesEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageDrmFormatModifierPropertiesEXT_CALL_INSTANCE)); + CMOCK_vkGetImageDrmFormatModifierPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageDrmFormatModifierPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageDrmFormatModifierPropertiesEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageDrmFormatModifierPropertiesEXT_CallInstance, cmock_guts_index); + Mock.vkGetImageDrmFormatModifierPropertiesEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetImageDrmFormatModifierPropertiesEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageDrmFormatModifierPropertiesEXT_CALL_INSTANCE)); + CMOCK_vkGetImageDrmFormatModifierPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageDrmFormatModifierPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageDrmFormatModifierPropertiesEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageDrmFormatModifierPropertiesEXT_CallInstance, cmock_guts_index); + Mock.vkGetImageDrmFormatModifierPropertiesEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetImageDrmFormatModifierPropertiesEXT(cmock_call_instance, device, image, pProperties); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetImageDrmFormatModifierPropertiesEXT_AddCallback(CMOCK_vkGetImageDrmFormatModifierPropertiesEXT_CALLBACK Callback) +{ + Mock.vkGetImageDrmFormatModifierPropertiesEXT_IgnoreBool = (char)0; + Mock.vkGetImageDrmFormatModifierPropertiesEXT_CallbackBool = (char)1; + Mock.vkGetImageDrmFormatModifierPropertiesEXT_CallbackFunctionPointer = Callback; +} + +void vkGetImageDrmFormatModifierPropertiesEXT_Stub(CMOCK_vkGetImageDrmFormatModifierPropertiesEXT_CALLBACK Callback) +{ + Mock.vkGetImageDrmFormatModifierPropertiesEXT_IgnoreBool = (char)0; + Mock.vkGetImageDrmFormatModifierPropertiesEXT_CallbackBool = (char)0; + Mock.vkGetImageDrmFormatModifierPropertiesEXT_CallbackFunctionPointer = Callback; +} + +void vkGetImageDrmFormatModifierPropertiesEXT_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkImageDrmFormatModifierPropertiesEXT const* pProperties, size_t cmock_size) +{ + CMOCK_vkGetImageDrmFormatModifierPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageDrmFormatModifierPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageDrmFormatModifierPropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pProperties_Val = pProperties; + cmock_call_instance->ReturnThruPtr_pProperties_Size = cmock_size; +} + +void vkGetImageDrmFormatModifierPropertiesEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageDrmFormatModifierPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageDrmFormatModifierPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageDrmFormatModifierPropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetImageDrmFormatModifierPropertiesEXT_CMockIgnoreArg_image(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageDrmFormatModifierPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageDrmFormatModifierPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageDrmFormatModifierPropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_image = 1; +} + +void vkGetImageDrmFormatModifierPropertiesEXT_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageDrmFormatModifierPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageDrmFormatModifierPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageDrmFormatModifierPropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pProperties = 1; +} + +VkResult vkCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateValidationCacheEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateValidationCacheEXT); + cmock_call_instance = (CMOCK_vkCreateValidationCacheEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateValidationCacheEXT_CallInstance); + Mock.vkCreateValidationCacheEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCreateValidationCacheEXT_CallInstance); + if (Mock.vkCreateValidationCacheEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateValidationCacheEXT_FinalReturn; + memcpy((void*)(&Mock.vkCreateValidationCacheEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateValidationCacheEXT_CallbackBool && + Mock.vkCreateValidationCacheEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateValidationCacheEXT_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pValidationCache, Mock.vkCreateValidationCacheEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateValidationCacheEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateValidationCacheEXT,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkValidationCacheCreateInfoEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateValidationCacheEXT,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pValidationCache) + { + UNITY_SET_DETAILS(CMockString_vkCreateValidationCacheEXT,CMockString_pValidationCache); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pValidationCache), (void*)(pValidationCache), sizeof(VkValidationCacheEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateValidationCacheEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateValidationCacheEXT_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pValidationCache, Mock.vkCreateValidationCacheEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pValidationCache_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pValidationCache, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pValidationCache, (const void*)cmock_call_instance->ReturnThruPtr_pValidationCache_Val, + cmock_call_instance->ReturnThruPtr_pValidationCache_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateValidationCacheEXT(CMOCK_vkCreateValidationCacheEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache); +void CMockExpectParameters_vkCreateValidationCacheEXT(CMOCK_vkCreateValidationCacheEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pValidationCache = pValidationCache; + cmock_call_instance->IgnoreArg_pValidationCache = 0; + cmock_call_instance->ReturnThruPtr_pValidationCache_Used = 0; +} + +void vkCreateValidationCacheEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateValidationCacheEXT_CALL_INSTANCE)); + CMOCK_vkCreateValidationCacheEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateValidationCacheEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateValidationCacheEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCreateValidationCacheEXT_CallInstance, cmock_guts_index); + Mock.vkCreateValidationCacheEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateValidationCacheEXT_IgnoreBool = (char)1; +} + +void vkCreateValidationCacheEXT_CMockStopIgnore(void) +{ + if(Mock.vkCreateValidationCacheEXT_IgnoreBool) + Mock.vkCreateValidationCacheEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCreateValidationCacheEXT_CallInstance); + Mock.vkCreateValidationCacheEXT_IgnoreBool = (char)0; +} + +void vkCreateValidationCacheEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateValidationCacheEXT_CALL_INSTANCE)); + CMOCK_vkCreateValidationCacheEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateValidationCacheEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateValidationCacheEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCreateValidationCacheEXT_CallInstance, cmock_guts_index); + Mock.vkCreateValidationCacheEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateValidationCacheEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateValidationCacheEXT_CALL_INSTANCE)); + CMOCK_vkCreateValidationCacheEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateValidationCacheEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateValidationCacheEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCreateValidationCacheEXT_CallInstance, cmock_guts_index); + Mock.vkCreateValidationCacheEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateValidationCacheEXT(cmock_call_instance, device, pCreateInfo, pAllocator, pValidationCache); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateValidationCacheEXT_AddCallback(CMOCK_vkCreateValidationCacheEXT_CALLBACK Callback) +{ + Mock.vkCreateValidationCacheEXT_IgnoreBool = (char)0; + Mock.vkCreateValidationCacheEXT_CallbackBool = (char)1; + Mock.vkCreateValidationCacheEXT_CallbackFunctionPointer = Callback; +} + +void vkCreateValidationCacheEXT_Stub(CMOCK_vkCreateValidationCacheEXT_CALLBACK Callback) +{ + Mock.vkCreateValidationCacheEXT_IgnoreBool = (char)0; + Mock.vkCreateValidationCacheEXT_CallbackBool = (char)0; + Mock.vkCreateValidationCacheEXT_CallbackFunctionPointer = Callback; +} + +void vkCreateValidationCacheEXT_CMockReturnMemThruPtr_pValidationCache(UNITY_LINE_TYPE cmock_line, VkValidationCacheEXT const* pValidationCache, size_t cmock_size) +{ + CMOCK_vkCreateValidationCacheEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateValidationCacheEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateValidationCacheEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pValidationCache_Used = 1; + cmock_call_instance->ReturnThruPtr_pValidationCache_Val = pValidationCache; + cmock_call_instance->ReturnThruPtr_pValidationCache_Size = cmock_size; +} + +void vkCreateValidationCacheEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateValidationCacheEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateValidationCacheEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateValidationCacheEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateValidationCacheEXT_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateValidationCacheEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateValidationCacheEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateValidationCacheEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateValidationCacheEXT_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateValidationCacheEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateValidationCacheEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateValidationCacheEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateValidationCacheEXT_CMockIgnoreArg_pValidationCache(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateValidationCacheEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateValidationCacheEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateValidationCacheEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pValidationCache = 1; +} + +void vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyValidationCacheEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyValidationCacheEXT); + cmock_call_instance = (CMOCK_vkDestroyValidationCacheEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyValidationCacheEXT_CallInstance); + Mock.vkDestroyValidationCacheEXT_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyValidationCacheEXT_CallInstance); + if (Mock.vkDestroyValidationCacheEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyValidationCacheEXT_CallbackBool && + Mock.vkDestroyValidationCacheEXT_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyValidationCacheEXT_CallbackFunctionPointer(device, validationCache, pAllocator, Mock.vkDestroyValidationCacheEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyValidationCacheEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_validationCache) + { + UNITY_SET_DETAILS(CMockString_vkDestroyValidationCacheEXT,CMockString_validationCache); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_validationCache), (void*)(&validationCache), sizeof(VkValidationCacheEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyValidationCacheEXT,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyValidationCacheEXT_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyValidationCacheEXT_CallbackFunctionPointer(device, validationCache, pAllocator, Mock.vkDestroyValidationCacheEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyValidationCacheEXT(CMOCK_vkDestroyValidationCacheEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyValidationCacheEXT(CMOCK_vkDestroyValidationCacheEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_validationCache), (void*)(&validationCache), + sizeof(VkValidationCacheEXT[sizeof(validationCache) == sizeof(VkValidationCacheEXT) ? 1 : -1])); /* add VkValidationCacheEXT to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_validationCache = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyValidationCacheEXT_CMockIgnore(void) +{ + Mock.vkDestroyValidationCacheEXT_IgnoreBool = (char)1; +} + +void vkDestroyValidationCacheEXT_CMockStopIgnore(void) +{ + Mock.vkDestroyValidationCacheEXT_IgnoreBool = (char)0; +} + +void vkDestroyValidationCacheEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyValidationCacheEXT_CALL_INSTANCE)); + CMOCK_vkDestroyValidationCacheEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyValidationCacheEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyValidationCacheEXT_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyValidationCacheEXT_CallInstance, cmock_guts_index); + Mock.vkDestroyValidationCacheEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyValidationCacheEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyValidationCacheEXT_CALL_INSTANCE)); + CMOCK_vkDestroyValidationCacheEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyValidationCacheEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyValidationCacheEXT_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyValidationCacheEXT_CallInstance, cmock_guts_index); + Mock.vkDestroyValidationCacheEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyValidationCacheEXT(cmock_call_instance, device, validationCache, pAllocator); +} + +void vkDestroyValidationCacheEXT_AddCallback(CMOCK_vkDestroyValidationCacheEXT_CALLBACK Callback) +{ + Mock.vkDestroyValidationCacheEXT_IgnoreBool = (char)0; + Mock.vkDestroyValidationCacheEXT_CallbackBool = (char)1; + Mock.vkDestroyValidationCacheEXT_CallbackFunctionPointer = Callback; +} + +void vkDestroyValidationCacheEXT_Stub(CMOCK_vkDestroyValidationCacheEXT_CALLBACK Callback) +{ + Mock.vkDestroyValidationCacheEXT_IgnoreBool = (char)0; + Mock.vkDestroyValidationCacheEXT_CallbackBool = (char)0; + Mock.vkDestroyValidationCacheEXT_CallbackFunctionPointer = Callback; +} + +void vkDestroyValidationCacheEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyValidationCacheEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyValidationCacheEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyValidationCacheEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyValidationCacheEXT_CMockIgnoreArg_validationCache(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyValidationCacheEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyValidationCacheEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyValidationCacheEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_validationCache = 1; +} + +void vkDestroyValidationCacheEXT_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyValidationCacheEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyValidationCacheEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyValidationCacheEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +VkResult vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkMergeValidationCachesEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkMergeValidationCachesEXT); + cmock_call_instance = (CMOCK_vkMergeValidationCachesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkMergeValidationCachesEXT_CallInstance); + Mock.vkMergeValidationCachesEXT_CallInstance = CMock_Guts_MemNext(Mock.vkMergeValidationCachesEXT_CallInstance); + if (Mock.vkMergeValidationCachesEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkMergeValidationCachesEXT_FinalReturn; + memcpy((void*)(&Mock.vkMergeValidationCachesEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkMergeValidationCachesEXT_CallbackBool && + Mock.vkMergeValidationCachesEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkMergeValidationCachesEXT_CallbackFunctionPointer(device, dstCache, srcCacheCount, pSrcCaches, Mock.vkMergeValidationCachesEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkMergeValidationCachesEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dstCache) + { + UNITY_SET_DETAILS(CMockString_vkMergeValidationCachesEXT,CMockString_dstCache); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dstCache), (void*)(&dstCache), sizeof(VkValidationCacheEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_srcCacheCount) + { + UNITY_SET_DETAILS(CMockString_vkMergeValidationCachesEXT,CMockString_srcCacheCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_srcCacheCount, srcCacheCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSrcCaches) + { + UNITY_SET_DETAILS(CMockString_vkMergeValidationCachesEXT,CMockString_pSrcCaches); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSrcCaches), (void*)(pSrcCaches), sizeof(const VkValidationCacheEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkMergeValidationCachesEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkMergeValidationCachesEXT_CallbackFunctionPointer(device, dstCache, srcCacheCount, pSrcCaches, Mock.vkMergeValidationCachesEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkMergeValidationCachesEXT(CMOCK_vkMergeValidationCachesEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches); +void CMockExpectParameters_vkMergeValidationCachesEXT(CMOCK_vkMergeValidationCachesEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_dstCache), (void*)(&dstCache), + sizeof(VkValidationCacheEXT[sizeof(dstCache) == sizeof(VkValidationCacheEXT) ? 1 : -1])); /* add VkValidationCacheEXT to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dstCache = 0; + cmock_call_instance->Expected_srcCacheCount = srcCacheCount; + cmock_call_instance->IgnoreArg_srcCacheCount = 0; + cmock_call_instance->Expected_pSrcCaches = pSrcCaches; + cmock_call_instance->IgnoreArg_pSrcCaches = 0; +} + +void vkMergeValidationCachesEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkMergeValidationCachesEXT_CALL_INSTANCE)); + CMOCK_vkMergeValidationCachesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMergeValidationCachesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkMergeValidationCachesEXT_CallInstance = CMock_Guts_MemChain(Mock.vkMergeValidationCachesEXT_CallInstance, cmock_guts_index); + Mock.vkMergeValidationCachesEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkMergeValidationCachesEXT_IgnoreBool = (char)1; +} + +void vkMergeValidationCachesEXT_CMockStopIgnore(void) +{ + if(Mock.vkMergeValidationCachesEXT_IgnoreBool) + Mock.vkMergeValidationCachesEXT_CallInstance = CMock_Guts_MemNext(Mock.vkMergeValidationCachesEXT_CallInstance); + Mock.vkMergeValidationCachesEXT_IgnoreBool = (char)0; +} + +void vkMergeValidationCachesEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkMergeValidationCachesEXT_CALL_INSTANCE)); + CMOCK_vkMergeValidationCachesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMergeValidationCachesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkMergeValidationCachesEXT_CallInstance = CMock_Guts_MemChain(Mock.vkMergeValidationCachesEXT_CallInstance, cmock_guts_index); + Mock.vkMergeValidationCachesEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkMergeValidationCachesEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkMergeValidationCachesEXT_CALL_INSTANCE)); + CMOCK_vkMergeValidationCachesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMergeValidationCachesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkMergeValidationCachesEXT_CallInstance = CMock_Guts_MemChain(Mock.vkMergeValidationCachesEXT_CallInstance, cmock_guts_index); + Mock.vkMergeValidationCachesEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkMergeValidationCachesEXT(cmock_call_instance, device, dstCache, srcCacheCount, pSrcCaches); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkMergeValidationCachesEXT_AddCallback(CMOCK_vkMergeValidationCachesEXT_CALLBACK Callback) +{ + Mock.vkMergeValidationCachesEXT_IgnoreBool = (char)0; + Mock.vkMergeValidationCachesEXT_CallbackBool = (char)1; + Mock.vkMergeValidationCachesEXT_CallbackFunctionPointer = Callback; +} + +void vkMergeValidationCachesEXT_Stub(CMOCK_vkMergeValidationCachesEXT_CALLBACK Callback) +{ + Mock.vkMergeValidationCachesEXT_IgnoreBool = (char)0; + Mock.vkMergeValidationCachesEXT_CallbackBool = (char)0; + Mock.vkMergeValidationCachesEXT_CallbackFunctionPointer = Callback; +} + +void vkMergeValidationCachesEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkMergeValidationCachesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMergeValidationCachesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkMergeValidationCachesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkMergeValidationCachesEXT_CMockIgnoreArg_dstCache(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkMergeValidationCachesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMergeValidationCachesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkMergeValidationCachesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dstCache = 1; +} + +void vkMergeValidationCachesEXT_CMockIgnoreArg_srcCacheCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkMergeValidationCachesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMergeValidationCachesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkMergeValidationCachesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_srcCacheCount = 1; +} + +void vkMergeValidationCachesEXT_CMockIgnoreArg_pSrcCaches(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkMergeValidationCachesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkMergeValidationCachesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkMergeValidationCachesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSrcCaches = 1; +} + +VkResult vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetValidationCacheDataEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetValidationCacheDataEXT); + cmock_call_instance = (CMOCK_vkGetValidationCacheDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetValidationCacheDataEXT_CallInstance); + Mock.vkGetValidationCacheDataEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetValidationCacheDataEXT_CallInstance); + if (Mock.vkGetValidationCacheDataEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetValidationCacheDataEXT_FinalReturn; + memcpy((void*)(&Mock.vkGetValidationCacheDataEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetValidationCacheDataEXT_CallbackBool && + Mock.vkGetValidationCacheDataEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetValidationCacheDataEXT_CallbackFunctionPointer(device, validationCache, pDataSize, pData, Mock.vkGetValidationCacheDataEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetValidationCacheDataEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_validationCache) + { + UNITY_SET_DETAILS(CMockString_vkGetValidationCacheDataEXT,CMockString_validationCache); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_validationCache), (void*)(&validationCache), sizeof(VkValidationCacheEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDataSize) + { + UNITY_SET_DETAILS(CMockString_vkGetValidationCacheDataEXT,CMockString_pDataSize); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDataSize), (void*)(pDataSize), sizeof(size_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pData) + { + UNITY_SET_DETAILS(CMockString_vkGetValidationCacheDataEXT,CMockString_pData); + if (cmock_call_instance->Expected_pData == NULL) + { UNITY_TEST_ASSERT_NULL(pData, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(cmock_call_instance->Expected_pData, pData, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkGetValidationCacheDataEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetValidationCacheDataEXT_CallbackFunctionPointer(device, validationCache, pDataSize, pData, Mock.vkGetValidationCacheDataEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pDataSize_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pDataSize, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pDataSize, (const void*)cmock_call_instance->ReturnThruPtr_pDataSize_Val, + cmock_call_instance->ReturnThruPtr_pDataSize_Size); + } + if (cmock_call_instance->ReturnThruPtr_pData_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pData, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pData, (const void*)cmock_call_instance->ReturnThruPtr_pData_Val, + cmock_call_instance->ReturnThruPtr_pData_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetValidationCacheDataEXT(CMOCK_vkGetValidationCacheDataEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData); +void CMockExpectParameters_vkGetValidationCacheDataEXT(CMOCK_vkGetValidationCacheDataEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_validationCache), (void*)(&validationCache), + sizeof(VkValidationCacheEXT[sizeof(validationCache) == sizeof(VkValidationCacheEXT) ? 1 : -1])); /* add VkValidationCacheEXT to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_validationCache = 0; + cmock_call_instance->Expected_pDataSize = pDataSize; + cmock_call_instance->IgnoreArg_pDataSize = 0; + cmock_call_instance->ReturnThruPtr_pDataSize_Used = 0; + cmock_call_instance->Expected_pData = pData; + cmock_call_instance->IgnoreArg_pData = 0; + cmock_call_instance->ReturnThruPtr_pData_Used = 0; +} + +void vkGetValidationCacheDataEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetValidationCacheDataEXT_CALL_INSTANCE)); + CMOCK_vkGetValidationCacheDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetValidationCacheDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetValidationCacheDataEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetValidationCacheDataEXT_CallInstance, cmock_guts_index); + Mock.vkGetValidationCacheDataEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetValidationCacheDataEXT_IgnoreBool = (char)1; +} + +void vkGetValidationCacheDataEXT_CMockStopIgnore(void) +{ + if(Mock.vkGetValidationCacheDataEXT_IgnoreBool) + Mock.vkGetValidationCacheDataEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetValidationCacheDataEXT_CallInstance); + Mock.vkGetValidationCacheDataEXT_IgnoreBool = (char)0; +} + +void vkGetValidationCacheDataEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetValidationCacheDataEXT_CALL_INSTANCE)); + CMOCK_vkGetValidationCacheDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetValidationCacheDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetValidationCacheDataEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetValidationCacheDataEXT_CallInstance, cmock_guts_index); + Mock.vkGetValidationCacheDataEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetValidationCacheDataEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetValidationCacheDataEXT_CALL_INSTANCE)); + CMOCK_vkGetValidationCacheDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetValidationCacheDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetValidationCacheDataEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetValidationCacheDataEXT_CallInstance, cmock_guts_index); + Mock.vkGetValidationCacheDataEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetValidationCacheDataEXT(cmock_call_instance, device, validationCache, pDataSize, pData); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetValidationCacheDataEXT_AddCallback(CMOCK_vkGetValidationCacheDataEXT_CALLBACK Callback) +{ + Mock.vkGetValidationCacheDataEXT_IgnoreBool = (char)0; + Mock.vkGetValidationCacheDataEXT_CallbackBool = (char)1; + Mock.vkGetValidationCacheDataEXT_CallbackFunctionPointer = Callback; +} + +void vkGetValidationCacheDataEXT_Stub(CMOCK_vkGetValidationCacheDataEXT_CALLBACK Callback) +{ + Mock.vkGetValidationCacheDataEXT_IgnoreBool = (char)0; + Mock.vkGetValidationCacheDataEXT_CallbackBool = (char)0; + Mock.vkGetValidationCacheDataEXT_CallbackFunctionPointer = Callback; +} + +void vkGetValidationCacheDataEXT_CMockReturnMemThruPtr_pDataSize(UNITY_LINE_TYPE cmock_line, size_t const* pDataSize, size_t cmock_size) +{ + CMOCK_vkGetValidationCacheDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetValidationCacheDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetValidationCacheDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pDataSize_Used = 1; + cmock_call_instance->ReturnThruPtr_pDataSize_Val = pDataSize; + cmock_call_instance->ReturnThruPtr_pDataSize_Size = cmock_size; +} + +void vkGetValidationCacheDataEXT_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, void const* pData, size_t cmock_size) +{ + CMOCK_vkGetValidationCacheDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetValidationCacheDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetValidationCacheDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pData_Used = 1; + cmock_call_instance->ReturnThruPtr_pData_Val = pData; + cmock_call_instance->ReturnThruPtr_pData_Size = cmock_size; +} + +void vkGetValidationCacheDataEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetValidationCacheDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetValidationCacheDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetValidationCacheDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetValidationCacheDataEXT_CMockIgnoreArg_validationCache(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetValidationCacheDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetValidationCacheDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetValidationCacheDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_validationCache = 1; +} + +void vkGetValidationCacheDataEXT_CMockIgnoreArg_pDataSize(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetValidationCacheDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetValidationCacheDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetValidationCacheDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDataSize = 1; +} + +void vkGetValidationCacheDataEXT_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetValidationCacheDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetValidationCacheDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetValidationCacheDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pData = 1; +} + +void vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBindShadingRateImageNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBindShadingRateImageNV); + cmock_call_instance = (CMOCK_vkCmdBindShadingRateImageNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBindShadingRateImageNV_CallInstance); + Mock.vkCmdBindShadingRateImageNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBindShadingRateImageNV_CallInstance); + if (Mock.vkCmdBindShadingRateImageNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBindShadingRateImageNV_CallbackBool && + Mock.vkCmdBindShadingRateImageNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBindShadingRateImageNV_CallbackFunctionPointer(commandBuffer, imageView, imageLayout, Mock.vkCmdBindShadingRateImageNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindShadingRateImageNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_imageView) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindShadingRateImageNV,CMockString_imageView); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_imageView), (void*)(&imageView), sizeof(VkImageView), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_imageLayout) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindShadingRateImageNV,CMockString_imageLayout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_imageLayout), (void*)(&imageLayout), sizeof(VkImageLayout), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdBindShadingRateImageNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBindShadingRateImageNV_CallbackFunctionPointer(commandBuffer, imageView, imageLayout, Mock.vkCmdBindShadingRateImageNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBindShadingRateImageNV(CMOCK_vkCmdBindShadingRateImageNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout); +void CMockExpectParameters_vkCmdBindShadingRateImageNV(CMOCK_vkCmdBindShadingRateImageNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_imageView), (void*)(&imageView), + sizeof(VkImageView[sizeof(imageView) == sizeof(VkImageView) ? 1 : -1])); /* add VkImageView to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_imageView = 0; + memcpy((void*)(&cmock_call_instance->Expected_imageLayout), (void*)(&imageLayout), + sizeof(VkImageLayout[sizeof(imageLayout) == sizeof(VkImageLayout) ? 1 : -1])); /* add VkImageLayout to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_imageLayout = 0; +} + +void vkCmdBindShadingRateImageNV_CMockIgnore(void) +{ + Mock.vkCmdBindShadingRateImageNV_IgnoreBool = (char)1; +} + +void vkCmdBindShadingRateImageNV_CMockStopIgnore(void) +{ + Mock.vkCmdBindShadingRateImageNV_IgnoreBool = (char)0; +} + +void vkCmdBindShadingRateImageNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBindShadingRateImageNV_CALL_INSTANCE)); + CMOCK_vkCmdBindShadingRateImageNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindShadingRateImageNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBindShadingRateImageNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBindShadingRateImageNV_CallInstance, cmock_guts_index); + Mock.vkCmdBindShadingRateImageNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBindShadingRateImageNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBindShadingRateImageNV_CALL_INSTANCE)); + CMOCK_vkCmdBindShadingRateImageNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindShadingRateImageNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBindShadingRateImageNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBindShadingRateImageNV_CallInstance, cmock_guts_index); + Mock.vkCmdBindShadingRateImageNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBindShadingRateImageNV(cmock_call_instance, commandBuffer, imageView, imageLayout); +} + +void vkCmdBindShadingRateImageNV_AddCallback(CMOCK_vkCmdBindShadingRateImageNV_CALLBACK Callback) +{ + Mock.vkCmdBindShadingRateImageNV_IgnoreBool = (char)0; + Mock.vkCmdBindShadingRateImageNV_CallbackBool = (char)1; + Mock.vkCmdBindShadingRateImageNV_CallbackFunctionPointer = Callback; +} + +void vkCmdBindShadingRateImageNV_Stub(CMOCK_vkCmdBindShadingRateImageNV_CALLBACK Callback) +{ + Mock.vkCmdBindShadingRateImageNV_IgnoreBool = (char)0; + Mock.vkCmdBindShadingRateImageNV_CallbackBool = (char)0; + Mock.vkCmdBindShadingRateImageNV_CallbackFunctionPointer = Callback; +} + +void vkCmdBindShadingRateImageNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindShadingRateImageNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindShadingRateImageNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindShadingRateImageNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBindShadingRateImageNV_CMockIgnoreArg_imageView(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindShadingRateImageNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindShadingRateImageNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindShadingRateImageNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_imageView = 1; +} + +void vkCmdBindShadingRateImageNV_CMockIgnoreArg_imageLayout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindShadingRateImageNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindShadingRateImageNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindShadingRateImageNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_imageLayout = 1; +} + +void vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetViewportShadingRatePaletteNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetViewportShadingRatePaletteNV); + cmock_call_instance = (CMOCK_vkCmdSetViewportShadingRatePaletteNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetViewportShadingRatePaletteNV_CallInstance); + Mock.vkCmdSetViewportShadingRatePaletteNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetViewportShadingRatePaletteNV_CallInstance); + if (Mock.vkCmdSetViewportShadingRatePaletteNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetViewportShadingRatePaletteNV_CallbackBool && + Mock.vkCmdSetViewportShadingRatePaletteNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetViewportShadingRatePaletteNV_CallbackFunctionPointer(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes, Mock.vkCmdSetViewportShadingRatePaletteNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetViewportShadingRatePaletteNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstViewport) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetViewportShadingRatePaletteNV,CMockString_firstViewport); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstViewport, firstViewport, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_viewportCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetViewportShadingRatePaletteNV,CMockString_viewportCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_viewportCount, viewportCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pShadingRatePalettes) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetViewportShadingRatePaletteNV,CMockString_pShadingRatePalettes); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pShadingRatePalettes), (void*)(pShadingRatePalettes), sizeof(const VkShadingRatePaletteNV), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetViewportShadingRatePaletteNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetViewportShadingRatePaletteNV_CallbackFunctionPointer(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes, Mock.vkCmdSetViewportShadingRatePaletteNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetViewportShadingRatePaletteNV(CMOCK_vkCmdSetViewportShadingRatePaletteNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes); +void CMockExpectParameters_vkCmdSetViewportShadingRatePaletteNV(CMOCK_vkCmdSetViewportShadingRatePaletteNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_firstViewport = firstViewport; + cmock_call_instance->IgnoreArg_firstViewport = 0; + cmock_call_instance->Expected_viewportCount = viewportCount; + cmock_call_instance->IgnoreArg_viewportCount = 0; + cmock_call_instance->Expected_pShadingRatePalettes = pShadingRatePalettes; + cmock_call_instance->IgnoreArg_pShadingRatePalettes = 0; +} + +void vkCmdSetViewportShadingRatePaletteNV_CMockIgnore(void) +{ + Mock.vkCmdSetViewportShadingRatePaletteNV_IgnoreBool = (char)1; +} + +void vkCmdSetViewportShadingRatePaletteNV_CMockStopIgnore(void) +{ + Mock.vkCmdSetViewportShadingRatePaletteNV_IgnoreBool = (char)0; +} + +void vkCmdSetViewportShadingRatePaletteNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetViewportShadingRatePaletteNV_CALL_INSTANCE)); + CMOCK_vkCmdSetViewportShadingRatePaletteNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportShadingRatePaletteNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetViewportShadingRatePaletteNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetViewportShadingRatePaletteNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetViewportShadingRatePaletteNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetViewportShadingRatePaletteNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetViewportShadingRatePaletteNV_CALL_INSTANCE)); + CMOCK_vkCmdSetViewportShadingRatePaletteNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportShadingRatePaletteNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetViewportShadingRatePaletteNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetViewportShadingRatePaletteNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetViewportShadingRatePaletteNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetViewportShadingRatePaletteNV(cmock_call_instance, commandBuffer, firstViewport, viewportCount, pShadingRatePalettes); +} + +void vkCmdSetViewportShadingRatePaletteNV_AddCallback(CMOCK_vkCmdSetViewportShadingRatePaletteNV_CALLBACK Callback) +{ + Mock.vkCmdSetViewportShadingRatePaletteNV_IgnoreBool = (char)0; + Mock.vkCmdSetViewportShadingRatePaletteNV_CallbackBool = (char)1; + Mock.vkCmdSetViewportShadingRatePaletteNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetViewportShadingRatePaletteNV_Stub(CMOCK_vkCmdSetViewportShadingRatePaletteNV_CALLBACK Callback) +{ + Mock.vkCmdSetViewportShadingRatePaletteNV_IgnoreBool = (char)0; + Mock.vkCmdSetViewportShadingRatePaletteNV_CallbackBool = (char)0; + Mock.vkCmdSetViewportShadingRatePaletteNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetViewportShadingRatePaletteNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetViewportShadingRatePaletteNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportShadingRatePaletteNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetViewportShadingRatePaletteNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetViewportShadingRatePaletteNV_CMockIgnoreArg_firstViewport(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetViewportShadingRatePaletteNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportShadingRatePaletteNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetViewportShadingRatePaletteNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstViewport = 1; +} + +void vkCmdSetViewportShadingRatePaletteNV_CMockIgnoreArg_viewportCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetViewportShadingRatePaletteNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportShadingRatePaletteNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetViewportShadingRatePaletteNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_viewportCount = 1; +} + +void vkCmdSetViewportShadingRatePaletteNV_CMockIgnoreArg_pShadingRatePalettes(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetViewportShadingRatePaletteNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportShadingRatePaletteNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetViewportShadingRatePaletteNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pShadingRatePalettes = 1; +} + +void vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetCoarseSampleOrderNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetCoarseSampleOrderNV); + cmock_call_instance = (CMOCK_vkCmdSetCoarseSampleOrderNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetCoarseSampleOrderNV_CallInstance); + Mock.vkCmdSetCoarseSampleOrderNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetCoarseSampleOrderNV_CallInstance); + if (Mock.vkCmdSetCoarseSampleOrderNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetCoarseSampleOrderNV_CallbackBool && + Mock.vkCmdSetCoarseSampleOrderNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetCoarseSampleOrderNV_CallbackFunctionPointer(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders, Mock.vkCmdSetCoarseSampleOrderNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetCoarseSampleOrderNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_sampleOrderType) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetCoarseSampleOrderNV,CMockString_sampleOrderType); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_sampleOrderType), (void*)(&sampleOrderType), sizeof(VkCoarseSampleOrderTypeNV), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_customSampleOrderCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetCoarseSampleOrderNV,CMockString_customSampleOrderCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_customSampleOrderCount, customSampleOrderCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCustomSampleOrders) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetCoarseSampleOrderNV,CMockString_pCustomSampleOrders); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCustomSampleOrders), (void*)(pCustomSampleOrders), sizeof(const VkCoarseSampleOrderCustomNV), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetCoarseSampleOrderNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetCoarseSampleOrderNV_CallbackFunctionPointer(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders, Mock.vkCmdSetCoarseSampleOrderNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetCoarseSampleOrderNV(CMOCK_vkCmdSetCoarseSampleOrderNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders); +void CMockExpectParameters_vkCmdSetCoarseSampleOrderNV(CMOCK_vkCmdSetCoarseSampleOrderNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_sampleOrderType), (void*)(&sampleOrderType), + sizeof(VkCoarseSampleOrderTypeNV[sizeof(sampleOrderType) == sizeof(VkCoarseSampleOrderTypeNV) ? 1 : -1])); /* add VkCoarseSampleOrderTypeNV to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_sampleOrderType = 0; + cmock_call_instance->Expected_customSampleOrderCount = customSampleOrderCount; + cmock_call_instance->IgnoreArg_customSampleOrderCount = 0; + cmock_call_instance->Expected_pCustomSampleOrders = pCustomSampleOrders; + cmock_call_instance->IgnoreArg_pCustomSampleOrders = 0; +} + +void vkCmdSetCoarseSampleOrderNV_CMockIgnore(void) +{ + Mock.vkCmdSetCoarseSampleOrderNV_IgnoreBool = (char)1; +} + +void vkCmdSetCoarseSampleOrderNV_CMockStopIgnore(void) +{ + Mock.vkCmdSetCoarseSampleOrderNV_IgnoreBool = (char)0; +} + +void vkCmdSetCoarseSampleOrderNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetCoarseSampleOrderNV_CALL_INSTANCE)); + CMOCK_vkCmdSetCoarseSampleOrderNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoarseSampleOrderNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetCoarseSampleOrderNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetCoarseSampleOrderNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetCoarseSampleOrderNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetCoarseSampleOrderNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetCoarseSampleOrderNV_CALL_INSTANCE)); + CMOCK_vkCmdSetCoarseSampleOrderNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoarseSampleOrderNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetCoarseSampleOrderNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetCoarseSampleOrderNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetCoarseSampleOrderNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetCoarseSampleOrderNV(cmock_call_instance, commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders); +} + +void vkCmdSetCoarseSampleOrderNV_AddCallback(CMOCK_vkCmdSetCoarseSampleOrderNV_CALLBACK Callback) +{ + Mock.vkCmdSetCoarseSampleOrderNV_IgnoreBool = (char)0; + Mock.vkCmdSetCoarseSampleOrderNV_CallbackBool = (char)1; + Mock.vkCmdSetCoarseSampleOrderNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetCoarseSampleOrderNV_Stub(CMOCK_vkCmdSetCoarseSampleOrderNV_CALLBACK Callback) +{ + Mock.vkCmdSetCoarseSampleOrderNV_IgnoreBool = (char)0; + Mock.vkCmdSetCoarseSampleOrderNV_CallbackBool = (char)0; + Mock.vkCmdSetCoarseSampleOrderNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetCoarseSampleOrderNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetCoarseSampleOrderNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoarseSampleOrderNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetCoarseSampleOrderNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetCoarseSampleOrderNV_CMockIgnoreArg_sampleOrderType(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetCoarseSampleOrderNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoarseSampleOrderNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetCoarseSampleOrderNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_sampleOrderType = 1; +} + +void vkCmdSetCoarseSampleOrderNV_CMockIgnoreArg_customSampleOrderCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetCoarseSampleOrderNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoarseSampleOrderNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetCoarseSampleOrderNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_customSampleOrderCount = 1; +} + +void vkCmdSetCoarseSampleOrderNV_CMockIgnoreArg_pCustomSampleOrders(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetCoarseSampleOrderNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoarseSampleOrderNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetCoarseSampleOrderNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCustomSampleOrders = 1; +} + +VkResult vkCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateAccelerationStructureNV); + cmock_call_instance = (CMOCK_vkCreateAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateAccelerationStructureNV_CallInstance); + Mock.vkCreateAccelerationStructureNV_CallInstance = CMock_Guts_MemNext(Mock.vkCreateAccelerationStructureNV_CallInstance); + if (Mock.vkCreateAccelerationStructureNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateAccelerationStructureNV_FinalReturn; + memcpy((void*)(&Mock.vkCreateAccelerationStructureNV_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateAccelerationStructureNV_CallbackBool && + Mock.vkCreateAccelerationStructureNV_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateAccelerationStructureNV_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pAccelerationStructure, Mock.vkCreateAccelerationStructureNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateAccelerationStructureNV,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateAccelerationStructureNV,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkAccelerationStructureCreateInfoNV), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateAccelerationStructureNV,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAccelerationStructure) + { + UNITY_SET_DETAILS(CMockString_vkCreateAccelerationStructureNV,CMockString_pAccelerationStructure); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAccelerationStructure), (void*)(pAccelerationStructure), sizeof(VkAccelerationStructureNV), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateAccelerationStructureNV_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateAccelerationStructureNV_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pAccelerationStructure, Mock.vkCreateAccelerationStructureNV_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pAccelerationStructure_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pAccelerationStructure, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pAccelerationStructure, (const void*)cmock_call_instance->ReturnThruPtr_pAccelerationStructure_Val, + cmock_call_instance->ReturnThruPtr_pAccelerationStructure_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateAccelerationStructureNV(CMOCK_vkCreateAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure); +void CMockExpectParameters_vkCreateAccelerationStructureNV(CMOCK_vkCreateAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pAccelerationStructure = pAccelerationStructure; + cmock_call_instance->IgnoreArg_pAccelerationStructure = 0; + cmock_call_instance->ReturnThruPtr_pAccelerationStructure_Used = 0; +} + +void vkCreateAccelerationStructureNV_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateAccelerationStructureNV_CALL_INSTANCE)); + CMOCK_vkCreateAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateAccelerationStructureNV_CallInstance = CMock_Guts_MemChain(Mock.vkCreateAccelerationStructureNV_CallInstance, cmock_guts_index); + Mock.vkCreateAccelerationStructureNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateAccelerationStructureNV_IgnoreBool = (char)1; +} + +void vkCreateAccelerationStructureNV_CMockStopIgnore(void) +{ + if(Mock.vkCreateAccelerationStructureNV_IgnoreBool) + Mock.vkCreateAccelerationStructureNV_CallInstance = CMock_Guts_MemNext(Mock.vkCreateAccelerationStructureNV_CallInstance); + Mock.vkCreateAccelerationStructureNV_IgnoreBool = (char)0; +} + +void vkCreateAccelerationStructureNV_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateAccelerationStructureNV_CALL_INSTANCE)); + CMOCK_vkCreateAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateAccelerationStructureNV_CallInstance = CMock_Guts_MemChain(Mock.vkCreateAccelerationStructureNV_CallInstance, cmock_guts_index); + Mock.vkCreateAccelerationStructureNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateAccelerationStructureNV_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateAccelerationStructureNV_CALL_INSTANCE)); + CMOCK_vkCreateAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateAccelerationStructureNV_CallInstance = CMock_Guts_MemChain(Mock.vkCreateAccelerationStructureNV_CallInstance, cmock_guts_index); + Mock.vkCreateAccelerationStructureNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateAccelerationStructureNV(cmock_call_instance, device, pCreateInfo, pAllocator, pAccelerationStructure); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateAccelerationStructureNV_AddCallback(CMOCK_vkCreateAccelerationStructureNV_CALLBACK Callback) +{ + Mock.vkCreateAccelerationStructureNV_IgnoreBool = (char)0; + Mock.vkCreateAccelerationStructureNV_CallbackBool = (char)1; + Mock.vkCreateAccelerationStructureNV_CallbackFunctionPointer = Callback; +} + +void vkCreateAccelerationStructureNV_Stub(CMOCK_vkCreateAccelerationStructureNV_CALLBACK Callback) +{ + Mock.vkCreateAccelerationStructureNV_IgnoreBool = (char)0; + Mock.vkCreateAccelerationStructureNV_CallbackBool = (char)0; + Mock.vkCreateAccelerationStructureNV_CallbackFunctionPointer = Callback; +} + +void vkCreateAccelerationStructureNV_CMockReturnMemThruPtr_pAccelerationStructure(UNITY_LINE_TYPE cmock_line, VkAccelerationStructureNV const* pAccelerationStructure, size_t cmock_size) +{ + CMOCK_vkCreateAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateAccelerationStructureNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pAccelerationStructure_Used = 1; + cmock_call_instance->ReturnThruPtr_pAccelerationStructure_Val = pAccelerationStructure; + cmock_call_instance->ReturnThruPtr_pAccelerationStructure_Size = cmock_size; +} + +void vkCreateAccelerationStructureNV_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateAccelerationStructureNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateAccelerationStructureNV_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateAccelerationStructureNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateAccelerationStructureNV_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateAccelerationStructureNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateAccelerationStructureNV_CMockIgnoreArg_pAccelerationStructure(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateAccelerationStructureNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAccelerationStructure = 1; +} + +void vkDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyAccelerationStructureNV); + cmock_call_instance = (CMOCK_vkDestroyAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyAccelerationStructureNV_CallInstance); + Mock.vkDestroyAccelerationStructureNV_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyAccelerationStructureNV_CallInstance); + if (Mock.vkDestroyAccelerationStructureNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyAccelerationStructureNV_CallbackBool && + Mock.vkDestroyAccelerationStructureNV_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyAccelerationStructureNV_CallbackFunctionPointer(device, accelerationStructure, pAllocator, Mock.vkDestroyAccelerationStructureNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyAccelerationStructureNV,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_accelerationStructure) + { + UNITY_SET_DETAILS(CMockString_vkDestroyAccelerationStructureNV,CMockString_accelerationStructure); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_accelerationStructure), (void*)(&accelerationStructure), sizeof(VkAccelerationStructureNV), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyAccelerationStructureNV,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyAccelerationStructureNV_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyAccelerationStructureNV_CallbackFunctionPointer(device, accelerationStructure, pAllocator, Mock.vkDestroyAccelerationStructureNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyAccelerationStructureNV(CMOCK_vkDestroyAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyAccelerationStructureNV(CMOCK_vkDestroyAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_accelerationStructure), (void*)(&accelerationStructure), + sizeof(VkAccelerationStructureNV[sizeof(accelerationStructure) == sizeof(VkAccelerationStructureNV) ? 1 : -1])); /* add VkAccelerationStructureNV to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_accelerationStructure = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyAccelerationStructureNV_CMockIgnore(void) +{ + Mock.vkDestroyAccelerationStructureNV_IgnoreBool = (char)1; +} + +void vkDestroyAccelerationStructureNV_CMockStopIgnore(void) +{ + Mock.vkDestroyAccelerationStructureNV_IgnoreBool = (char)0; +} + +void vkDestroyAccelerationStructureNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyAccelerationStructureNV_CALL_INSTANCE)); + CMOCK_vkDestroyAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyAccelerationStructureNV_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyAccelerationStructureNV_CallInstance, cmock_guts_index); + Mock.vkDestroyAccelerationStructureNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyAccelerationStructureNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyAccelerationStructureNV_CALL_INSTANCE)); + CMOCK_vkDestroyAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyAccelerationStructureNV_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyAccelerationStructureNV_CallInstance, cmock_guts_index); + Mock.vkDestroyAccelerationStructureNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyAccelerationStructureNV(cmock_call_instance, device, accelerationStructure, pAllocator); +} + +void vkDestroyAccelerationStructureNV_AddCallback(CMOCK_vkDestroyAccelerationStructureNV_CALLBACK Callback) +{ + Mock.vkDestroyAccelerationStructureNV_IgnoreBool = (char)0; + Mock.vkDestroyAccelerationStructureNV_CallbackBool = (char)1; + Mock.vkDestroyAccelerationStructureNV_CallbackFunctionPointer = Callback; +} + +void vkDestroyAccelerationStructureNV_Stub(CMOCK_vkDestroyAccelerationStructureNV_CALLBACK Callback) +{ + Mock.vkDestroyAccelerationStructureNV_IgnoreBool = (char)0; + Mock.vkDestroyAccelerationStructureNV_CallbackBool = (char)0; + Mock.vkDestroyAccelerationStructureNV_CallbackFunctionPointer = Callback; +} + +void vkDestroyAccelerationStructureNV_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyAccelerationStructureNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyAccelerationStructureNV_CMockIgnoreArg_accelerationStructure(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyAccelerationStructureNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_accelerationStructure = 1; +} + +void vkDestroyAccelerationStructureNV_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyAccelerationStructureNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetAccelerationStructureMemoryRequirementsNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetAccelerationStructureMemoryRequirementsNV); + cmock_call_instance = (CMOCK_vkGetAccelerationStructureMemoryRequirementsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetAccelerationStructureMemoryRequirementsNV_CallInstance); + Mock.vkGetAccelerationStructureMemoryRequirementsNV_CallInstance = CMock_Guts_MemNext(Mock.vkGetAccelerationStructureMemoryRequirementsNV_CallInstance); + if (Mock.vkGetAccelerationStructureMemoryRequirementsNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetAccelerationStructureMemoryRequirementsNV_CallbackBool && + Mock.vkGetAccelerationStructureMemoryRequirementsNV_CallbackFunctionPointer != NULL) + { + Mock.vkGetAccelerationStructureMemoryRequirementsNV_CallbackFunctionPointer(device, pInfo, pMemoryRequirements, Mock.vkGetAccelerationStructureMemoryRequirementsNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetAccelerationStructureMemoryRequirementsNV,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetAccelerationStructureMemoryRequirementsNV,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkAccelerationStructureMemoryRequirementsInfoNV), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMemoryRequirements) + { + UNITY_SET_DETAILS(CMockString_vkGetAccelerationStructureMemoryRequirementsNV,CMockString_pMemoryRequirements); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMemoryRequirements), (void*)(pMemoryRequirements), sizeof(VkMemoryRequirements2KHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetAccelerationStructureMemoryRequirementsNV_CallbackFunctionPointer != NULL) + { + Mock.vkGetAccelerationStructureMemoryRequirementsNV_CallbackFunctionPointer(device, pInfo, pMemoryRequirements, Mock.vkGetAccelerationStructureMemoryRequirementsNV_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pMemoryRequirements, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pMemoryRequirements, (const void*)cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Val, + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetAccelerationStructureMemoryRequirementsNV(CMOCK_vkGetAccelerationStructureMemoryRequirementsNV_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements); +void CMockExpectParameters_vkGetAccelerationStructureMemoryRequirementsNV(CMOCK_vkGetAccelerationStructureMemoryRequirementsNV_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; + cmock_call_instance->Expected_pMemoryRequirements = pMemoryRequirements; + cmock_call_instance->IgnoreArg_pMemoryRequirements = 0; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used = 0; +} + +void vkGetAccelerationStructureMemoryRequirementsNV_CMockIgnore(void) +{ + Mock.vkGetAccelerationStructureMemoryRequirementsNV_IgnoreBool = (char)1; +} + +void vkGetAccelerationStructureMemoryRequirementsNV_CMockStopIgnore(void) +{ + Mock.vkGetAccelerationStructureMemoryRequirementsNV_IgnoreBool = (char)0; +} + +void vkGetAccelerationStructureMemoryRequirementsNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetAccelerationStructureMemoryRequirementsNV_CALL_INSTANCE)); + CMOCK_vkGetAccelerationStructureMemoryRequirementsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureMemoryRequirementsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetAccelerationStructureMemoryRequirementsNV_CallInstance = CMock_Guts_MemChain(Mock.vkGetAccelerationStructureMemoryRequirementsNV_CallInstance, cmock_guts_index); + Mock.vkGetAccelerationStructureMemoryRequirementsNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetAccelerationStructureMemoryRequirementsNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetAccelerationStructureMemoryRequirementsNV_CALL_INSTANCE)); + CMOCK_vkGetAccelerationStructureMemoryRequirementsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureMemoryRequirementsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetAccelerationStructureMemoryRequirementsNV_CallInstance = CMock_Guts_MemChain(Mock.vkGetAccelerationStructureMemoryRequirementsNV_CallInstance, cmock_guts_index); + Mock.vkGetAccelerationStructureMemoryRequirementsNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetAccelerationStructureMemoryRequirementsNV(cmock_call_instance, device, pInfo, pMemoryRequirements); +} + +void vkGetAccelerationStructureMemoryRequirementsNV_AddCallback(CMOCK_vkGetAccelerationStructureMemoryRequirementsNV_CALLBACK Callback) +{ + Mock.vkGetAccelerationStructureMemoryRequirementsNV_IgnoreBool = (char)0; + Mock.vkGetAccelerationStructureMemoryRequirementsNV_CallbackBool = (char)1; + Mock.vkGetAccelerationStructureMemoryRequirementsNV_CallbackFunctionPointer = Callback; +} + +void vkGetAccelerationStructureMemoryRequirementsNV_Stub(CMOCK_vkGetAccelerationStructureMemoryRequirementsNV_CALLBACK Callback) +{ + Mock.vkGetAccelerationStructureMemoryRequirementsNV_IgnoreBool = (char)0; + Mock.vkGetAccelerationStructureMemoryRequirementsNV_CallbackBool = (char)0; + Mock.vkGetAccelerationStructureMemoryRequirementsNV_CallbackFunctionPointer = Callback; +} + +void vkGetAccelerationStructureMemoryRequirementsNV_CMockReturnMemThruPtr_pMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkMemoryRequirements2KHR const* pMemoryRequirements, size_t cmock_size) +{ + CMOCK_vkGetAccelerationStructureMemoryRequirementsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureMemoryRequirementsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetAccelerationStructureMemoryRequirementsNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used = 1; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Val = pMemoryRequirements; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Size = cmock_size; +} + +void vkGetAccelerationStructureMemoryRequirementsNV_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetAccelerationStructureMemoryRequirementsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureMemoryRequirementsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetAccelerationStructureMemoryRequirementsNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetAccelerationStructureMemoryRequirementsNV_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetAccelerationStructureMemoryRequirementsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureMemoryRequirementsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetAccelerationStructureMemoryRequirementsNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +void vkGetAccelerationStructureMemoryRequirementsNV_CMockIgnoreArg_pMemoryRequirements(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetAccelerationStructureMemoryRequirementsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureMemoryRequirementsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetAccelerationStructureMemoryRequirementsNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMemoryRequirements = 1; +} + +VkResult vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkBindAccelerationStructureMemoryNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkBindAccelerationStructureMemoryNV); + cmock_call_instance = (CMOCK_vkBindAccelerationStructureMemoryNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkBindAccelerationStructureMemoryNV_CallInstance); + Mock.vkBindAccelerationStructureMemoryNV_CallInstance = CMock_Guts_MemNext(Mock.vkBindAccelerationStructureMemoryNV_CallInstance); + if (Mock.vkBindAccelerationStructureMemoryNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkBindAccelerationStructureMemoryNV_FinalReturn; + memcpy((void*)(&Mock.vkBindAccelerationStructureMemoryNV_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkBindAccelerationStructureMemoryNV_CallbackBool && + Mock.vkBindAccelerationStructureMemoryNV_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkBindAccelerationStructureMemoryNV_CallbackFunctionPointer(device, bindInfoCount, pBindInfos, Mock.vkBindAccelerationStructureMemoryNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkBindAccelerationStructureMemoryNV,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_bindInfoCount) + { + UNITY_SET_DETAILS(CMockString_vkBindAccelerationStructureMemoryNV,CMockString_bindInfoCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_bindInfoCount, bindInfoCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pBindInfos) + { + UNITY_SET_DETAILS(CMockString_vkBindAccelerationStructureMemoryNV,CMockString_pBindInfos); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pBindInfos), (void*)(pBindInfos), sizeof(const VkBindAccelerationStructureMemoryInfoNV), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkBindAccelerationStructureMemoryNV_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkBindAccelerationStructureMemoryNV_CallbackFunctionPointer(device, bindInfoCount, pBindInfos, Mock.vkBindAccelerationStructureMemoryNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkBindAccelerationStructureMemoryNV(CMOCK_vkBindAccelerationStructureMemoryNV_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos); +void CMockExpectParameters_vkBindAccelerationStructureMemoryNV(CMOCK_vkBindAccelerationStructureMemoryNV_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_bindInfoCount = bindInfoCount; + cmock_call_instance->IgnoreArg_bindInfoCount = 0; + cmock_call_instance->Expected_pBindInfos = pBindInfos; + cmock_call_instance->IgnoreArg_pBindInfos = 0; +} + +void vkBindAccelerationStructureMemoryNV_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBindAccelerationStructureMemoryNV_CALL_INSTANCE)); + CMOCK_vkBindAccelerationStructureMemoryNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindAccelerationStructureMemoryNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBindAccelerationStructureMemoryNV_CallInstance = CMock_Guts_MemChain(Mock.vkBindAccelerationStructureMemoryNV_CallInstance, cmock_guts_index); + Mock.vkBindAccelerationStructureMemoryNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkBindAccelerationStructureMemoryNV_IgnoreBool = (char)1; +} + +void vkBindAccelerationStructureMemoryNV_CMockStopIgnore(void) +{ + if(Mock.vkBindAccelerationStructureMemoryNV_IgnoreBool) + Mock.vkBindAccelerationStructureMemoryNV_CallInstance = CMock_Guts_MemNext(Mock.vkBindAccelerationStructureMemoryNV_CallInstance); + Mock.vkBindAccelerationStructureMemoryNV_IgnoreBool = (char)0; +} + +void vkBindAccelerationStructureMemoryNV_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBindAccelerationStructureMemoryNV_CALL_INSTANCE)); + CMOCK_vkBindAccelerationStructureMemoryNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindAccelerationStructureMemoryNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBindAccelerationStructureMemoryNV_CallInstance = CMock_Guts_MemChain(Mock.vkBindAccelerationStructureMemoryNV_CallInstance, cmock_guts_index); + Mock.vkBindAccelerationStructureMemoryNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkBindAccelerationStructureMemoryNV_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBindAccelerationStructureMemoryNV_CALL_INSTANCE)); + CMOCK_vkBindAccelerationStructureMemoryNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindAccelerationStructureMemoryNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBindAccelerationStructureMemoryNV_CallInstance = CMock_Guts_MemChain(Mock.vkBindAccelerationStructureMemoryNV_CallInstance, cmock_guts_index); + Mock.vkBindAccelerationStructureMemoryNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkBindAccelerationStructureMemoryNV(cmock_call_instance, device, bindInfoCount, pBindInfos); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkBindAccelerationStructureMemoryNV_AddCallback(CMOCK_vkBindAccelerationStructureMemoryNV_CALLBACK Callback) +{ + Mock.vkBindAccelerationStructureMemoryNV_IgnoreBool = (char)0; + Mock.vkBindAccelerationStructureMemoryNV_CallbackBool = (char)1; + Mock.vkBindAccelerationStructureMemoryNV_CallbackFunctionPointer = Callback; +} + +void vkBindAccelerationStructureMemoryNV_Stub(CMOCK_vkBindAccelerationStructureMemoryNV_CALLBACK Callback) +{ + Mock.vkBindAccelerationStructureMemoryNV_IgnoreBool = (char)0; + Mock.vkBindAccelerationStructureMemoryNV_CallbackBool = (char)0; + Mock.vkBindAccelerationStructureMemoryNV_CallbackFunctionPointer = Callback; +} + +void vkBindAccelerationStructureMemoryNV_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindAccelerationStructureMemoryNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindAccelerationStructureMemoryNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindAccelerationStructureMemoryNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkBindAccelerationStructureMemoryNV_CMockIgnoreArg_bindInfoCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindAccelerationStructureMemoryNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindAccelerationStructureMemoryNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindAccelerationStructureMemoryNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_bindInfoCount = 1; +} + +void vkBindAccelerationStructureMemoryNV_CMockIgnoreArg_pBindInfos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindAccelerationStructureMemoryNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindAccelerationStructureMemoryNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindAccelerationStructureMemoryNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pBindInfos = 1; +} + +void vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBuildAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBuildAccelerationStructureNV); + cmock_call_instance = (CMOCK_vkCmdBuildAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBuildAccelerationStructureNV_CallInstance); + Mock.vkCmdBuildAccelerationStructureNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBuildAccelerationStructureNV_CallInstance); + if (Mock.vkCmdBuildAccelerationStructureNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBuildAccelerationStructureNV_CallbackBool && + Mock.vkCmdBuildAccelerationStructureNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBuildAccelerationStructureNV_CallbackFunctionPointer(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset, Mock.vkCmdBuildAccelerationStructureNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBuildAccelerationStructureNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdBuildAccelerationStructureNV,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkAccelerationStructureInfoNV), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_instanceData) + { + UNITY_SET_DETAILS(CMockString_vkCmdBuildAccelerationStructureNV,CMockString_instanceData); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_instanceData), (void*)(&instanceData), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_instanceOffset) + { + UNITY_SET_DETAILS(CMockString_vkCmdBuildAccelerationStructureNV,CMockString_instanceOffset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_instanceOffset), (void*)(&instanceOffset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_update) + { + UNITY_SET_DETAILS(CMockString_vkCmdBuildAccelerationStructureNV,CMockString_update); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_update), (void*)(&update), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dst) + { + UNITY_SET_DETAILS(CMockString_vkCmdBuildAccelerationStructureNV,CMockString_dst); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dst), (void*)(&dst), sizeof(VkAccelerationStructureNV), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_src) + { + UNITY_SET_DETAILS(CMockString_vkCmdBuildAccelerationStructureNV,CMockString_src); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_src), (void*)(&src), sizeof(VkAccelerationStructureNV), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_scratch) + { + UNITY_SET_DETAILS(CMockString_vkCmdBuildAccelerationStructureNV,CMockString_scratch); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_scratch), (void*)(&scratch), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_scratchOffset) + { + UNITY_SET_DETAILS(CMockString_vkCmdBuildAccelerationStructureNV,CMockString_scratchOffset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_scratchOffset), (void*)(&scratchOffset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdBuildAccelerationStructureNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBuildAccelerationStructureNV_CallbackFunctionPointer(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset, Mock.vkCmdBuildAccelerationStructureNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBuildAccelerationStructureNV(CMOCK_vkCmdBuildAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset); +void CMockExpectParameters_vkCmdBuildAccelerationStructureNV(CMOCK_vkCmdBuildAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; + memcpy((void*)(&cmock_call_instance->Expected_instanceData), (void*)(&instanceData), + sizeof(VkBuffer[sizeof(instanceData) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_instanceData = 0; + memcpy((void*)(&cmock_call_instance->Expected_instanceOffset), (void*)(&instanceOffset), + sizeof(VkDeviceSize[sizeof(instanceOffset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_instanceOffset = 0; + memcpy((void*)(&cmock_call_instance->Expected_update), (void*)(&update), + sizeof(VkBool32[sizeof(update) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_update = 0; + memcpy((void*)(&cmock_call_instance->Expected_dst), (void*)(&dst), + sizeof(VkAccelerationStructureNV[sizeof(dst) == sizeof(VkAccelerationStructureNV) ? 1 : -1])); /* add VkAccelerationStructureNV to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dst = 0; + memcpy((void*)(&cmock_call_instance->Expected_src), (void*)(&src), + sizeof(VkAccelerationStructureNV[sizeof(src) == sizeof(VkAccelerationStructureNV) ? 1 : -1])); /* add VkAccelerationStructureNV to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_src = 0; + memcpy((void*)(&cmock_call_instance->Expected_scratch), (void*)(&scratch), + sizeof(VkBuffer[sizeof(scratch) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_scratch = 0; + memcpy((void*)(&cmock_call_instance->Expected_scratchOffset), (void*)(&scratchOffset), + sizeof(VkDeviceSize[sizeof(scratchOffset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_scratchOffset = 0; +} + +void vkCmdBuildAccelerationStructureNV_CMockIgnore(void) +{ + Mock.vkCmdBuildAccelerationStructureNV_IgnoreBool = (char)1; +} + +void vkCmdBuildAccelerationStructureNV_CMockStopIgnore(void) +{ + Mock.vkCmdBuildAccelerationStructureNV_IgnoreBool = (char)0; +} + +void vkCmdBuildAccelerationStructureNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBuildAccelerationStructureNV_CALL_INSTANCE)); + CMOCK_vkCmdBuildAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBuildAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBuildAccelerationStructureNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBuildAccelerationStructureNV_CallInstance, cmock_guts_index); + Mock.vkCmdBuildAccelerationStructureNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBuildAccelerationStructureNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBuildAccelerationStructureNV_CALL_INSTANCE)); + CMOCK_vkCmdBuildAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBuildAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBuildAccelerationStructureNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBuildAccelerationStructureNV_CallInstance, cmock_guts_index); + Mock.vkCmdBuildAccelerationStructureNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBuildAccelerationStructureNV(cmock_call_instance, commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset); +} + +void vkCmdBuildAccelerationStructureNV_AddCallback(CMOCK_vkCmdBuildAccelerationStructureNV_CALLBACK Callback) +{ + Mock.vkCmdBuildAccelerationStructureNV_IgnoreBool = (char)0; + Mock.vkCmdBuildAccelerationStructureNV_CallbackBool = (char)1; + Mock.vkCmdBuildAccelerationStructureNV_CallbackFunctionPointer = Callback; +} + +void vkCmdBuildAccelerationStructureNV_Stub(CMOCK_vkCmdBuildAccelerationStructureNV_CALLBACK Callback) +{ + Mock.vkCmdBuildAccelerationStructureNV_IgnoreBool = (char)0; + Mock.vkCmdBuildAccelerationStructureNV_CallbackBool = (char)0; + Mock.vkCmdBuildAccelerationStructureNV_CallbackFunctionPointer = Callback; +} + +void vkCmdBuildAccelerationStructureNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBuildAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBuildAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBuildAccelerationStructureNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBuildAccelerationStructureNV_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBuildAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBuildAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBuildAccelerationStructureNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +void vkCmdBuildAccelerationStructureNV_CMockIgnoreArg_instanceData(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBuildAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBuildAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBuildAccelerationStructureNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_instanceData = 1; +} + +void vkCmdBuildAccelerationStructureNV_CMockIgnoreArg_instanceOffset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBuildAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBuildAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBuildAccelerationStructureNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_instanceOffset = 1; +} + +void vkCmdBuildAccelerationStructureNV_CMockIgnoreArg_update(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBuildAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBuildAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBuildAccelerationStructureNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_update = 1; +} + +void vkCmdBuildAccelerationStructureNV_CMockIgnoreArg_dst(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBuildAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBuildAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBuildAccelerationStructureNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dst = 1; +} + +void vkCmdBuildAccelerationStructureNV_CMockIgnoreArg_src(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBuildAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBuildAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBuildAccelerationStructureNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_src = 1; +} + +void vkCmdBuildAccelerationStructureNV_CMockIgnoreArg_scratch(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBuildAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBuildAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBuildAccelerationStructureNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_scratch = 1; +} + +void vkCmdBuildAccelerationStructureNV_CMockIgnoreArg_scratchOffset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBuildAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBuildAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBuildAccelerationStructureNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_scratchOffset = 1; +} + +void vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdCopyAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdCopyAccelerationStructureNV); + cmock_call_instance = (CMOCK_vkCmdCopyAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdCopyAccelerationStructureNV_CallInstance); + Mock.vkCmdCopyAccelerationStructureNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdCopyAccelerationStructureNV_CallInstance); + if (Mock.vkCmdCopyAccelerationStructureNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdCopyAccelerationStructureNV_CallbackBool && + Mock.vkCmdCopyAccelerationStructureNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyAccelerationStructureNV_CallbackFunctionPointer(commandBuffer, dst, src, mode, Mock.vkCmdCopyAccelerationStructureNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyAccelerationStructureNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dst) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyAccelerationStructureNV,CMockString_dst); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dst), (void*)(&dst), sizeof(VkAccelerationStructureNV), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_src) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyAccelerationStructureNV,CMockString_src); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_src), (void*)(&src), sizeof(VkAccelerationStructureNV), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_mode) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyAccelerationStructureNV,CMockString_mode); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_mode), (void*)(&mode), sizeof(VkCopyAccelerationStructureModeKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdCopyAccelerationStructureNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyAccelerationStructureNV_CallbackFunctionPointer(commandBuffer, dst, src, mode, Mock.vkCmdCopyAccelerationStructureNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdCopyAccelerationStructureNV(CMOCK_vkCmdCopyAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode); +void CMockExpectParameters_vkCmdCopyAccelerationStructureNV(CMOCK_vkCmdCopyAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_dst), (void*)(&dst), + sizeof(VkAccelerationStructureNV[sizeof(dst) == sizeof(VkAccelerationStructureNV) ? 1 : -1])); /* add VkAccelerationStructureNV to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dst = 0; + memcpy((void*)(&cmock_call_instance->Expected_src), (void*)(&src), + sizeof(VkAccelerationStructureNV[sizeof(src) == sizeof(VkAccelerationStructureNV) ? 1 : -1])); /* add VkAccelerationStructureNV to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_src = 0; + memcpy((void*)(&cmock_call_instance->Expected_mode), (void*)(&mode), + sizeof(VkCopyAccelerationStructureModeKHR[sizeof(mode) == sizeof(VkCopyAccelerationStructureModeKHR) ? 1 : -1])); /* add VkCopyAccelerationStructureModeKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_mode = 0; +} + +void vkCmdCopyAccelerationStructureNV_CMockIgnore(void) +{ + Mock.vkCmdCopyAccelerationStructureNV_IgnoreBool = (char)1; +} + +void vkCmdCopyAccelerationStructureNV_CMockStopIgnore(void) +{ + Mock.vkCmdCopyAccelerationStructureNV_IgnoreBool = (char)0; +} + +void vkCmdCopyAccelerationStructureNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyAccelerationStructureNV_CALL_INSTANCE)); + CMOCK_vkCmdCopyAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyAccelerationStructureNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyAccelerationStructureNV_CallInstance, cmock_guts_index); + Mock.vkCmdCopyAccelerationStructureNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdCopyAccelerationStructureNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyAccelerationStructureNV_CALL_INSTANCE)); + CMOCK_vkCmdCopyAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyAccelerationStructureNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyAccelerationStructureNV_CallInstance, cmock_guts_index); + Mock.vkCmdCopyAccelerationStructureNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdCopyAccelerationStructureNV(cmock_call_instance, commandBuffer, dst, src, mode); +} + +void vkCmdCopyAccelerationStructureNV_AddCallback(CMOCK_vkCmdCopyAccelerationStructureNV_CALLBACK Callback) +{ + Mock.vkCmdCopyAccelerationStructureNV_IgnoreBool = (char)0; + Mock.vkCmdCopyAccelerationStructureNV_CallbackBool = (char)1; + Mock.vkCmdCopyAccelerationStructureNV_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyAccelerationStructureNV_Stub(CMOCK_vkCmdCopyAccelerationStructureNV_CALLBACK Callback) +{ + Mock.vkCmdCopyAccelerationStructureNV_IgnoreBool = (char)0; + Mock.vkCmdCopyAccelerationStructureNV_CallbackBool = (char)0; + Mock.vkCmdCopyAccelerationStructureNV_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyAccelerationStructureNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyAccelerationStructureNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdCopyAccelerationStructureNV_CMockIgnoreArg_dst(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyAccelerationStructureNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dst = 1; +} + +void vkCmdCopyAccelerationStructureNV_CMockIgnoreArg_src(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyAccelerationStructureNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_src = 1; +} + +void vkCmdCopyAccelerationStructureNV_CMockIgnoreArg_mode(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyAccelerationStructureNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyAccelerationStructureNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyAccelerationStructureNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_mode = 1; +} + +void vkCmdTraceRaysNV(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdTraceRaysNV); + cmock_call_instance = (CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdTraceRaysNV_CallInstance); + Mock.vkCmdTraceRaysNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdTraceRaysNV_CallInstance); + if (Mock.vkCmdTraceRaysNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdTraceRaysNV_CallbackBool && + Mock.vkCmdTraceRaysNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdTraceRaysNV_CallbackFunctionPointer(commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth, Mock.vkCmdTraceRaysNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_raygenShaderBindingTableBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysNV,CMockString_raygenShaderBindingTableBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_raygenShaderBindingTableBuffer), (void*)(&raygenShaderBindingTableBuffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_raygenShaderBindingOffset) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysNV,CMockString_raygenShaderBindingOffset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_raygenShaderBindingOffset), (void*)(&raygenShaderBindingOffset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_missShaderBindingTableBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysNV,CMockString_missShaderBindingTableBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_missShaderBindingTableBuffer), (void*)(&missShaderBindingTableBuffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_missShaderBindingOffset) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysNV,CMockString_missShaderBindingOffset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_missShaderBindingOffset), (void*)(&missShaderBindingOffset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_missShaderBindingStride) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysNV,CMockString_missShaderBindingStride); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_missShaderBindingStride), (void*)(&missShaderBindingStride), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_hitShaderBindingTableBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysNV,CMockString_hitShaderBindingTableBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_hitShaderBindingTableBuffer), (void*)(&hitShaderBindingTableBuffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_hitShaderBindingOffset) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysNV,CMockString_hitShaderBindingOffset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_hitShaderBindingOffset), (void*)(&hitShaderBindingOffset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_hitShaderBindingStride) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysNV,CMockString_hitShaderBindingStride); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_hitShaderBindingStride), (void*)(&hitShaderBindingStride), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_callableShaderBindingTableBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysNV,CMockString_callableShaderBindingTableBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_callableShaderBindingTableBuffer), (void*)(&callableShaderBindingTableBuffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_callableShaderBindingOffset) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysNV,CMockString_callableShaderBindingOffset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_callableShaderBindingOffset), (void*)(&callableShaderBindingOffset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_callableShaderBindingStride) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysNV,CMockString_callableShaderBindingStride); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_callableShaderBindingStride), (void*)(&callableShaderBindingStride), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_width) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysNV,CMockString_width); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_width, width, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_height) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysNV,CMockString_height); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_height, height, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_depth) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysNV,CMockString_depth); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_depth, depth, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdTraceRaysNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdTraceRaysNV_CallbackFunctionPointer(commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth, Mock.vkCmdTraceRaysNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdTraceRaysNV(CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth); +void CMockExpectParameters_vkCmdTraceRaysNV(CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_raygenShaderBindingTableBuffer), (void*)(&raygenShaderBindingTableBuffer), + sizeof(VkBuffer[sizeof(raygenShaderBindingTableBuffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_raygenShaderBindingTableBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_raygenShaderBindingOffset), (void*)(&raygenShaderBindingOffset), + sizeof(VkDeviceSize[sizeof(raygenShaderBindingOffset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_raygenShaderBindingOffset = 0; + memcpy((void*)(&cmock_call_instance->Expected_missShaderBindingTableBuffer), (void*)(&missShaderBindingTableBuffer), + sizeof(VkBuffer[sizeof(missShaderBindingTableBuffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_missShaderBindingTableBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_missShaderBindingOffset), (void*)(&missShaderBindingOffset), + sizeof(VkDeviceSize[sizeof(missShaderBindingOffset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_missShaderBindingOffset = 0; + memcpy((void*)(&cmock_call_instance->Expected_missShaderBindingStride), (void*)(&missShaderBindingStride), + sizeof(VkDeviceSize[sizeof(missShaderBindingStride) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_missShaderBindingStride = 0; + memcpy((void*)(&cmock_call_instance->Expected_hitShaderBindingTableBuffer), (void*)(&hitShaderBindingTableBuffer), + sizeof(VkBuffer[sizeof(hitShaderBindingTableBuffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_hitShaderBindingTableBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_hitShaderBindingOffset), (void*)(&hitShaderBindingOffset), + sizeof(VkDeviceSize[sizeof(hitShaderBindingOffset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_hitShaderBindingOffset = 0; + memcpy((void*)(&cmock_call_instance->Expected_hitShaderBindingStride), (void*)(&hitShaderBindingStride), + sizeof(VkDeviceSize[sizeof(hitShaderBindingStride) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_hitShaderBindingStride = 0; + memcpy((void*)(&cmock_call_instance->Expected_callableShaderBindingTableBuffer), (void*)(&callableShaderBindingTableBuffer), + sizeof(VkBuffer[sizeof(callableShaderBindingTableBuffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_callableShaderBindingTableBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_callableShaderBindingOffset), (void*)(&callableShaderBindingOffset), + sizeof(VkDeviceSize[sizeof(callableShaderBindingOffset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_callableShaderBindingOffset = 0; + memcpy((void*)(&cmock_call_instance->Expected_callableShaderBindingStride), (void*)(&callableShaderBindingStride), + sizeof(VkDeviceSize[sizeof(callableShaderBindingStride) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_callableShaderBindingStride = 0; + cmock_call_instance->Expected_width = width; + cmock_call_instance->IgnoreArg_width = 0; + cmock_call_instance->Expected_height = height; + cmock_call_instance->IgnoreArg_height = 0; + cmock_call_instance->Expected_depth = depth; + cmock_call_instance->IgnoreArg_depth = 0; +} + +void vkCmdTraceRaysNV_CMockIgnore(void) +{ + Mock.vkCmdTraceRaysNV_IgnoreBool = (char)1; +} + +void vkCmdTraceRaysNV_CMockStopIgnore(void) +{ + Mock.vkCmdTraceRaysNV_IgnoreBool = (char)0; +} + +void vkCmdTraceRaysNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE)); + CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdTraceRaysNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdTraceRaysNV_CallInstance, cmock_guts_index); + Mock.vkCmdTraceRaysNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdTraceRaysNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE)); + CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdTraceRaysNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdTraceRaysNV_CallInstance, cmock_guts_index); + Mock.vkCmdTraceRaysNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdTraceRaysNV(cmock_call_instance, commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth); +} + +void vkCmdTraceRaysNV_AddCallback(CMOCK_vkCmdTraceRaysNV_CALLBACK Callback) +{ + Mock.vkCmdTraceRaysNV_IgnoreBool = (char)0; + Mock.vkCmdTraceRaysNV_CallbackBool = (char)1; + Mock.vkCmdTraceRaysNV_CallbackFunctionPointer = Callback; +} + +void vkCmdTraceRaysNV_Stub(CMOCK_vkCmdTraceRaysNV_CALLBACK Callback) +{ + Mock.vkCmdTraceRaysNV_IgnoreBool = (char)0; + Mock.vkCmdTraceRaysNV_CallbackBool = (char)0; + Mock.vkCmdTraceRaysNV_CallbackFunctionPointer = Callback; +} + +void vkCmdTraceRaysNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdTraceRaysNV_CMockIgnoreArg_raygenShaderBindingTableBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_raygenShaderBindingTableBuffer = 1; +} + +void vkCmdTraceRaysNV_CMockIgnoreArg_raygenShaderBindingOffset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_raygenShaderBindingOffset = 1; +} + +void vkCmdTraceRaysNV_CMockIgnoreArg_missShaderBindingTableBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_missShaderBindingTableBuffer = 1; +} + +void vkCmdTraceRaysNV_CMockIgnoreArg_missShaderBindingOffset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_missShaderBindingOffset = 1; +} + +void vkCmdTraceRaysNV_CMockIgnoreArg_missShaderBindingStride(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_missShaderBindingStride = 1; +} + +void vkCmdTraceRaysNV_CMockIgnoreArg_hitShaderBindingTableBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_hitShaderBindingTableBuffer = 1; +} + +void vkCmdTraceRaysNV_CMockIgnoreArg_hitShaderBindingOffset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_hitShaderBindingOffset = 1; +} + +void vkCmdTraceRaysNV_CMockIgnoreArg_hitShaderBindingStride(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_hitShaderBindingStride = 1; +} + +void vkCmdTraceRaysNV_CMockIgnoreArg_callableShaderBindingTableBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_callableShaderBindingTableBuffer = 1; +} + +void vkCmdTraceRaysNV_CMockIgnoreArg_callableShaderBindingOffset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_callableShaderBindingOffset = 1; +} + +void vkCmdTraceRaysNV_CMockIgnoreArg_callableShaderBindingStride(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_callableShaderBindingStride = 1; +} + +void vkCmdTraceRaysNV_CMockIgnoreArg_width(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_width = 1; +} + +void vkCmdTraceRaysNV_CMockIgnoreArg_height(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_height = 1; +} + +void vkCmdTraceRaysNV_CMockIgnoreArg_depth(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_depth = 1; +} + +VkResult vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateRayTracingPipelinesNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateRayTracingPipelinesNV); + cmock_call_instance = (CMOCK_vkCreateRayTracingPipelinesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateRayTracingPipelinesNV_CallInstance); + Mock.vkCreateRayTracingPipelinesNV_CallInstance = CMock_Guts_MemNext(Mock.vkCreateRayTracingPipelinesNV_CallInstance); + if (Mock.vkCreateRayTracingPipelinesNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateRayTracingPipelinesNV_FinalReturn; + memcpy((void*)(&Mock.vkCreateRayTracingPipelinesNV_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateRayTracingPipelinesNV_CallbackBool && + Mock.vkCreateRayTracingPipelinesNV_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateRayTracingPipelinesNV_CallbackFunctionPointer(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, Mock.vkCreateRayTracingPipelinesNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateRayTracingPipelinesNV,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pipelineCache) + { + UNITY_SET_DETAILS(CMockString_vkCreateRayTracingPipelinesNV,CMockString_pipelineCache); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_pipelineCache), (void*)(&pipelineCache), sizeof(VkPipelineCache), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_createInfoCount) + { + UNITY_SET_DETAILS(CMockString_vkCreateRayTracingPipelinesNV,CMockString_createInfoCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_createInfoCount, createInfoCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfos) + { + UNITY_SET_DETAILS(CMockString_vkCreateRayTracingPipelinesNV,CMockString_pCreateInfos); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfos), (void*)(pCreateInfos), sizeof(const VkRayTracingPipelineCreateInfoNV), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateRayTracingPipelinesNV,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPipelines) + { + UNITY_SET_DETAILS(CMockString_vkCreateRayTracingPipelinesNV,CMockString_pPipelines); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pPipelines), (void*)(pPipelines), sizeof(VkPipeline), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateRayTracingPipelinesNV_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateRayTracingPipelinesNV_CallbackFunctionPointer(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, Mock.vkCreateRayTracingPipelinesNV_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPipelines_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPipelines, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPipelines, (const void*)cmock_call_instance->ReturnThruPtr_pPipelines_Val, + cmock_call_instance->ReturnThruPtr_pPipelines_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateRayTracingPipelinesNV(CMOCK_vkCreateRayTracingPipelinesNV_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +void CMockExpectParameters_vkCreateRayTracingPipelinesNV(CMOCK_vkCreateRayTracingPipelinesNV_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_pipelineCache), (void*)(&pipelineCache), + sizeof(VkPipelineCache[sizeof(pipelineCache) == sizeof(VkPipelineCache) ? 1 : -1])); /* add VkPipelineCache to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_pipelineCache = 0; + cmock_call_instance->Expected_createInfoCount = createInfoCount; + cmock_call_instance->IgnoreArg_createInfoCount = 0; + cmock_call_instance->Expected_pCreateInfos = pCreateInfos; + cmock_call_instance->IgnoreArg_pCreateInfos = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pPipelines = pPipelines; + cmock_call_instance->IgnoreArg_pPipelines = 0; + cmock_call_instance->ReturnThruPtr_pPipelines_Used = 0; +} + +void vkCreateRayTracingPipelinesNV_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateRayTracingPipelinesNV_CALL_INSTANCE)); + CMOCK_vkCreateRayTracingPipelinesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRayTracingPipelinesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateRayTracingPipelinesNV_CallInstance = CMock_Guts_MemChain(Mock.vkCreateRayTracingPipelinesNV_CallInstance, cmock_guts_index); + Mock.vkCreateRayTracingPipelinesNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateRayTracingPipelinesNV_IgnoreBool = (char)1; +} + +void vkCreateRayTracingPipelinesNV_CMockStopIgnore(void) +{ + if(Mock.vkCreateRayTracingPipelinesNV_IgnoreBool) + Mock.vkCreateRayTracingPipelinesNV_CallInstance = CMock_Guts_MemNext(Mock.vkCreateRayTracingPipelinesNV_CallInstance); + Mock.vkCreateRayTracingPipelinesNV_IgnoreBool = (char)0; +} + +void vkCreateRayTracingPipelinesNV_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateRayTracingPipelinesNV_CALL_INSTANCE)); + CMOCK_vkCreateRayTracingPipelinesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRayTracingPipelinesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateRayTracingPipelinesNV_CallInstance = CMock_Guts_MemChain(Mock.vkCreateRayTracingPipelinesNV_CallInstance, cmock_guts_index); + Mock.vkCreateRayTracingPipelinesNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateRayTracingPipelinesNV_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateRayTracingPipelinesNV_CALL_INSTANCE)); + CMOCK_vkCreateRayTracingPipelinesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRayTracingPipelinesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateRayTracingPipelinesNV_CallInstance = CMock_Guts_MemChain(Mock.vkCreateRayTracingPipelinesNV_CallInstance, cmock_guts_index); + Mock.vkCreateRayTracingPipelinesNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateRayTracingPipelinesNV(cmock_call_instance, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateRayTracingPipelinesNV_AddCallback(CMOCK_vkCreateRayTracingPipelinesNV_CALLBACK Callback) +{ + Mock.vkCreateRayTracingPipelinesNV_IgnoreBool = (char)0; + Mock.vkCreateRayTracingPipelinesNV_CallbackBool = (char)1; + Mock.vkCreateRayTracingPipelinesNV_CallbackFunctionPointer = Callback; +} + +void vkCreateRayTracingPipelinesNV_Stub(CMOCK_vkCreateRayTracingPipelinesNV_CALLBACK Callback) +{ + Mock.vkCreateRayTracingPipelinesNV_IgnoreBool = (char)0; + Mock.vkCreateRayTracingPipelinesNV_CallbackBool = (char)0; + Mock.vkCreateRayTracingPipelinesNV_CallbackFunctionPointer = Callback; +} + +void vkCreateRayTracingPipelinesNV_CMockReturnMemThruPtr_pPipelines(UNITY_LINE_TYPE cmock_line, VkPipeline const* pPipelines, size_t cmock_size) +{ + CMOCK_vkCreateRayTracingPipelinesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRayTracingPipelinesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateRayTracingPipelinesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPipelines_Used = 1; + cmock_call_instance->ReturnThruPtr_pPipelines_Val = pPipelines; + cmock_call_instance->ReturnThruPtr_pPipelines_Size = cmock_size; +} + +void vkCreateRayTracingPipelinesNV_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateRayTracingPipelinesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRayTracingPipelinesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateRayTracingPipelinesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateRayTracingPipelinesNV_CMockIgnoreArg_pipelineCache(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateRayTracingPipelinesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRayTracingPipelinesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateRayTracingPipelinesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pipelineCache = 1; +} + +void vkCreateRayTracingPipelinesNV_CMockIgnoreArg_createInfoCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateRayTracingPipelinesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRayTracingPipelinesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateRayTracingPipelinesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_createInfoCount = 1; +} + +void vkCreateRayTracingPipelinesNV_CMockIgnoreArg_pCreateInfos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateRayTracingPipelinesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRayTracingPipelinesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateRayTracingPipelinesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfos = 1; +} + +void vkCreateRayTracingPipelinesNV_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateRayTracingPipelinesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRayTracingPipelinesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateRayTracingPipelinesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateRayTracingPipelinesNV_CMockIgnoreArg_pPipelines(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateRayTracingPipelinesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRayTracingPipelinesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateRayTracingPipelinesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPipelines = 1; +} + +VkResult vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetRayTracingShaderGroupHandlesKHR); + cmock_call_instance = (CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetRayTracingShaderGroupHandlesKHR_CallInstance); + Mock.vkGetRayTracingShaderGroupHandlesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetRayTracingShaderGroupHandlesKHR_CallInstance); + if (Mock.vkGetRayTracingShaderGroupHandlesKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetRayTracingShaderGroupHandlesKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetRayTracingShaderGroupHandlesKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetRayTracingShaderGroupHandlesKHR_CallbackBool && + Mock.vkGetRayTracingShaderGroupHandlesKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetRayTracingShaderGroupHandlesKHR_CallbackFunctionPointer(device, pipeline, firstGroup, groupCount, dataSize, pData, Mock.vkGetRayTracingShaderGroupHandlesKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetRayTracingShaderGroupHandlesKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pipeline) + { + UNITY_SET_DETAILS(CMockString_vkGetRayTracingShaderGroupHandlesKHR,CMockString_pipeline); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_pipeline), (void*)(&pipeline), sizeof(VkPipeline), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstGroup) + { + UNITY_SET_DETAILS(CMockString_vkGetRayTracingShaderGroupHandlesKHR,CMockString_firstGroup); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstGroup, firstGroup, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_groupCount) + { + UNITY_SET_DETAILS(CMockString_vkGetRayTracingShaderGroupHandlesKHR,CMockString_groupCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_groupCount, groupCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dataSize) + { + UNITY_SET_DETAILS(CMockString_vkGetRayTracingShaderGroupHandlesKHR,CMockString_dataSize); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dataSize), (void*)(&dataSize), sizeof(size_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pData) + { + UNITY_SET_DETAILS(CMockString_vkGetRayTracingShaderGroupHandlesKHR,CMockString_pData); + if (cmock_call_instance->Expected_pData == NULL) + { UNITY_TEST_ASSERT_NULL(pData, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(cmock_call_instance->Expected_pData, pData, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkGetRayTracingShaderGroupHandlesKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetRayTracingShaderGroupHandlesKHR_CallbackFunctionPointer(device, pipeline, firstGroup, groupCount, dataSize, pData, Mock.vkGetRayTracingShaderGroupHandlesKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pData_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pData, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pData, (const void*)cmock_call_instance->ReturnThruPtr_pData_Val, + cmock_call_instance->ReturnThruPtr_pData_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetRayTracingShaderGroupHandlesKHR(CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData); +void CMockExpectParameters_vkGetRayTracingShaderGroupHandlesKHR(CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_pipeline), (void*)(&pipeline), + sizeof(VkPipeline[sizeof(pipeline) == sizeof(VkPipeline) ? 1 : -1])); /* add VkPipeline to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_pipeline = 0; + cmock_call_instance->Expected_firstGroup = firstGroup; + cmock_call_instance->IgnoreArg_firstGroup = 0; + cmock_call_instance->Expected_groupCount = groupCount; + cmock_call_instance->IgnoreArg_groupCount = 0; + memcpy((void*)(&cmock_call_instance->Expected_dataSize), (void*)(&dataSize), + sizeof(size_t[sizeof(dataSize) == sizeof(size_t) ? 1 : -1])); /* add size_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dataSize = 0; + cmock_call_instance->Expected_pData = pData; + cmock_call_instance->IgnoreArg_pData = 0; + cmock_call_instance->ReturnThruPtr_pData_Used = 0; +} + +void vkGetRayTracingShaderGroupHandlesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALL_INSTANCE)); + CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetRayTracingShaderGroupHandlesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetRayTracingShaderGroupHandlesKHR_CallInstance, cmock_guts_index); + Mock.vkGetRayTracingShaderGroupHandlesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetRayTracingShaderGroupHandlesKHR_IgnoreBool = (char)1; +} + +void vkGetRayTracingShaderGroupHandlesKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetRayTracingShaderGroupHandlesKHR_IgnoreBool) + Mock.vkGetRayTracingShaderGroupHandlesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetRayTracingShaderGroupHandlesKHR_CallInstance); + Mock.vkGetRayTracingShaderGroupHandlesKHR_IgnoreBool = (char)0; +} + +void vkGetRayTracingShaderGroupHandlesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALL_INSTANCE)); + CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetRayTracingShaderGroupHandlesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetRayTracingShaderGroupHandlesKHR_CallInstance, cmock_guts_index); + Mock.vkGetRayTracingShaderGroupHandlesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetRayTracingShaderGroupHandlesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALL_INSTANCE)); + CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetRayTracingShaderGroupHandlesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetRayTracingShaderGroupHandlesKHR_CallInstance, cmock_guts_index); + Mock.vkGetRayTracingShaderGroupHandlesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetRayTracingShaderGroupHandlesKHR(cmock_call_instance, device, pipeline, firstGroup, groupCount, dataSize, pData); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetRayTracingShaderGroupHandlesKHR_AddCallback(CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALLBACK Callback) +{ + Mock.vkGetRayTracingShaderGroupHandlesKHR_IgnoreBool = (char)0; + Mock.vkGetRayTracingShaderGroupHandlesKHR_CallbackBool = (char)1; + Mock.vkGetRayTracingShaderGroupHandlesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetRayTracingShaderGroupHandlesKHR_Stub(CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALLBACK Callback) +{ + Mock.vkGetRayTracingShaderGroupHandlesKHR_IgnoreBool = (char)0; + Mock.vkGetRayTracingShaderGroupHandlesKHR_CallbackBool = (char)0; + Mock.vkGetRayTracingShaderGroupHandlesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetRayTracingShaderGroupHandlesKHR_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, void const* pData, size_t cmock_size) +{ + CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRayTracingShaderGroupHandlesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pData_Used = 1; + cmock_call_instance->ReturnThruPtr_pData_Val = pData; + cmock_call_instance->ReturnThruPtr_pData_Size = cmock_size; +} + +void vkGetRayTracingShaderGroupHandlesKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRayTracingShaderGroupHandlesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetRayTracingShaderGroupHandlesKHR_CMockIgnoreArg_pipeline(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRayTracingShaderGroupHandlesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pipeline = 1; +} + +void vkGetRayTracingShaderGroupHandlesKHR_CMockIgnoreArg_firstGroup(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRayTracingShaderGroupHandlesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstGroup = 1; +} + +void vkGetRayTracingShaderGroupHandlesKHR_CMockIgnoreArg_groupCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRayTracingShaderGroupHandlesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_groupCount = 1; +} + +void vkGetRayTracingShaderGroupHandlesKHR_CMockIgnoreArg_dataSize(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRayTracingShaderGroupHandlesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dataSize = 1; +} + +void vkGetRayTracingShaderGroupHandlesKHR_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRayTracingShaderGroupHandlesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pData = 1; +} + +VkResult vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetRayTracingShaderGroupHandlesNV); + cmock_call_instance = (CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetRayTracingShaderGroupHandlesNV_CallInstance); + Mock.vkGetRayTracingShaderGroupHandlesNV_CallInstance = CMock_Guts_MemNext(Mock.vkGetRayTracingShaderGroupHandlesNV_CallInstance); + if (Mock.vkGetRayTracingShaderGroupHandlesNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetRayTracingShaderGroupHandlesNV_FinalReturn; + memcpy((void*)(&Mock.vkGetRayTracingShaderGroupHandlesNV_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetRayTracingShaderGroupHandlesNV_CallbackBool && + Mock.vkGetRayTracingShaderGroupHandlesNV_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetRayTracingShaderGroupHandlesNV_CallbackFunctionPointer(device, pipeline, firstGroup, groupCount, dataSize, pData, Mock.vkGetRayTracingShaderGroupHandlesNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetRayTracingShaderGroupHandlesNV,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pipeline) + { + UNITY_SET_DETAILS(CMockString_vkGetRayTracingShaderGroupHandlesNV,CMockString_pipeline); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_pipeline), (void*)(&pipeline), sizeof(VkPipeline), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstGroup) + { + UNITY_SET_DETAILS(CMockString_vkGetRayTracingShaderGroupHandlesNV,CMockString_firstGroup); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstGroup, firstGroup, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_groupCount) + { + UNITY_SET_DETAILS(CMockString_vkGetRayTracingShaderGroupHandlesNV,CMockString_groupCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_groupCount, groupCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dataSize) + { + UNITY_SET_DETAILS(CMockString_vkGetRayTracingShaderGroupHandlesNV,CMockString_dataSize); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dataSize), (void*)(&dataSize), sizeof(size_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pData) + { + UNITY_SET_DETAILS(CMockString_vkGetRayTracingShaderGroupHandlesNV,CMockString_pData); + if (cmock_call_instance->Expected_pData == NULL) + { UNITY_TEST_ASSERT_NULL(pData, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(cmock_call_instance->Expected_pData, pData, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkGetRayTracingShaderGroupHandlesNV_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetRayTracingShaderGroupHandlesNV_CallbackFunctionPointer(device, pipeline, firstGroup, groupCount, dataSize, pData, Mock.vkGetRayTracingShaderGroupHandlesNV_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pData_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pData, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pData, (const void*)cmock_call_instance->ReturnThruPtr_pData_Val, + cmock_call_instance->ReturnThruPtr_pData_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetRayTracingShaderGroupHandlesNV(CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData); +void CMockExpectParameters_vkGetRayTracingShaderGroupHandlesNV(CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_pipeline), (void*)(&pipeline), + sizeof(VkPipeline[sizeof(pipeline) == sizeof(VkPipeline) ? 1 : -1])); /* add VkPipeline to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_pipeline = 0; + cmock_call_instance->Expected_firstGroup = firstGroup; + cmock_call_instance->IgnoreArg_firstGroup = 0; + cmock_call_instance->Expected_groupCount = groupCount; + cmock_call_instance->IgnoreArg_groupCount = 0; + memcpy((void*)(&cmock_call_instance->Expected_dataSize), (void*)(&dataSize), + sizeof(size_t[sizeof(dataSize) == sizeof(size_t) ? 1 : -1])); /* add size_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dataSize = 0; + cmock_call_instance->Expected_pData = pData; + cmock_call_instance->IgnoreArg_pData = 0; + cmock_call_instance->ReturnThruPtr_pData_Used = 0; +} + +void vkGetRayTracingShaderGroupHandlesNV_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALL_INSTANCE)); + CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetRayTracingShaderGroupHandlesNV_CallInstance = CMock_Guts_MemChain(Mock.vkGetRayTracingShaderGroupHandlesNV_CallInstance, cmock_guts_index); + Mock.vkGetRayTracingShaderGroupHandlesNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetRayTracingShaderGroupHandlesNV_IgnoreBool = (char)1; +} + +void vkGetRayTracingShaderGroupHandlesNV_CMockStopIgnore(void) +{ + if(Mock.vkGetRayTracingShaderGroupHandlesNV_IgnoreBool) + Mock.vkGetRayTracingShaderGroupHandlesNV_CallInstance = CMock_Guts_MemNext(Mock.vkGetRayTracingShaderGroupHandlesNV_CallInstance); + Mock.vkGetRayTracingShaderGroupHandlesNV_IgnoreBool = (char)0; +} + +void vkGetRayTracingShaderGroupHandlesNV_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALL_INSTANCE)); + CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetRayTracingShaderGroupHandlesNV_CallInstance = CMock_Guts_MemChain(Mock.vkGetRayTracingShaderGroupHandlesNV_CallInstance, cmock_guts_index); + Mock.vkGetRayTracingShaderGroupHandlesNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetRayTracingShaderGroupHandlesNV_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALL_INSTANCE)); + CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetRayTracingShaderGroupHandlesNV_CallInstance = CMock_Guts_MemChain(Mock.vkGetRayTracingShaderGroupHandlesNV_CallInstance, cmock_guts_index); + Mock.vkGetRayTracingShaderGroupHandlesNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetRayTracingShaderGroupHandlesNV(cmock_call_instance, device, pipeline, firstGroup, groupCount, dataSize, pData); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetRayTracingShaderGroupHandlesNV_AddCallback(CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALLBACK Callback) +{ + Mock.vkGetRayTracingShaderGroupHandlesNV_IgnoreBool = (char)0; + Mock.vkGetRayTracingShaderGroupHandlesNV_CallbackBool = (char)1; + Mock.vkGetRayTracingShaderGroupHandlesNV_CallbackFunctionPointer = Callback; +} + +void vkGetRayTracingShaderGroupHandlesNV_Stub(CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALLBACK Callback) +{ + Mock.vkGetRayTracingShaderGroupHandlesNV_IgnoreBool = (char)0; + Mock.vkGetRayTracingShaderGroupHandlesNV_CallbackBool = (char)0; + Mock.vkGetRayTracingShaderGroupHandlesNV_CallbackFunctionPointer = Callback; +} + +void vkGetRayTracingShaderGroupHandlesNV_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, void const* pData, size_t cmock_size) +{ + CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRayTracingShaderGroupHandlesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pData_Used = 1; + cmock_call_instance->ReturnThruPtr_pData_Val = pData; + cmock_call_instance->ReturnThruPtr_pData_Size = cmock_size; +} + +void vkGetRayTracingShaderGroupHandlesNV_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRayTracingShaderGroupHandlesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetRayTracingShaderGroupHandlesNV_CMockIgnoreArg_pipeline(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRayTracingShaderGroupHandlesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pipeline = 1; +} + +void vkGetRayTracingShaderGroupHandlesNV_CMockIgnoreArg_firstGroup(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRayTracingShaderGroupHandlesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstGroup = 1; +} + +void vkGetRayTracingShaderGroupHandlesNV_CMockIgnoreArg_groupCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRayTracingShaderGroupHandlesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_groupCount = 1; +} + +void vkGetRayTracingShaderGroupHandlesNV_CMockIgnoreArg_dataSize(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRayTracingShaderGroupHandlesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dataSize = 1; +} + +void vkGetRayTracingShaderGroupHandlesNV_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRayTracingShaderGroupHandlesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pData = 1; +} + +VkResult vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetAccelerationStructureHandleNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetAccelerationStructureHandleNV); + cmock_call_instance = (CMOCK_vkGetAccelerationStructureHandleNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetAccelerationStructureHandleNV_CallInstance); + Mock.vkGetAccelerationStructureHandleNV_CallInstance = CMock_Guts_MemNext(Mock.vkGetAccelerationStructureHandleNV_CallInstance); + if (Mock.vkGetAccelerationStructureHandleNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetAccelerationStructureHandleNV_FinalReturn; + memcpy((void*)(&Mock.vkGetAccelerationStructureHandleNV_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetAccelerationStructureHandleNV_CallbackBool && + Mock.vkGetAccelerationStructureHandleNV_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetAccelerationStructureHandleNV_CallbackFunctionPointer(device, accelerationStructure, dataSize, pData, Mock.vkGetAccelerationStructureHandleNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetAccelerationStructureHandleNV,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_accelerationStructure) + { + UNITY_SET_DETAILS(CMockString_vkGetAccelerationStructureHandleNV,CMockString_accelerationStructure); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_accelerationStructure), (void*)(&accelerationStructure), sizeof(VkAccelerationStructureNV), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dataSize) + { + UNITY_SET_DETAILS(CMockString_vkGetAccelerationStructureHandleNV,CMockString_dataSize); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dataSize), (void*)(&dataSize), sizeof(size_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pData) + { + UNITY_SET_DETAILS(CMockString_vkGetAccelerationStructureHandleNV,CMockString_pData); + if (cmock_call_instance->Expected_pData == NULL) + { UNITY_TEST_ASSERT_NULL(pData, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(cmock_call_instance->Expected_pData, pData, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkGetAccelerationStructureHandleNV_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetAccelerationStructureHandleNV_CallbackFunctionPointer(device, accelerationStructure, dataSize, pData, Mock.vkGetAccelerationStructureHandleNV_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pData_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pData, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pData, (const void*)cmock_call_instance->ReturnThruPtr_pData_Val, + cmock_call_instance->ReturnThruPtr_pData_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetAccelerationStructureHandleNV(CMOCK_vkGetAccelerationStructureHandleNV_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData); +void CMockExpectParameters_vkGetAccelerationStructureHandleNV(CMOCK_vkGetAccelerationStructureHandleNV_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_accelerationStructure), (void*)(&accelerationStructure), + sizeof(VkAccelerationStructureNV[sizeof(accelerationStructure) == sizeof(VkAccelerationStructureNV) ? 1 : -1])); /* add VkAccelerationStructureNV to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_accelerationStructure = 0; + memcpy((void*)(&cmock_call_instance->Expected_dataSize), (void*)(&dataSize), + sizeof(size_t[sizeof(dataSize) == sizeof(size_t) ? 1 : -1])); /* add size_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dataSize = 0; + cmock_call_instance->Expected_pData = pData; + cmock_call_instance->IgnoreArg_pData = 0; + cmock_call_instance->ReturnThruPtr_pData_Used = 0; +} + +void vkGetAccelerationStructureHandleNV_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetAccelerationStructureHandleNV_CALL_INSTANCE)); + CMOCK_vkGetAccelerationStructureHandleNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureHandleNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetAccelerationStructureHandleNV_CallInstance = CMock_Guts_MemChain(Mock.vkGetAccelerationStructureHandleNV_CallInstance, cmock_guts_index); + Mock.vkGetAccelerationStructureHandleNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetAccelerationStructureHandleNV_IgnoreBool = (char)1; +} + +void vkGetAccelerationStructureHandleNV_CMockStopIgnore(void) +{ + if(Mock.vkGetAccelerationStructureHandleNV_IgnoreBool) + Mock.vkGetAccelerationStructureHandleNV_CallInstance = CMock_Guts_MemNext(Mock.vkGetAccelerationStructureHandleNV_CallInstance); + Mock.vkGetAccelerationStructureHandleNV_IgnoreBool = (char)0; +} + +void vkGetAccelerationStructureHandleNV_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetAccelerationStructureHandleNV_CALL_INSTANCE)); + CMOCK_vkGetAccelerationStructureHandleNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureHandleNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetAccelerationStructureHandleNV_CallInstance = CMock_Guts_MemChain(Mock.vkGetAccelerationStructureHandleNV_CallInstance, cmock_guts_index); + Mock.vkGetAccelerationStructureHandleNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetAccelerationStructureHandleNV_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetAccelerationStructureHandleNV_CALL_INSTANCE)); + CMOCK_vkGetAccelerationStructureHandleNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureHandleNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetAccelerationStructureHandleNV_CallInstance = CMock_Guts_MemChain(Mock.vkGetAccelerationStructureHandleNV_CallInstance, cmock_guts_index); + Mock.vkGetAccelerationStructureHandleNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetAccelerationStructureHandleNV(cmock_call_instance, device, accelerationStructure, dataSize, pData); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetAccelerationStructureHandleNV_AddCallback(CMOCK_vkGetAccelerationStructureHandleNV_CALLBACK Callback) +{ + Mock.vkGetAccelerationStructureHandleNV_IgnoreBool = (char)0; + Mock.vkGetAccelerationStructureHandleNV_CallbackBool = (char)1; + Mock.vkGetAccelerationStructureHandleNV_CallbackFunctionPointer = Callback; +} + +void vkGetAccelerationStructureHandleNV_Stub(CMOCK_vkGetAccelerationStructureHandleNV_CALLBACK Callback) +{ + Mock.vkGetAccelerationStructureHandleNV_IgnoreBool = (char)0; + Mock.vkGetAccelerationStructureHandleNV_CallbackBool = (char)0; + Mock.vkGetAccelerationStructureHandleNV_CallbackFunctionPointer = Callback; +} + +void vkGetAccelerationStructureHandleNV_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, void const* pData, size_t cmock_size) +{ + CMOCK_vkGetAccelerationStructureHandleNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureHandleNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetAccelerationStructureHandleNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pData_Used = 1; + cmock_call_instance->ReturnThruPtr_pData_Val = pData; + cmock_call_instance->ReturnThruPtr_pData_Size = cmock_size; +} + +void vkGetAccelerationStructureHandleNV_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetAccelerationStructureHandleNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureHandleNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetAccelerationStructureHandleNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetAccelerationStructureHandleNV_CMockIgnoreArg_accelerationStructure(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetAccelerationStructureHandleNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureHandleNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetAccelerationStructureHandleNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_accelerationStructure = 1; +} + +void vkGetAccelerationStructureHandleNV_CMockIgnoreArg_dataSize(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetAccelerationStructureHandleNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureHandleNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetAccelerationStructureHandleNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dataSize = 1; +} + +void vkGetAccelerationStructureHandleNV_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetAccelerationStructureHandleNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureHandleNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetAccelerationStructureHandleNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pData = 1; +} + +void vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdWriteAccelerationStructuresPropertiesNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdWriteAccelerationStructuresPropertiesNV); + cmock_call_instance = (CMOCK_vkCmdWriteAccelerationStructuresPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdWriteAccelerationStructuresPropertiesNV_CallInstance); + Mock.vkCmdWriteAccelerationStructuresPropertiesNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdWriteAccelerationStructuresPropertiesNV_CallInstance); + if (Mock.vkCmdWriteAccelerationStructuresPropertiesNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdWriteAccelerationStructuresPropertiesNV_CallbackBool && + Mock.vkCmdWriteAccelerationStructuresPropertiesNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdWriteAccelerationStructuresPropertiesNV_CallbackFunctionPointer(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery, Mock.vkCmdWriteAccelerationStructuresPropertiesNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteAccelerationStructuresPropertiesNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_accelerationStructureCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteAccelerationStructuresPropertiesNV,CMockString_accelerationStructureCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_accelerationStructureCount, accelerationStructureCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAccelerationStructures) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteAccelerationStructuresPropertiesNV,CMockString_pAccelerationStructures); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAccelerationStructures), (void*)(pAccelerationStructures), sizeof(const VkAccelerationStructureNV), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queryType) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteAccelerationStructuresPropertiesNV,CMockString_queryType); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queryType), (void*)(&queryType), sizeof(VkQueryType), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queryPool) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteAccelerationStructuresPropertiesNV,CMockString_queryPool); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), sizeof(VkQueryPool), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstQuery) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteAccelerationStructuresPropertiesNV,CMockString_firstQuery); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstQuery, firstQuery, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdWriteAccelerationStructuresPropertiesNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdWriteAccelerationStructuresPropertiesNV_CallbackFunctionPointer(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery, Mock.vkCmdWriteAccelerationStructuresPropertiesNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdWriteAccelerationStructuresPropertiesNV(CMOCK_vkCmdWriteAccelerationStructuresPropertiesNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); +void CMockExpectParameters_vkCmdWriteAccelerationStructuresPropertiesNV(CMOCK_vkCmdWriteAccelerationStructuresPropertiesNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_accelerationStructureCount = accelerationStructureCount; + cmock_call_instance->IgnoreArg_accelerationStructureCount = 0; + cmock_call_instance->Expected_pAccelerationStructures = pAccelerationStructures; + cmock_call_instance->IgnoreArg_pAccelerationStructures = 0; + memcpy((void*)(&cmock_call_instance->Expected_queryType), (void*)(&queryType), + sizeof(VkQueryType[sizeof(queryType) == sizeof(VkQueryType) ? 1 : -1])); /* add VkQueryType to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queryType = 0; + memcpy((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), + sizeof(VkQueryPool[sizeof(queryPool) == sizeof(VkQueryPool) ? 1 : -1])); /* add VkQueryPool to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queryPool = 0; + cmock_call_instance->Expected_firstQuery = firstQuery; + cmock_call_instance->IgnoreArg_firstQuery = 0; +} + +void vkCmdWriteAccelerationStructuresPropertiesNV_CMockIgnore(void) +{ + Mock.vkCmdWriteAccelerationStructuresPropertiesNV_IgnoreBool = (char)1; +} + +void vkCmdWriteAccelerationStructuresPropertiesNV_CMockStopIgnore(void) +{ + Mock.vkCmdWriteAccelerationStructuresPropertiesNV_IgnoreBool = (char)0; +} + +void vkCmdWriteAccelerationStructuresPropertiesNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdWriteAccelerationStructuresPropertiesNV_CALL_INSTANCE)); + CMOCK_vkCmdWriteAccelerationStructuresPropertiesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteAccelerationStructuresPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdWriteAccelerationStructuresPropertiesNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdWriteAccelerationStructuresPropertiesNV_CallInstance, cmock_guts_index); + Mock.vkCmdWriteAccelerationStructuresPropertiesNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdWriteAccelerationStructuresPropertiesNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdWriteAccelerationStructuresPropertiesNV_CALL_INSTANCE)); + CMOCK_vkCmdWriteAccelerationStructuresPropertiesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteAccelerationStructuresPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdWriteAccelerationStructuresPropertiesNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdWriteAccelerationStructuresPropertiesNV_CallInstance, cmock_guts_index); + Mock.vkCmdWriteAccelerationStructuresPropertiesNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdWriteAccelerationStructuresPropertiesNV(cmock_call_instance, commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); +} + +void vkCmdWriteAccelerationStructuresPropertiesNV_AddCallback(CMOCK_vkCmdWriteAccelerationStructuresPropertiesNV_CALLBACK Callback) +{ + Mock.vkCmdWriteAccelerationStructuresPropertiesNV_IgnoreBool = (char)0; + Mock.vkCmdWriteAccelerationStructuresPropertiesNV_CallbackBool = (char)1; + Mock.vkCmdWriteAccelerationStructuresPropertiesNV_CallbackFunctionPointer = Callback; +} + +void vkCmdWriteAccelerationStructuresPropertiesNV_Stub(CMOCK_vkCmdWriteAccelerationStructuresPropertiesNV_CALLBACK Callback) +{ + Mock.vkCmdWriteAccelerationStructuresPropertiesNV_IgnoreBool = (char)0; + Mock.vkCmdWriteAccelerationStructuresPropertiesNV_CallbackBool = (char)0; + Mock.vkCmdWriteAccelerationStructuresPropertiesNV_CallbackFunctionPointer = Callback; +} + +void vkCmdWriteAccelerationStructuresPropertiesNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteAccelerationStructuresPropertiesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteAccelerationStructuresPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteAccelerationStructuresPropertiesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdWriteAccelerationStructuresPropertiesNV_CMockIgnoreArg_accelerationStructureCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteAccelerationStructuresPropertiesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteAccelerationStructuresPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteAccelerationStructuresPropertiesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_accelerationStructureCount = 1; +} + +void vkCmdWriteAccelerationStructuresPropertiesNV_CMockIgnoreArg_pAccelerationStructures(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteAccelerationStructuresPropertiesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteAccelerationStructuresPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteAccelerationStructuresPropertiesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAccelerationStructures = 1; +} + +void vkCmdWriteAccelerationStructuresPropertiesNV_CMockIgnoreArg_queryType(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteAccelerationStructuresPropertiesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteAccelerationStructuresPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteAccelerationStructuresPropertiesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queryType = 1; +} + +void vkCmdWriteAccelerationStructuresPropertiesNV_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteAccelerationStructuresPropertiesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteAccelerationStructuresPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteAccelerationStructuresPropertiesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queryPool = 1; +} + +void vkCmdWriteAccelerationStructuresPropertiesNV_CMockIgnoreArg_firstQuery(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteAccelerationStructuresPropertiesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteAccelerationStructuresPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteAccelerationStructuresPropertiesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstQuery = 1; +} + +VkResult vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCompileDeferredNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCompileDeferredNV); + cmock_call_instance = (CMOCK_vkCompileDeferredNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCompileDeferredNV_CallInstance); + Mock.vkCompileDeferredNV_CallInstance = CMock_Guts_MemNext(Mock.vkCompileDeferredNV_CallInstance); + if (Mock.vkCompileDeferredNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCompileDeferredNV_FinalReturn; + memcpy((void*)(&Mock.vkCompileDeferredNV_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCompileDeferredNV_CallbackBool && + Mock.vkCompileDeferredNV_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCompileDeferredNV_CallbackFunctionPointer(device, pipeline, shader, Mock.vkCompileDeferredNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCompileDeferredNV,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pipeline) + { + UNITY_SET_DETAILS(CMockString_vkCompileDeferredNV,CMockString_pipeline); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_pipeline), (void*)(&pipeline), sizeof(VkPipeline), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_shader) + { + UNITY_SET_DETAILS(CMockString_vkCompileDeferredNV,CMockString_shader); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_shader, shader, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCompileDeferredNV_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCompileDeferredNV_CallbackFunctionPointer(device, pipeline, shader, Mock.vkCompileDeferredNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCompileDeferredNV(CMOCK_vkCompileDeferredNV_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPipeline pipeline, uint32_t shader); +void CMockExpectParameters_vkCompileDeferredNV(CMOCK_vkCompileDeferredNV_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPipeline pipeline, uint32_t shader) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_pipeline), (void*)(&pipeline), + sizeof(VkPipeline[sizeof(pipeline) == sizeof(VkPipeline) ? 1 : -1])); /* add VkPipeline to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_pipeline = 0; + cmock_call_instance->Expected_shader = shader; + cmock_call_instance->IgnoreArg_shader = 0; +} + +void vkCompileDeferredNV_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCompileDeferredNV_CALL_INSTANCE)); + CMOCK_vkCompileDeferredNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCompileDeferredNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCompileDeferredNV_CallInstance = CMock_Guts_MemChain(Mock.vkCompileDeferredNV_CallInstance, cmock_guts_index); + Mock.vkCompileDeferredNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCompileDeferredNV_IgnoreBool = (char)1; +} + +void vkCompileDeferredNV_CMockStopIgnore(void) +{ + if(Mock.vkCompileDeferredNV_IgnoreBool) + Mock.vkCompileDeferredNV_CallInstance = CMock_Guts_MemNext(Mock.vkCompileDeferredNV_CallInstance); + Mock.vkCompileDeferredNV_IgnoreBool = (char)0; +} + +void vkCompileDeferredNV_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCompileDeferredNV_CALL_INSTANCE)); + CMOCK_vkCompileDeferredNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCompileDeferredNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCompileDeferredNV_CallInstance = CMock_Guts_MemChain(Mock.vkCompileDeferredNV_CallInstance, cmock_guts_index); + Mock.vkCompileDeferredNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCompileDeferredNV_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPipeline pipeline, uint32_t shader, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCompileDeferredNV_CALL_INSTANCE)); + CMOCK_vkCompileDeferredNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCompileDeferredNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCompileDeferredNV_CallInstance = CMock_Guts_MemChain(Mock.vkCompileDeferredNV_CallInstance, cmock_guts_index); + Mock.vkCompileDeferredNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCompileDeferredNV(cmock_call_instance, device, pipeline, shader); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCompileDeferredNV_AddCallback(CMOCK_vkCompileDeferredNV_CALLBACK Callback) +{ + Mock.vkCompileDeferredNV_IgnoreBool = (char)0; + Mock.vkCompileDeferredNV_CallbackBool = (char)1; + Mock.vkCompileDeferredNV_CallbackFunctionPointer = Callback; +} + +void vkCompileDeferredNV_Stub(CMOCK_vkCompileDeferredNV_CALLBACK Callback) +{ + Mock.vkCompileDeferredNV_IgnoreBool = (char)0; + Mock.vkCompileDeferredNV_CallbackBool = (char)0; + Mock.vkCompileDeferredNV_CallbackFunctionPointer = Callback; +} + +void vkCompileDeferredNV_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCompileDeferredNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCompileDeferredNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCompileDeferredNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCompileDeferredNV_CMockIgnoreArg_pipeline(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCompileDeferredNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCompileDeferredNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCompileDeferredNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pipeline = 1; +} + +void vkCompileDeferredNV_CMockIgnoreArg_shader(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCompileDeferredNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCompileDeferredNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCompileDeferredNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_shader = 1; +} + +VkResult vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetMemoryHostPointerPropertiesEXT); + cmock_call_instance = (CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetMemoryHostPointerPropertiesEXT_CallInstance); + Mock.vkGetMemoryHostPointerPropertiesEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetMemoryHostPointerPropertiesEXT_CallInstance); + if (Mock.vkGetMemoryHostPointerPropertiesEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetMemoryHostPointerPropertiesEXT_FinalReturn; + memcpy((void*)(&Mock.vkGetMemoryHostPointerPropertiesEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetMemoryHostPointerPropertiesEXT_CallbackBool && + Mock.vkGetMemoryHostPointerPropertiesEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetMemoryHostPointerPropertiesEXT_CallbackFunctionPointer(device, handleType, pHostPointer, pMemoryHostPointerProperties, Mock.vkGetMemoryHostPointerPropertiesEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetMemoryHostPointerPropertiesEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_handleType) + { + UNITY_SET_DETAILS(CMockString_vkGetMemoryHostPointerPropertiesEXT,CMockString_handleType); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_handleType), (void*)(&handleType), sizeof(VkExternalMemoryHandleTypeFlagBits), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pHostPointer) + { + UNITY_SET_DETAILS(CMockString_vkGetMemoryHostPointerPropertiesEXT,CMockString_pHostPointer); + if (cmock_call_instance->Expected_pHostPointer == NULL) + { UNITY_TEST_ASSERT_NULL(pHostPointer, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(cmock_call_instance->Expected_pHostPointer, pHostPointer, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pMemoryHostPointerProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetMemoryHostPointerPropertiesEXT,CMockString_pMemoryHostPointerProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMemoryHostPointerProperties), (void*)(pMemoryHostPointerProperties), sizeof(VkMemoryHostPointerPropertiesEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetMemoryHostPointerPropertiesEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetMemoryHostPointerPropertiesEXT_CallbackFunctionPointer(device, handleType, pHostPointer, pMemoryHostPointerProperties, Mock.vkGetMemoryHostPointerPropertiesEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pMemoryHostPointerProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pMemoryHostPointerProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pMemoryHostPointerProperties, (const void*)cmock_call_instance->ReturnThruPtr_pMemoryHostPointerProperties_Val, + cmock_call_instance->ReturnThruPtr_pMemoryHostPointerProperties_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetMemoryHostPointerPropertiesEXT(CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); +void CMockExpectParameters_vkGetMemoryHostPointerPropertiesEXT(CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_handleType), (void*)(&handleType), + sizeof(VkExternalMemoryHandleTypeFlagBits[sizeof(handleType) == sizeof(VkExternalMemoryHandleTypeFlagBits) ? 1 : -1])); /* add VkExternalMemoryHandleTypeFlagBits to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_handleType = 0; + cmock_call_instance->Expected_pHostPointer = pHostPointer; + cmock_call_instance->IgnoreArg_pHostPointer = 0; + cmock_call_instance->Expected_pMemoryHostPointerProperties = pMemoryHostPointerProperties; + cmock_call_instance->IgnoreArg_pMemoryHostPointerProperties = 0; + cmock_call_instance->ReturnThruPtr_pMemoryHostPointerProperties_Used = 0; +} + +void vkGetMemoryHostPointerPropertiesEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALL_INSTANCE)); + CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetMemoryHostPointerPropertiesEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetMemoryHostPointerPropertiesEXT_CallInstance, cmock_guts_index); + Mock.vkGetMemoryHostPointerPropertiesEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetMemoryHostPointerPropertiesEXT_IgnoreBool = (char)1; +} + +void vkGetMemoryHostPointerPropertiesEXT_CMockStopIgnore(void) +{ + if(Mock.vkGetMemoryHostPointerPropertiesEXT_IgnoreBool) + Mock.vkGetMemoryHostPointerPropertiesEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetMemoryHostPointerPropertiesEXT_CallInstance); + Mock.vkGetMemoryHostPointerPropertiesEXT_IgnoreBool = (char)0; +} + +void vkGetMemoryHostPointerPropertiesEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALL_INSTANCE)); + CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetMemoryHostPointerPropertiesEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetMemoryHostPointerPropertiesEXT_CallInstance, cmock_guts_index); + Mock.vkGetMemoryHostPointerPropertiesEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetMemoryHostPointerPropertiesEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALL_INSTANCE)); + CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetMemoryHostPointerPropertiesEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetMemoryHostPointerPropertiesEXT_CallInstance, cmock_guts_index); + Mock.vkGetMemoryHostPointerPropertiesEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetMemoryHostPointerPropertiesEXT(cmock_call_instance, device, handleType, pHostPointer, pMemoryHostPointerProperties); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetMemoryHostPointerPropertiesEXT_AddCallback(CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALLBACK Callback) +{ + Mock.vkGetMemoryHostPointerPropertiesEXT_IgnoreBool = (char)0; + Mock.vkGetMemoryHostPointerPropertiesEXT_CallbackBool = (char)1; + Mock.vkGetMemoryHostPointerPropertiesEXT_CallbackFunctionPointer = Callback; +} + +void vkGetMemoryHostPointerPropertiesEXT_Stub(CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALLBACK Callback) +{ + Mock.vkGetMemoryHostPointerPropertiesEXT_IgnoreBool = (char)0; + Mock.vkGetMemoryHostPointerPropertiesEXT_CallbackBool = (char)0; + Mock.vkGetMemoryHostPointerPropertiesEXT_CallbackFunctionPointer = Callback; +} + +void vkGetMemoryHostPointerPropertiesEXT_CMockReturnMemThruPtr_pMemoryHostPointerProperties(UNITY_LINE_TYPE cmock_line, VkMemoryHostPointerPropertiesEXT const* pMemoryHostPointerProperties, size_t cmock_size) +{ + CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetMemoryHostPointerPropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pMemoryHostPointerProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pMemoryHostPointerProperties_Val = pMemoryHostPointerProperties; + cmock_call_instance->ReturnThruPtr_pMemoryHostPointerProperties_Size = cmock_size; +} + +void vkGetMemoryHostPointerPropertiesEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetMemoryHostPointerPropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetMemoryHostPointerPropertiesEXT_CMockIgnoreArg_handleType(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetMemoryHostPointerPropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_handleType = 1; +} + +void vkGetMemoryHostPointerPropertiesEXT_CMockIgnoreArg_pHostPointer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetMemoryHostPointerPropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pHostPointer = 1; +} + +void vkGetMemoryHostPointerPropertiesEXT_CMockIgnoreArg_pMemoryHostPointerProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetMemoryHostPointerPropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMemoryHostPointerProperties = 1; +} + +void vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdWriteBufferMarkerAMD_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdWriteBufferMarkerAMD); + cmock_call_instance = (CMOCK_vkCmdWriteBufferMarkerAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdWriteBufferMarkerAMD_CallInstance); + Mock.vkCmdWriteBufferMarkerAMD_CallInstance = CMock_Guts_MemNext(Mock.vkCmdWriteBufferMarkerAMD_CallInstance); + if (Mock.vkCmdWriteBufferMarkerAMD_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdWriteBufferMarkerAMD_CallbackBool && + Mock.vkCmdWriteBufferMarkerAMD_CallbackFunctionPointer != NULL) + { + Mock.vkCmdWriteBufferMarkerAMD_CallbackFunctionPointer(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker, Mock.vkCmdWriteBufferMarkerAMD_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteBufferMarkerAMD,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pipelineStage) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteBufferMarkerAMD,CMockString_pipelineStage); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_pipelineStage), (void*)(&pipelineStage), sizeof(VkPipelineStageFlagBits), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dstBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteBufferMarkerAMD,CMockString_dstBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dstBuffer), (void*)(&dstBuffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dstOffset) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteBufferMarkerAMD,CMockString_dstOffset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dstOffset), (void*)(&dstOffset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_marker) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteBufferMarkerAMD,CMockString_marker); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_marker, marker, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdWriteBufferMarkerAMD_CallbackFunctionPointer != NULL) + { + Mock.vkCmdWriteBufferMarkerAMD_CallbackFunctionPointer(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker, Mock.vkCmdWriteBufferMarkerAMD_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdWriteBufferMarkerAMD(CMOCK_vkCmdWriteBufferMarkerAMD_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker); +void CMockExpectParameters_vkCmdWriteBufferMarkerAMD(CMOCK_vkCmdWriteBufferMarkerAMD_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_pipelineStage), (void*)(&pipelineStage), + sizeof(VkPipelineStageFlagBits[sizeof(pipelineStage) == sizeof(VkPipelineStageFlagBits) ? 1 : -1])); /* add VkPipelineStageFlagBits to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_pipelineStage = 0; + memcpy((void*)(&cmock_call_instance->Expected_dstBuffer), (void*)(&dstBuffer), + sizeof(VkBuffer[sizeof(dstBuffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dstBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_dstOffset), (void*)(&dstOffset), + sizeof(VkDeviceSize[sizeof(dstOffset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dstOffset = 0; + cmock_call_instance->Expected_marker = marker; + cmock_call_instance->IgnoreArg_marker = 0; +} + +void vkCmdWriteBufferMarkerAMD_CMockIgnore(void) +{ + Mock.vkCmdWriteBufferMarkerAMD_IgnoreBool = (char)1; +} + +void vkCmdWriteBufferMarkerAMD_CMockStopIgnore(void) +{ + Mock.vkCmdWriteBufferMarkerAMD_IgnoreBool = (char)0; +} + +void vkCmdWriteBufferMarkerAMD_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdWriteBufferMarkerAMD_CALL_INSTANCE)); + CMOCK_vkCmdWriteBufferMarkerAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteBufferMarkerAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdWriteBufferMarkerAMD_CallInstance = CMock_Guts_MemChain(Mock.vkCmdWriteBufferMarkerAMD_CallInstance, cmock_guts_index); + Mock.vkCmdWriteBufferMarkerAMD_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdWriteBufferMarkerAMD_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdWriteBufferMarkerAMD_CALL_INSTANCE)); + CMOCK_vkCmdWriteBufferMarkerAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteBufferMarkerAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdWriteBufferMarkerAMD_CallInstance = CMock_Guts_MemChain(Mock.vkCmdWriteBufferMarkerAMD_CallInstance, cmock_guts_index); + Mock.vkCmdWriteBufferMarkerAMD_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdWriteBufferMarkerAMD(cmock_call_instance, commandBuffer, pipelineStage, dstBuffer, dstOffset, marker); +} + +void vkCmdWriteBufferMarkerAMD_AddCallback(CMOCK_vkCmdWriteBufferMarkerAMD_CALLBACK Callback) +{ + Mock.vkCmdWriteBufferMarkerAMD_IgnoreBool = (char)0; + Mock.vkCmdWriteBufferMarkerAMD_CallbackBool = (char)1; + Mock.vkCmdWriteBufferMarkerAMD_CallbackFunctionPointer = Callback; +} + +void vkCmdWriteBufferMarkerAMD_Stub(CMOCK_vkCmdWriteBufferMarkerAMD_CALLBACK Callback) +{ + Mock.vkCmdWriteBufferMarkerAMD_IgnoreBool = (char)0; + Mock.vkCmdWriteBufferMarkerAMD_CallbackBool = (char)0; + Mock.vkCmdWriteBufferMarkerAMD_CallbackFunctionPointer = Callback; +} + +void vkCmdWriteBufferMarkerAMD_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteBufferMarkerAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteBufferMarkerAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteBufferMarkerAMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdWriteBufferMarkerAMD_CMockIgnoreArg_pipelineStage(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteBufferMarkerAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteBufferMarkerAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteBufferMarkerAMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pipelineStage = 1; +} + +void vkCmdWriteBufferMarkerAMD_CMockIgnoreArg_dstBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteBufferMarkerAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteBufferMarkerAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteBufferMarkerAMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dstBuffer = 1; +} + +void vkCmdWriteBufferMarkerAMD_CMockIgnoreArg_dstOffset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteBufferMarkerAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteBufferMarkerAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteBufferMarkerAMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dstOffset = 1; +} + +void vkCmdWriteBufferMarkerAMD_CMockIgnoreArg_marker(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteBufferMarkerAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteBufferMarkerAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteBufferMarkerAMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_marker = 1; +} + +VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallInstance); + Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallInstance); + if (Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_FinalReturn; + memcpy((void*)(&Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallbackBool && + Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallbackFunctionPointer(physicalDevice, pTimeDomainCount, pTimeDomains, Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pTimeDomainCount) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,CMockString_pTimeDomainCount); + if (cmock_call_instance->Expected_pTimeDomainCount == NULL) + { UNITY_TEST_ASSERT_NULL(pTimeDomainCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pTimeDomainCount, pTimeDomainCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pTimeDomains) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,CMockString_pTimeDomains); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pTimeDomains), (void*)(pTimeDomains), sizeof(VkTimeDomainEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallbackFunctionPointer(physicalDevice, pTimeDomainCount, pTimeDomains, Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pTimeDomainCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pTimeDomainCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pTimeDomainCount, (const void*)cmock_call_instance->ReturnThruPtr_pTimeDomainCount_Val, + cmock_call_instance->ReturnThruPtr_pTimeDomainCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pTimeDomains_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pTimeDomains, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pTimeDomains, (const void*)cmock_call_instance->ReturnThruPtr_pTimeDomains_Val, + cmock_call_instance->ReturnThruPtr_pTimeDomains_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains); +void CMockExpectParameters_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pTimeDomainCount = pTimeDomainCount; + cmock_call_instance->IgnoreArg_pTimeDomainCount = 0; + cmock_call_instance->ReturnThruPtr_pTimeDomainCount_Used = 0; + cmock_call_instance->Expected_pTimeDomains = pTimeDomains; + cmock_call_instance->IgnoreArg_pTimeDomains = 0; + cmock_call_instance->ReturnThruPtr_pTimeDomains_Used = 0; +} + +void vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockStopIgnore(void) +{ + if(Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_IgnoreBool) + Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallInstance); + Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(cmock_call_instance, physicalDevice, pTimeDomainCount, pTimeDomains); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_AddCallback(CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_Stub(CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockReturnMemThruPtr_pTimeDomainCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pTimeDomainCount, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pTimeDomainCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pTimeDomainCount_Val = pTimeDomainCount; + cmock_call_instance->ReturnThruPtr_pTimeDomainCount_Size = cmock_size; +} + +void vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockReturnMemThruPtr_pTimeDomains(UNITY_LINE_TYPE cmock_line, VkTimeDomainEXT const* pTimeDomains, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pTimeDomains_Used = 1; + cmock_call_instance->ReturnThruPtr_pTimeDomains_Val = pTimeDomains; + cmock_call_instance->ReturnThruPtr_pTimeDomains_Size = cmock_size; +} + +void vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockIgnoreArg_pTimeDomainCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pTimeDomainCount = 1; +} + +void vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockIgnoreArg_pTimeDomains(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pTimeDomains = 1; +} + +VkResult vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetCalibratedTimestampsEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetCalibratedTimestampsEXT); + cmock_call_instance = (CMOCK_vkGetCalibratedTimestampsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetCalibratedTimestampsEXT_CallInstance); + Mock.vkGetCalibratedTimestampsEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetCalibratedTimestampsEXT_CallInstance); + if (Mock.vkGetCalibratedTimestampsEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetCalibratedTimestampsEXT_FinalReturn; + memcpy((void*)(&Mock.vkGetCalibratedTimestampsEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetCalibratedTimestampsEXT_CallbackBool && + Mock.vkGetCalibratedTimestampsEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetCalibratedTimestampsEXT_CallbackFunctionPointer(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation, Mock.vkGetCalibratedTimestampsEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetCalibratedTimestampsEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_timestampCount) + { + UNITY_SET_DETAILS(CMockString_vkGetCalibratedTimestampsEXT,CMockString_timestampCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_timestampCount, timestampCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pTimestampInfos) + { + UNITY_SET_DETAILS(CMockString_vkGetCalibratedTimestampsEXT,CMockString_pTimestampInfos); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pTimestampInfos), (void*)(pTimestampInfos), sizeof(const VkCalibratedTimestampInfoEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pTimestamps) + { + UNITY_SET_DETAILS(CMockString_vkGetCalibratedTimestampsEXT,CMockString_pTimestamps); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pTimestamps), (void*)(pTimestamps), sizeof(uint64_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMaxDeviation) + { + UNITY_SET_DETAILS(CMockString_vkGetCalibratedTimestampsEXT,CMockString_pMaxDeviation); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMaxDeviation), (void*)(pMaxDeviation), sizeof(uint64_t), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetCalibratedTimestampsEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetCalibratedTimestampsEXT_CallbackFunctionPointer(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation, Mock.vkGetCalibratedTimestampsEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pTimestamps_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pTimestamps, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pTimestamps, (const void*)cmock_call_instance->ReturnThruPtr_pTimestamps_Val, + cmock_call_instance->ReturnThruPtr_pTimestamps_Size); + } + if (cmock_call_instance->ReturnThruPtr_pMaxDeviation_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pMaxDeviation, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pMaxDeviation, (const void*)cmock_call_instance->ReturnThruPtr_pMaxDeviation_Val, + cmock_call_instance->ReturnThruPtr_pMaxDeviation_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetCalibratedTimestampsEXT(CMOCK_vkGetCalibratedTimestampsEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation); +void CMockExpectParameters_vkGetCalibratedTimestampsEXT(CMOCK_vkGetCalibratedTimestampsEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_timestampCount = timestampCount; + cmock_call_instance->IgnoreArg_timestampCount = 0; + cmock_call_instance->Expected_pTimestampInfos = pTimestampInfos; + cmock_call_instance->IgnoreArg_pTimestampInfos = 0; + cmock_call_instance->Expected_pTimestamps = pTimestamps; + cmock_call_instance->IgnoreArg_pTimestamps = 0; + cmock_call_instance->ReturnThruPtr_pTimestamps_Used = 0; + cmock_call_instance->Expected_pMaxDeviation = pMaxDeviation; + cmock_call_instance->IgnoreArg_pMaxDeviation = 0; + cmock_call_instance->ReturnThruPtr_pMaxDeviation_Used = 0; +} + +void vkGetCalibratedTimestampsEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetCalibratedTimestampsEXT_CALL_INSTANCE)); + CMOCK_vkGetCalibratedTimestampsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetCalibratedTimestampsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetCalibratedTimestampsEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetCalibratedTimestampsEXT_CallInstance, cmock_guts_index); + Mock.vkGetCalibratedTimestampsEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetCalibratedTimestampsEXT_IgnoreBool = (char)1; +} + +void vkGetCalibratedTimestampsEXT_CMockStopIgnore(void) +{ + if(Mock.vkGetCalibratedTimestampsEXT_IgnoreBool) + Mock.vkGetCalibratedTimestampsEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetCalibratedTimestampsEXT_CallInstance); + Mock.vkGetCalibratedTimestampsEXT_IgnoreBool = (char)0; +} + +void vkGetCalibratedTimestampsEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetCalibratedTimestampsEXT_CALL_INSTANCE)); + CMOCK_vkGetCalibratedTimestampsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetCalibratedTimestampsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetCalibratedTimestampsEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetCalibratedTimestampsEXT_CallInstance, cmock_guts_index); + Mock.vkGetCalibratedTimestampsEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetCalibratedTimestampsEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetCalibratedTimestampsEXT_CALL_INSTANCE)); + CMOCK_vkGetCalibratedTimestampsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetCalibratedTimestampsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetCalibratedTimestampsEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetCalibratedTimestampsEXT_CallInstance, cmock_guts_index); + Mock.vkGetCalibratedTimestampsEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetCalibratedTimestampsEXT(cmock_call_instance, device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetCalibratedTimestampsEXT_AddCallback(CMOCK_vkGetCalibratedTimestampsEXT_CALLBACK Callback) +{ + Mock.vkGetCalibratedTimestampsEXT_IgnoreBool = (char)0; + Mock.vkGetCalibratedTimestampsEXT_CallbackBool = (char)1; + Mock.vkGetCalibratedTimestampsEXT_CallbackFunctionPointer = Callback; +} + +void vkGetCalibratedTimestampsEXT_Stub(CMOCK_vkGetCalibratedTimestampsEXT_CALLBACK Callback) +{ + Mock.vkGetCalibratedTimestampsEXT_IgnoreBool = (char)0; + Mock.vkGetCalibratedTimestampsEXT_CallbackBool = (char)0; + Mock.vkGetCalibratedTimestampsEXT_CallbackFunctionPointer = Callback; +} + +void vkGetCalibratedTimestampsEXT_CMockReturnMemThruPtr_pTimestamps(UNITY_LINE_TYPE cmock_line, uint64_t const* pTimestamps, size_t cmock_size) +{ + CMOCK_vkGetCalibratedTimestampsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetCalibratedTimestampsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetCalibratedTimestampsEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pTimestamps_Used = 1; + cmock_call_instance->ReturnThruPtr_pTimestamps_Val = pTimestamps; + cmock_call_instance->ReturnThruPtr_pTimestamps_Size = cmock_size; +} + +void vkGetCalibratedTimestampsEXT_CMockReturnMemThruPtr_pMaxDeviation(UNITY_LINE_TYPE cmock_line, uint64_t const* pMaxDeviation, size_t cmock_size) +{ + CMOCK_vkGetCalibratedTimestampsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetCalibratedTimestampsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetCalibratedTimestampsEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pMaxDeviation_Used = 1; + cmock_call_instance->ReturnThruPtr_pMaxDeviation_Val = pMaxDeviation; + cmock_call_instance->ReturnThruPtr_pMaxDeviation_Size = cmock_size; +} + +void vkGetCalibratedTimestampsEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetCalibratedTimestampsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetCalibratedTimestampsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetCalibratedTimestampsEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetCalibratedTimestampsEXT_CMockIgnoreArg_timestampCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetCalibratedTimestampsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetCalibratedTimestampsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetCalibratedTimestampsEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_timestampCount = 1; +} + +void vkGetCalibratedTimestampsEXT_CMockIgnoreArg_pTimestampInfos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetCalibratedTimestampsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetCalibratedTimestampsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetCalibratedTimestampsEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pTimestampInfos = 1; +} + +void vkGetCalibratedTimestampsEXT_CMockIgnoreArg_pTimestamps(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetCalibratedTimestampsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetCalibratedTimestampsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetCalibratedTimestampsEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pTimestamps = 1; +} + +void vkGetCalibratedTimestampsEXT_CMockIgnoreArg_pMaxDeviation(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetCalibratedTimestampsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetCalibratedTimestampsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetCalibratedTimestampsEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMaxDeviation = 1; +} + +void vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDrawMeshTasksNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDrawMeshTasksNV); + cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDrawMeshTasksNV_CallInstance); + Mock.vkCmdDrawMeshTasksNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDrawMeshTasksNV_CallInstance); + if (Mock.vkCmdDrawMeshTasksNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDrawMeshTasksNV_CallbackBool && + Mock.vkCmdDrawMeshTasksNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawMeshTasksNV_CallbackFunctionPointer(commandBuffer, taskCount, firstTask, Mock.vkCmdDrawMeshTasksNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_taskCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksNV,CMockString_taskCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_taskCount, taskCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstTask) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksNV,CMockString_firstTask); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstTask, firstTask, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdDrawMeshTasksNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawMeshTasksNV_CallbackFunctionPointer(commandBuffer, taskCount, firstTask, Mock.vkCmdDrawMeshTasksNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDrawMeshTasksNV(CMOCK_vkCmdDrawMeshTasksNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask); +void CMockExpectParameters_vkCmdDrawMeshTasksNV(CMOCK_vkCmdDrawMeshTasksNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_taskCount = taskCount; + cmock_call_instance->IgnoreArg_taskCount = 0; + cmock_call_instance->Expected_firstTask = firstTask; + cmock_call_instance->IgnoreArg_firstTask = 0; +} + +void vkCmdDrawMeshTasksNV_CMockIgnore(void) +{ + Mock.vkCmdDrawMeshTasksNV_IgnoreBool = (char)1; +} + +void vkCmdDrawMeshTasksNV_CMockStopIgnore(void) +{ + Mock.vkCmdDrawMeshTasksNV_IgnoreBool = (char)0; +} + +void vkCmdDrawMeshTasksNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawMeshTasksNV_CALL_INSTANCE)); + CMOCK_vkCmdDrawMeshTasksNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawMeshTasksNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawMeshTasksNV_CallInstance, cmock_guts_index); + Mock.vkCmdDrawMeshTasksNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDrawMeshTasksNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawMeshTasksNV_CALL_INSTANCE)); + CMOCK_vkCmdDrawMeshTasksNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawMeshTasksNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawMeshTasksNV_CallInstance, cmock_guts_index); + Mock.vkCmdDrawMeshTasksNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDrawMeshTasksNV(cmock_call_instance, commandBuffer, taskCount, firstTask); +} + +void vkCmdDrawMeshTasksNV_AddCallback(CMOCK_vkCmdDrawMeshTasksNV_CALLBACK Callback) +{ + Mock.vkCmdDrawMeshTasksNV_IgnoreBool = (char)0; + Mock.vkCmdDrawMeshTasksNV_CallbackBool = (char)1; + Mock.vkCmdDrawMeshTasksNV_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawMeshTasksNV_Stub(CMOCK_vkCmdDrawMeshTasksNV_CALLBACK Callback) +{ + Mock.vkCmdDrawMeshTasksNV_IgnoreBool = (char)0; + Mock.vkCmdDrawMeshTasksNV_CallbackBool = (char)0; + Mock.vkCmdDrawMeshTasksNV_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawMeshTasksNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDrawMeshTasksNV_CMockIgnoreArg_taskCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_taskCount = 1; +} + +void vkCmdDrawMeshTasksNV_CMockIgnoreArg_firstTask(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstTask = 1; +} + +void vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDrawMeshTasksIndirectNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDrawMeshTasksIndirectNV); + cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDrawMeshTasksIndirectNV_CallInstance); + Mock.vkCmdDrawMeshTasksIndirectNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDrawMeshTasksIndirectNV_CallInstance); + if (Mock.vkCmdDrawMeshTasksIndirectNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDrawMeshTasksIndirectNV_CallbackBool && + Mock.vkCmdDrawMeshTasksIndirectNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawMeshTasksIndirectNV_CallbackFunctionPointer(commandBuffer, buffer, offset, drawCount, stride, Mock.vkCmdDrawMeshTasksIndirectNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksIndirectNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_buffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksIndirectNV,CMockString_buffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_offset) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksIndirectNV,CMockString_offset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_drawCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksIndirectNV,CMockString_drawCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_drawCount, drawCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_stride) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksIndirectNV,CMockString_stride); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_stride, stride, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdDrawMeshTasksIndirectNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawMeshTasksIndirectNV_CallbackFunctionPointer(commandBuffer, buffer, offset, drawCount, stride, Mock.vkCmdDrawMeshTasksIndirectNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDrawMeshTasksIndirectNV(CMOCK_vkCmdDrawMeshTasksIndirectNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +void CMockExpectParameters_vkCmdDrawMeshTasksIndirectNV(CMOCK_vkCmdDrawMeshTasksIndirectNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), + sizeof(VkBuffer[sizeof(buffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_buffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), + sizeof(VkDeviceSize[sizeof(offset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_offset = 0; + cmock_call_instance->Expected_drawCount = drawCount; + cmock_call_instance->IgnoreArg_drawCount = 0; + cmock_call_instance->Expected_stride = stride; + cmock_call_instance->IgnoreArg_stride = 0; +} + +void vkCmdDrawMeshTasksIndirectNV_CMockIgnore(void) +{ + Mock.vkCmdDrawMeshTasksIndirectNV_IgnoreBool = (char)1; +} + +void vkCmdDrawMeshTasksIndirectNV_CMockStopIgnore(void) +{ + Mock.vkCmdDrawMeshTasksIndirectNV_IgnoreBool = (char)0; +} + +void vkCmdDrawMeshTasksIndirectNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawMeshTasksIndirectNV_CALL_INSTANCE)); + CMOCK_vkCmdDrawMeshTasksIndirectNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawMeshTasksIndirectNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawMeshTasksIndirectNV_CallInstance, cmock_guts_index); + Mock.vkCmdDrawMeshTasksIndirectNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDrawMeshTasksIndirectNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawMeshTasksIndirectNV_CALL_INSTANCE)); + CMOCK_vkCmdDrawMeshTasksIndirectNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawMeshTasksIndirectNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawMeshTasksIndirectNV_CallInstance, cmock_guts_index); + Mock.vkCmdDrawMeshTasksIndirectNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDrawMeshTasksIndirectNV(cmock_call_instance, commandBuffer, buffer, offset, drawCount, stride); +} + +void vkCmdDrawMeshTasksIndirectNV_AddCallback(CMOCK_vkCmdDrawMeshTasksIndirectNV_CALLBACK Callback) +{ + Mock.vkCmdDrawMeshTasksIndirectNV_IgnoreBool = (char)0; + Mock.vkCmdDrawMeshTasksIndirectNV_CallbackBool = (char)1; + Mock.vkCmdDrawMeshTasksIndirectNV_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawMeshTasksIndirectNV_Stub(CMOCK_vkCmdDrawMeshTasksIndirectNV_CALLBACK Callback) +{ + Mock.vkCmdDrawMeshTasksIndirectNV_IgnoreBool = (char)0; + Mock.vkCmdDrawMeshTasksIndirectNV_CallbackBool = (char)0; + Mock.vkCmdDrawMeshTasksIndirectNV_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawMeshTasksIndirectNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksIndirectNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksIndirectNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDrawMeshTasksIndirectNV_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksIndirectNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksIndirectNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_buffer = 1; +} + +void vkCmdDrawMeshTasksIndirectNV_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksIndirectNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksIndirectNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_offset = 1; +} + +void vkCmdDrawMeshTasksIndirectNV_CMockIgnoreArg_drawCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksIndirectNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksIndirectNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_drawCount = 1; +} + +void vkCmdDrawMeshTasksIndirectNV_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksIndirectNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksIndirectNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stride = 1; +} + +void vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDrawMeshTasksIndirectCountNV); + cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDrawMeshTasksIndirectCountNV_CallInstance); + Mock.vkCmdDrawMeshTasksIndirectCountNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDrawMeshTasksIndirectCountNV_CallInstance); + if (Mock.vkCmdDrawMeshTasksIndirectCountNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDrawMeshTasksIndirectCountNV_CallbackBool && + Mock.vkCmdDrawMeshTasksIndirectCountNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawMeshTasksIndirectCountNV_CallbackFunctionPointer(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, Mock.vkCmdDrawMeshTasksIndirectCountNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksIndirectCountNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_buffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksIndirectCountNV,CMockString_buffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_offset) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksIndirectCountNV,CMockString_offset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_countBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksIndirectCountNV,CMockString_countBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_countBuffer), (void*)(&countBuffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_countBufferOffset) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksIndirectCountNV,CMockString_countBufferOffset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_countBufferOffset), (void*)(&countBufferOffset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_maxDrawCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksIndirectCountNV,CMockString_maxDrawCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_maxDrawCount, maxDrawCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_stride) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksIndirectCountNV,CMockString_stride); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_stride, stride, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdDrawMeshTasksIndirectCountNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawMeshTasksIndirectCountNV_CallbackFunctionPointer(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, Mock.vkCmdDrawMeshTasksIndirectCountNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDrawMeshTasksIndirectCountNV(CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +void CMockExpectParameters_vkCmdDrawMeshTasksIndirectCountNV(CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), + sizeof(VkBuffer[sizeof(buffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_buffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), + sizeof(VkDeviceSize[sizeof(offset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_offset = 0; + memcpy((void*)(&cmock_call_instance->Expected_countBuffer), (void*)(&countBuffer), + sizeof(VkBuffer[sizeof(countBuffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_countBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_countBufferOffset), (void*)(&countBufferOffset), + sizeof(VkDeviceSize[sizeof(countBufferOffset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_countBufferOffset = 0; + cmock_call_instance->Expected_maxDrawCount = maxDrawCount; + cmock_call_instance->IgnoreArg_maxDrawCount = 0; + cmock_call_instance->Expected_stride = stride; + cmock_call_instance->IgnoreArg_stride = 0; +} + +void vkCmdDrawMeshTasksIndirectCountNV_CMockIgnore(void) +{ + Mock.vkCmdDrawMeshTasksIndirectCountNV_IgnoreBool = (char)1; +} + +void vkCmdDrawMeshTasksIndirectCountNV_CMockStopIgnore(void) +{ + Mock.vkCmdDrawMeshTasksIndirectCountNV_IgnoreBool = (char)0; +} + +void vkCmdDrawMeshTasksIndirectCountNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALL_INSTANCE)); + CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawMeshTasksIndirectCountNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawMeshTasksIndirectCountNV_CallInstance, cmock_guts_index); + Mock.vkCmdDrawMeshTasksIndirectCountNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDrawMeshTasksIndirectCountNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALL_INSTANCE)); + CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawMeshTasksIndirectCountNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawMeshTasksIndirectCountNV_CallInstance, cmock_guts_index); + Mock.vkCmdDrawMeshTasksIndirectCountNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDrawMeshTasksIndirectCountNV(cmock_call_instance, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); +} + +void vkCmdDrawMeshTasksIndirectCountNV_AddCallback(CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALLBACK Callback) +{ + Mock.vkCmdDrawMeshTasksIndirectCountNV_IgnoreBool = (char)0; + Mock.vkCmdDrawMeshTasksIndirectCountNV_CallbackBool = (char)1; + Mock.vkCmdDrawMeshTasksIndirectCountNV_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawMeshTasksIndirectCountNV_Stub(CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALLBACK Callback) +{ + Mock.vkCmdDrawMeshTasksIndirectCountNV_IgnoreBool = (char)0; + Mock.vkCmdDrawMeshTasksIndirectCountNV_CallbackBool = (char)0; + Mock.vkCmdDrawMeshTasksIndirectCountNV_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawMeshTasksIndirectCountNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksIndirectCountNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDrawMeshTasksIndirectCountNV_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksIndirectCountNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_buffer = 1; +} + +void vkCmdDrawMeshTasksIndirectCountNV_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksIndirectCountNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_offset = 1; +} + +void vkCmdDrawMeshTasksIndirectCountNV_CMockIgnoreArg_countBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksIndirectCountNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_countBuffer = 1; +} + +void vkCmdDrawMeshTasksIndirectCountNV_CMockIgnoreArg_countBufferOffset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksIndirectCountNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_countBufferOffset = 1; +} + +void vkCmdDrawMeshTasksIndirectCountNV_CMockIgnoreArg_maxDrawCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksIndirectCountNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_maxDrawCount = 1; +} + +void vkCmdDrawMeshTasksIndirectCountNV_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksIndirectCountNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stride = 1; +} + +void vkCmdSetExclusiveScissorEnableNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkBool32* pExclusiveScissorEnables) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetExclusiveScissorEnableNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetExclusiveScissorEnableNV); + cmock_call_instance = (CMOCK_vkCmdSetExclusiveScissorEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetExclusiveScissorEnableNV_CallInstance); + Mock.vkCmdSetExclusiveScissorEnableNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetExclusiveScissorEnableNV_CallInstance); + if (Mock.vkCmdSetExclusiveScissorEnableNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetExclusiveScissorEnableNV_CallbackBool && + Mock.vkCmdSetExclusiveScissorEnableNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetExclusiveScissorEnableNV_CallbackFunctionPointer(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables, Mock.vkCmdSetExclusiveScissorEnableNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetExclusiveScissorEnableNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstExclusiveScissor) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetExclusiveScissorEnableNV,CMockString_firstExclusiveScissor); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstExclusiveScissor, firstExclusiveScissor, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_exclusiveScissorCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetExclusiveScissorEnableNV,CMockString_exclusiveScissorCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_exclusiveScissorCount, exclusiveScissorCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pExclusiveScissorEnables) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetExclusiveScissorEnableNV,CMockString_pExclusiveScissorEnables); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pExclusiveScissorEnables), (void*)(pExclusiveScissorEnables), sizeof(const VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetExclusiveScissorEnableNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetExclusiveScissorEnableNV_CallbackFunctionPointer(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables, Mock.vkCmdSetExclusiveScissorEnableNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetExclusiveScissorEnableNV(CMOCK_vkCmdSetExclusiveScissorEnableNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkBool32* pExclusiveScissorEnables); +void CMockExpectParameters_vkCmdSetExclusiveScissorEnableNV(CMOCK_vkCmdSetExclusiveScissorEnableNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkBool32* pExclusiveScissorEnables) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_firstExclusiveScissor = firstExclusiveScissor; + cmock_call_instance->IgnoreArg_firstExclusiveScissor = 0; + cmock_call_instance->Expected_exclusiveScissorCount = exclusiveScissorCount; + cmock_call_instance->IgnoreArg_exclusiveScissorCount = 0; + cmock_call_instance->Expected_pExclusiveScissorEnables = pExclusiveScissorEnables; + cmock_call_instance->IgnoreArg_pExclusiveScissorEnables = 0; +} + +void vkCmdSetExclusiveScissorEnableNV_CMockIgnore(void) +{ + Mock.vkCmdSetExclusiveScissorEnableNV_IgnoreBool = (char)1; +} + +void vkCmdSetExclusiveScissorEnableNV_CMockStopIgnore(void) +{ + Mock.vkCmdSetExclusiveScissorEnableNV_IgnoreBool = (char)0; +} + +void vkCmdSetExclusiveScissorEnableNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetExclusiveScissorEnableNV_CALL_INSTANCE)); + CMOCK_vkCmdSetExclusiveScissorEnableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetExclusiveScissorEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetExclusiveScissorEnableNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetExclusiveScissorEnableNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetExclusiveScissorEnableNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetExclusiveScissorEnableNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkBool32* pExclusiveScissorEnables) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetExclusiveScissorEnableNV_CALL_INSTANCE)); + CMOCK_vkCmdSetExclusiveScissorEnableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetExclusiveScissorEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetExclusiveScissorEnableNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetExclusiveScissorEnableNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetExclusiveScissorEnableNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetExclusiveScissorEnableNV(cmock_call_instance, commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables); +} + +void vkCmdSetExclusiveScissorEnableNV_AddCallback(CMOCK_vkCmdSetExclusiveScissorEnableNV_CALLBACK Callback) +{ + Mock.vkCmdSetExclusiveScissorEnableNV_IgnoreBool = (char)0; + Mock.vkCmdSetExclusiveScissorEnableNV_CallbackBool = (char)1; + Mock.vkCmdSetExclusiveScissorEnableNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetExclusiveScissorEnableNV_Stub(CMOCK_vkCmdSetExclusiveScissorEnableNV_CALLBACK Callback) +{ + Mock.vkCmdSetExclusiveScissorEnableNV_IgnoreBool = (char)0; + Mock.vkCmdSetExclusiveScissorEnableNV_CallbackBool = (char)0; + Mock.vkCmdSetExclusiveScissorEnableNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetExclusiveScissorEnableNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetExclusiveScissorEnableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetExclusiveScissorEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetExclusiveScissorEnableNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetExclusiveScissorEnableNV_CMockIgnoreArg_firstExclusiveScissor(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetExclusiveScissorEnableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetExclusiveScissorEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetExclusiveScissorEnableNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstExclusiveScissor = 1; +} + +void vkCmdSetExclusiveScissorEnableNV_CMockIgnoreArg_exclusiveScissorCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetExclusiveScissorEnableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetExclusiveScissorEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetExclusiveScissorEnableNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_exclusiveScissorCount = 1; +} + +void vkCmdSetExclusiveScissorEnableNV_CMockIgnoreArg_pExclusiveScissorEnables(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetExclusiveScissorEnableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetExclusiveScissorEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetExclusiveScissorEnableNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pExclusiveScissorEnables = 1; +} + +void vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetExclusiveScissorNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetExclusiveScissorNV); + cmock_call_instance = (CMOCK_vkCmdSetExclusiveScissorNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetExclusiveScissorNV_CallInstance); + Mock.vkCmdSetExclusiveScissorNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetExclusiveScissorNV_CallInstance); + if (Mock.vkCmdSetExclusiveScissorNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetExclusiveScissorNV_CallbackBool && + Mock.vkCmdSetExclusiveScissorNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetExclusiveScissorNV_CallbackFunctionPointer(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors, Mock.vkCmdSetExclusiveScissorNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetExclusiveScissorNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstExclusiveScissor) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetExclusiveScissorNV,CMockString_firstExclusiveScissor); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstExclusiveScissor, firstExclusiveScissor, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_exclusiveScissorCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetExclusiveScissorNV,CMockString_exclusiveScissorCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_exclusiveScissorCount, exclusiveScissorCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pExclusiveScissors) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetExclusiveScissorNV,CMockString_pExclusiveScissors); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pExclusiveScissors), (void*)(pExclusiveScissors), sizeof(const VkRect2D), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetExclusiveScissorNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetExclusiveScissorNV_CallbackFunctionPointer(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors, Mock.vkCmdSetExclusiveScissorNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetExclusiveScissorNV(CMOCK_vkCmdSetExclusiveScissorNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors); +void CMockExpectParameters_vkCmdSetExclusiveScissorNV(CMOCK_vkCmdSetExclusiveScissorNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_firstExclusiveScissor = firstExclusiveScissor; + cmock_call_instance->IgnoreArg_firstExclusiveScissor = 0; + cmock_call_instance->Expected_exclusiveScissorCount = exclusiveScissorCount; + cmock_call_instance->IgnoreArg_exclusiveScissorCount = 0; + cmock_call_instance->Expected_pExclusiveScissors = pExclusiveScissors; + cmock_call_instance->IgnoreArg_pExclusiveScissors = 0; +} + +void vkCmdSetExclusiveScissorNV_CMockIgnore(void) +{ + Mock.vkCmdSetExclusiveScissorNV_IgnoreBool = (char)1; +} + +void vkCmdSetExclusiveScissorNV_CMockStopIgnore(void) +{ + Mock.vkCmdSetExclusiveScissorNV_IgnoreBool = (char)0; +} + +void vkCmdSetExclusiveScissorNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetExclusiveScissorNV_CALL_INSTANCE)); + CMOCK_vkCmdSetExclusiveScissorNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetExclusiveScissorNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetExclusiveScissorNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetExclusiveScissorNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetExclusiveScissorNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetExclusiveScissorNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetExclusiveScissorNV_CALL_INSTANCE)); + CMOCK_vkCmdSetExclusiveScissorNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetExclusiveScissorNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetExclusiveScissorNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetExclusiveScissorNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetExclusiveScissorNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetExclusiveScissorNV(cmock_call_instance, commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors); +} + +void vkCmdSetExclusiveScissorNV_AddCallback(CMOCK_vkCmdSetExclusiveScissorNV_CALLBACK Callback) +{ + Mock.vkCmdSetExclusiveScissorNV_IgnoreBool = (char)0; + Mock.vkCmdSetExclusiveScissorNV_CallbackBool = (char)1; + Mock.vkCmdSetExclusiveScissorNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetExclusiveScissorNV_Stub(CMOCK_vkCmdSetExclusiveScissorNV_CALLBACK Callback) +{ + Mock.vkCmdSetExclusiveScissorNV_IgnoreBool = (char)0; + Mock.vkCmdSetExclusiveScissorNV_CallbackBool = (char)0; + Mock.vkCmdSetExclusiveScissorNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetExclusiveScissorNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetExclusiveScissorNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetExclusiveScissorNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetExclusiveScissorNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetExclusiveScissorNV_CMockIgnoreArg_firstExclusiveScissor(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetExclusiveScissorNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetExclusiveScissorNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetExclusiveScissorNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstExclusiveScissor = 1; +} + +void vkCmdSetExclusiveScissorNV_CMockIgnoreArg_exclusiveScissorCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetExclusiveScissorNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetExclusiveScissorNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetExclusiveScissorNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_exclusiveScissorCount = 1; +} + +void vkCmdSetExclusiveScissorNV_CMockIgnoreArg_pExclusiveScissors(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetExclusiveScissorNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetExclusiveScissorNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetExclusiveScissorNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pExclusiveScissors = 1; +} + +void vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void* pCheckpointMarker) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetCheckpointNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetCheckpointNV); + cmock_call_instance = (CMOCK_vkCmdSetCheckpointNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetCheckpointNV_CallInstance); + Mock.vkCmdSetCheckpointNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetCheckpointNV_CallInstance); + if (Mock.vkCmdSetCheckpointNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetCheckpointNV_CallbackBool && + Mock.vkCmdSetCheckpointNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetCheckpointNV_CallbackFunctionPointer(commandBuffer, pCheckpointMarker, Mock.vkCmdSetCheckpointNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetCheckpointNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCheckpointMarker) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetCheckpointNV,CMockString_pCheckpointMarker); + if (cmock_call_instance->Expected_pCheckpointMarker == NULL) + { UNITY_TEST_ASSERT_NULL(pCheckpointMarker, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(cmock_call_instance->Expected_pCheckpointMarker, pCheckpointMarker, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkCmdSetCheckpointNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetCheckpointNV_CallbackFunctionPointer(commandBuffer, pCheckpointMarker, Mock.vkCmdSetCheckpointNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetCheckpointNV(CMOCK_vkCmdSetCheckpointNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const void* pCheckpointMarker); +void CMockExpectParameters_vkCmdSetCheckpointNV(CMOCK_vkCmdSetCheckpointNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const void* pCheckpointMarker) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pCheckpointMarker = pCheckpointMarker; + cmock_call_instance->IgnoreArg_pCheckpointMarker = 0; +} + +void vkCmdSetCheckpointNV_CMockIgnore(void) +{ + Mock.vkCmdSetCheckpointNV_IgnoreBool = (char)1; +} + +void vkCmdSetCheckpointNV_CMockStopIgnore(void) +{ + Mock.vkCmdSetCheckpointNV_IgnoreBool = (char)0; +} + +void vkCmdSetCheckpointNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetCheckpointNV_CALL_INSTANCE)); + CMOCK_vkCmdSetCheckpointNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCheckpointNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetCheckpointNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetCheckpointNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetCheckpointNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetCheckpointNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const void* pCheckpointMarker) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetCheckpointNV_CALL_INSTANCE)); + CMOCK_vkCmdSetCheckpointNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCheckpointNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetCheckpointNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetCheckpointNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetCheckpointNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetCheckpointNV(cmock_call_instance, commandBuffer, pCheckpointMarker); +} + +void vkCmdSetCheckpointNV_AddCallback(CMOCK_vkCmdSetCheckpointNV_CALLBACK Callback) +{ + Mock.vkCmdSetCheckpointNV_IgnoreBool = (char)0; + Mock.vkCmdSetCheckpointNV_CallbackBool = (char)1; + Mock.vkCmdSetCheckpointNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetCheckpointNV_Stub(CMOCK_vkCmdSetCheckpointNV_CALLBACK Callback) +{ + Mock.vkCmdSetCheckpointNV_IgnoreBool = (char)0; + Mock.vkCmdSetCheckpointNV_CallbackBool = (char)0; + Mock.vkCmdSetCheckpointNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetCheckpointNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetCheckpointNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCheckpointNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetCheckpointNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetCheckpointNV_CMockIgnoreArg_pCheckpointMarker(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetCheckpointNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCheckpointNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetCheckpointNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCheckpointMarker = 1; +} + +void vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetQueueCheckpointDataNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetQueueCheckpointDataNV); + cmock_call_instance = (CMOCK_vkGetQueueCheckpointDataNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetQueueCheckpointDataNV_CallInstance); + Mock.vkGetQueueCheckpointDataNV_CallInstance = CMock_Guts_MemNext(Mock.vkGetQueueCheckpointDataNV_CallInstance); + if (Mock.vkGetQueueCheckpointDataNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetQueueCheckpointDataNV_CallbackBool && + Mock.vkGetQueueCheckpointDataNV_CallbackFunctionPointer != NULL) + { + Mock.vkGetQueueCheckpointDataNV_CallbackFunctionPointer(queue, pCheckpointDataCount, pCheckpointData, Mock.vkGetQueueCheckpointDataNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_queue) + { + UNITY_SET_DETAILS(CMockString_vkGetQueueCheckpointDataNV,CMockString_queue); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queue), (void*)(&queue), sizeof(VkQueue), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCheckpointDataCount) + { + UNITY_SET_DETAILS(CMockString_vkGetQueueCheckpointDataNV,CMockString_pCheckpointDataCount); + if (cmock_call_instance->Expected_pCheckpointDataCount == NULL) + { UNITY_TEST_ASSERT_NULL(pCheckpointDataCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pCheckpointDataCount, pCheckpointDataCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pCheckpointData) + { + UNITY_SET_DETAILS(CMockString_vkGetQueueCheckpointDataNV,CMockString_pCheckpointData); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCheckpointData), (void*)(pCheckpointData), sizeof(VkCheckpointDataNV), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetQueueCheckpointDataNV_CallbackFunctionPointer != NULL) + { + Mock.vkGetQueueCheckpointDataNV_CallbackFunctionPointer(queue, pCheckpointDataCount, pCheckpointData, Mock.vkGetQueueCheckpointDataNV_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pCheckpointDataCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pCheckpointDataCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pCheckpointDataCount, (const void*)cmock_call_instance->ReturnThruPtr_pCheckpointDataCount_Val, + cmock_call_instance->ReturnThruPtr_pCheckpointDataCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pCheckpointData_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pCheckpointData, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pCheckpointData, (const void*)cmock_call_instance->ReturnThruPtr_pCheckpointData_Val, + cmock_call_instance->ReturnThruPtr_pCheckpointData_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetQueueCheckpointDataNV(CMOCK_vkGetQueueCheckpointDataNV_CALL_INSTANCE* cmock_call_instance, VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData); +void CMockExpectParameters_vkGetQueueCheckpointDataNV(CMOCK_vkGetQueueCheckpointDataNV_CALL_INSTANCE* cmock_call_instance, VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData) +{ + memcpy((void*)(&cmock_call_instance->Expected_queue), (void*)(&queue), + sizeof(VkQueue[sizeof(queue) == sizeof(VkQueue) ? 1 : -1])); /* add VkQueue to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queue = 0; + cmock_call_instance->Expected_pCheckpointDataCount = pCheckpointDataCount; + cmock_call_instance->IgnoreArg_pCheckpointDataCount = 0; + cmock_call_instance->ReturnThruPtr_pCheckpointDataCount_Used = 0; + cmock_call_instance->Expected_pCheckpointData = pCheckpointData; + cmock_call_instance->IgnoreArg_pCheckpointData = 0; + cmock_call_instance->ReturnThruPtr_pCheckpointData_Used = 0; +} + +void vkGetQueueCheckpointDataNV_CMockIgnore(void) +{ + Mock.vkGetQueueCheckpointDataNV_IgnoreBool = (char)1; +} + +void vkGetQueueCheckpointDataNV_CMockStopIgnore(void) +{ + Mock.vkGetQueueCheckpointDataNV_IgnoreBool = (char)0; +} + +void vkGetQueueCheckpointDataNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetQueueCheckpointDataNV_CALL_INSTANCE)); + CMOCK_vkGetQueueCheckpointDataNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetQueueCheckpointDataNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetQueueCheckpointDataNV_CallInstance = CMock_Guts_MemChain(Mock.vkGetQueueCheckpointDataNV_CallInstance, cmock_guts_index); + Mock.vkGetQueueCheckpointDataNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetQueueCheckpointDataNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetQueueCheckpointDataNV_CALL_INSTANCE)); + CMOCK_vkGetQueueCheckpointDataNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetQueueCheckpointDataNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetQueueCheckpointDataNV_CallInstance = CMock_Guts_MemChain(Mock.vkGetQueueCheckpointDataNV_CallInstance, cmock_guts_index); + Mock.vkGetQueueCheckpointDataNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetQueueCheckpointDataNV(cmock_call_instance, queue, pCheckpointDataCount, pCheckpointData); +} + +void vkGetQueueCheckpointDataNV_AddCallback(CMOCK_vkGetQueueCheckpointDataNV_CALLBACK Callback) +{ + Mock.vkGetQueueCheckpointDataNV_IgnoreBool = (char)0; + Mock.vkGetQueueCheckpointDataNV_CallbackBool = (char)1; + Mock.vkGetQueueCheckpointDataNV_CallbackFunctionPointer = Callback; +} + +void vkGetQueueCheckpointDataNV_Stub(CMOCK_vkGetQueueCheckpointDataNV_CALLBACK Callback) +{ + Mock.vkGetQueueCheckpointDataNV_IgnoreBool = (char)0; + Mock.vkGetQueueCheckpointDataNV_CallbackBool = (char)0; + Mock.vkGetQueueCheckpointDataNV_CallbackFunctionPointer = Callback; +} + +void vkGetQueueCheckpointDataNV_CMockReturnMemThruPtr_pCheckpointDataCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pCheckpointDataCount, size_t cmock_size) +{ + CMOCK_vkGetQueueCheckpointDataNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetQueueCheckpointDataNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetQueueCheckpointDataNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pCheckpointDataCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pCheckpointDataCount_Val = pCheckpointDataCount; + cmock_call_instance->ReturnThruPtr_pCheckpointDataCount_Size = cmock_size; +} + +void vkGetQueueCheckpointDataNV_CMockReturnMemThruPtr_pCheckpointData(UNITY_LINE_TYPE cmock_line, VkCheckpointDataNV const* pCheckpointData, size_t cmock_size) +{ + CMOCK_vkGetQueueCheckpointDataNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetQueueCheckpointDataNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetQueueCheckpointDataNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pCheckpointData_Used = 1; + cmock_call_instance->ReturnThruPtr_pCheckpointData_Val = pCheckpointData; + cmock_call_instance->ReturnThruPtr_pCheckpointData_Size = cmock_size; +} + +void vkGetQueueCheckpointDataNV_CMockIgnoreArg_queue(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetQueueCheckpointDataNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetQueueCheckpointDataNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetQueueCheckpointDataNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queue = 1; +} + +void vkGetQueueCheckpointDataNV_CMockIgnoreArg_pCheckpointDataCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetQueueCheckpointDataNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetQueueCheckpointDataNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetQueueCheckpointDataNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCheckpointDataCount = 1; +} + +void vkGetQueueCheckpointDataNV_CMockIgnoreArg_pCheckpointData(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetQueueCheckpointDataNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetQueueCheckpointDataNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetQueueCheckpointDataNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCheckpointData = 1; +} + +VkResult vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkInitializePerformanceApiINTEL_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkInitializePerformanceApiINTEL); + cmock_call_instance = (CMOCK_vkInitializePerformanceApiINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkInitializePerformanceApiINTEL_CallInstance); + Mock.vkInitializePerformanceApiINTEL_CallInstance = CMock_Guts_MemNext(Mock.vkInitializePerformanceApiINTEL_CallInstance); + if (Mock.vkInitializePerformanceApiINTEL_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkInitializePerformanceApiINTEL_FinalReturn; + memcpy((void*)(&Mock.vkInitializePerformanceApiINTEL_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkInitializePerformanceApiINTEL_CallbackBool && + Mock.vkInitializePerformanceApiINTEL_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkInitializePerformanceApiINTEL_CallbackFunctionPointer(device, pInitializeInfo, Mock.vkInitializePerformanceApiINTEL_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkInitializePerformanceApiINTEL,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInitializeInfo) + { + UNITY_SET_DETAILS(CMockString_vkInitializePerformanceApiINTEL,CMockString_pInitializeInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInitializeInfo), (void*)(pInitializeInfo), sizeof(const VkInitializePerformanceApiInfoINTEL), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkInitializePerformanceApiINTEL_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkInitializePerformanceApiINTEL_CallbackFunctionPointer(device, pInitializeInfo, Mock.vkInitializePerformanceApiINTEL_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkInitializePerformanceApiINTEL(CMOCK_vkInitializePerformanceApiINTEL_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo); +void CMockExpectParameters_vkInitializePerformanceApiINTEL(CMOCK_vkInitializePerformanceApiINTEL_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pInitializeInfo = pInitializeInfo; + cmock_call_instance->IgnoreArg_pInitializeInfo = 0; +} + +void vkInitializePerformanceApiINTEL_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkInitializePerformanceApiINTEL_CALL_INSTANCE)); + CMOCK_vkInitializePerformanceApiINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkInitializePerformanceApiINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkInitializePerformanceApiINTEL_CallInstance = CMock_Guts_MemChain(Mock.vkInitializePerformanceApiINTEL_CallInstance, cmock_guts_index); + Mock.vkInitializePerformanceApiINTEL_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkInitializePerformanceApiINTEL_IgnoreBool = (char)1; +} + +void vkInitializePerformanceApiINTEL_CMockStopIgnore(void) +{ + if(Mock.vkInitializePerformanceApiINTEL_IgnoreBool) + Mock.vkInitializePerformanceApiINTEL_CallInstance = CMock_Guts_MemNext(Mock.vkInitializePerformanceApiINTEL_CallInstance); + Mock.vkInitializePerformanceApiINTEL_IgnoreBool = (char)0; +} + +void vkInitializePerformanceApiINTEL_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkInitializePerformanceApiINTEL_CALL_INSTANCE)); + CMOCK_vkInitializePerformanceApiINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkInitializePerformanceApiINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkInitializePerformanceApiINTEL_CallInstance = CMock_Guts_MemChain(Mock.vkInitializePerformanceApiINTEL_CallInstance, cmock_guts_index); + Mock.vkInitializePerformanceApiINTEL_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkInitializePerformanceApiINTEL_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkInitializePerformanceApiINTEL_CALL_INSTANCE)); + CMOCK_vkInitializePerformanceApiINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkInitializePerformanceApiINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkInitializePerformanceApiINTEL_CallInstance = CMock_Guts_MemChain(Mock.vkInitializePerformanceApiINTEL_CallInstance, cmock_guts_index); + Mock.vkInitializePerformanceApiINTEL_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkInitializePerformanceApiINTEL(cmock_call_instance, device, pInitializeInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkInitializePerformanceApiINTEL_AddCallback(CMOCK_vkInitializePerformanceApiINTEL_CALLBACK Callback) +{ + Mock.vkInitializePerformanceApiINTEL_IgnoreBool = (char)0; + Mock.vkInitializePerformanceApiINTEL_CallbackBool = (char)1; + Mock.vkInitializePerformanceApiINTEL_CallbackFunctionPointer = Callback; +} + +void vkInitializePerformanceApiINTEL_Stub(CMOCK_vkInitializePerformanceApiINTEL_CALLBACK Callback) +{ + Mock.vkInitializePerformanceApiINTEL_IgnoreBool = (char)0; + Mock.vkInitializePerformanceApiINTEL_CallbackBool = (char)0; + Mock.vkInitializePerformanceApiINTEL_CallbackFunctionPointer = Callback; +} + +void vkInitializePerformanceApiINTEL_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkInitializePerformanceApiINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkInitializePerformanceApiINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkInitializePerformanceApiINTEL_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkInitializePerformanceApiINTEL_CMockIgnoreArg_pInitializeInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkInitializePerformanceApiINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkInitializePerformanceApiINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkInitializePerformanceApiINTEL_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInitializeInfo = 1; +} + +void vkUninitializePerformanceApiINTEL(VkDevice device) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkUninitializePerformanceApiINTEL_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkUninitializePerformanceApiINTEL); + cmock_call_instance = (CMOCK_vkUninitializePerformanceApiINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkUninitializePerformanceApiINTEL_CallInstance); + Mock.vkUninitializePerformanceApiINTEL_CallInstance = CMock_Guts_MemNext(Mock.vkUninitializePerformanceApiINTEL_CallInstance); + if (Mock.vkUninitializePerformanceApiINTEL_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkUninitializePerformanceApiINTEL_CallbackBool && + Mock.vkUninitializePerformanceApiINTEL_CallbackFunctionPointer != NULL) + { + Mock.vkUninitializePerformanceApiINTEL_CallbackFunctionPointer(device, Mock.vkUninitializePerformanceApiINTEL_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkUninitializePerformanceApiINTEL,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkUninitializePerformanceApiINTEL_CallbackFunctionPointer != NULL) + { + Mock.vkUninitializePerformanceApiINTEL_CallbackFunctionPointer(device, Mock.vkUninitializePerformanceApiINTEL_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkUninitializePerformanceApiINTEL(CMOCK_vkUninitializePerformanceApiINTEL_CALL_INSTANCE* cmock_call_instance, VkDevice device); +void CMockExpectParameters_vkUninitializePerformanceApiINTEL(CMOCK_vkUninitializePerformanceApiINTEL_CALL_INSTANCE* cmock_call_instance, VkDevice device) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; +} + +void vkUninitializePerformanceApiINTEL_CMockIgnore(void) +{ + Mock.vkUninitializePerformanceApiINTEL_IgnoreBool = (char)1; +} + +void vkUninitializePerformanceApiINTEL_CMockStopIgnore(void) +{ + Mock.vkUninitializePerformanceApiINTEL_IgnoreBool = (char)0; +} + +void vkUninitializePerformanceApiINTEL_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkUninitializePerformanceApiINTEL_CALL_INSTANCE)); + CMOCK_vkUninitializePerformanceApiINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUninitializePerformanceApiINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkUninitializePerformanceApiINTEL_CallInstance = CMock_Guts_MemChain(Mock.vkUninitializePerformanceApiINTEL_CallInstance, cmock_guts_index); + Mock.vkUninitializePerformanceApiINTEL_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkUninitializePerformanceApiINTEL_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkUninitializePerformanceApiINTEL_CALL_INSTANCE)); + CMOCK_vkUninitializePerformanceApiINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUninitializePerformanceApiINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkUninitializePerformanceApiINTEL_CallInstance = CMock_Guts_MemChain(Mock.vkUninitializePerformanceApiINTEL_CallInstance, cmock_guts_index); + Mock.vkUninitializePerformanceApiINTEL_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkUninitializePerformanceApiINTEL(cmock_call_instance, device); +} + +void vkUninitializePerformanceApiINTEL_AddCallback(CMOCK_vkUninitializePerformanceApiINTEL_CALLBACK Callback) +{ + Mock.vkUninitializePerformanceApiINTEL_IgnoreBool = (char)0; + Mock.vkUninitializePerformanceApiINTEL_CallbackBool = (char)1; + Mock.vkUninitializePerformanceApiINTEL_CallbackFunctionPointer = Callback; +} + +void vkUninitializePerformanceApiINTEL_Stub(CMOCK_vkUninitializePerformanceApiINTEL_CALLBACK Callback) +{ + Mock.vkUninitializePerformanceApiINTEL_IgnoreBool = (char)0; + Mock.vkUninitializePerformanceApiINTEL_CallbackBool = (char)0; + Mock.vkUninitializePerformanceApiINTEL_CallbackFunctionPointer = Callback; +} + +void vkUninitializePerformanceApiINTEL_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkUninitializePerformanceApiINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkUninitializePerformanceApiINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkUninitializePerformanceApiINTEL_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +VkResult vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetPerformanceMarkerINTEL_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetPerformanceMarkerINTEL); + cmock_call_instance = (CMOCK_vkCmdSetPerformanceMarkerINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetPerformanceMarkerINTEL_CallInstance); + Mock.vkCmdSetPerformanceMarkerINTEL_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetPerformanceMarkerINTEL_CallInstance); + if (Mock.vkCmdSetPerformanceMarkerINTEL_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCmdSetPerformanceMarkerINTEL_FinalReturn; + memcpy((void*)(&Mock.vkCmdSetPerformanceMarkerINTEL_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCmdSetPerformanceMarkerINTEL_CallbackBool && + Mock.vkCmdSetPerformanceMarkerINTEL_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCmdSetPerformanceMarkerINTEL_CallbackFunctionPointer(commandBuffer, pMarkerInfo, Mock.vkCmdSetPerformanceMarkerINTEL_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetPerformanceMarkerINTEL,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMarkerInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetPerformanceMarkerINTEL,CMockString_pMarkerInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMarkerInfo), (void*)(pMarkerInfo), sizeof(const VkPerformanceMarkerInfoINTEL), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetPerformanceMarkerINTEL_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCmdSetPerformanceMarkerINTEL_CallbackFunctionPointer(commandBuffer, pMarkerInfo, Mock.vkCmdSetPerformanceMarkerINTEL_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCmdSetPerformanceMarkerINTEL(CMOCK_vkCmdSetPerformanceMarkerINTEL_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo); +void CMockExpectParameters_vkCmdSetPerformanceMarkerINTEL(CMOCK_vkCmdSetPerformanceMarkerINTEL_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pMarkerInfo = pMarkerInfo; + cmock_call_instance->IgnoreArg_pMarkerInfo = 0; +} + +void vkCmdSetPerformanceMarkerINTEL_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetPerformanceMarkerINTEL_CALL_INSTANCE)); + CMOCK_vkCmdSetPerformanceMarkerINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPerformanceMarkerINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetPerformanceMarkerINTEL_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetPerformanceMarkerINTEL_CallInstance, cmock_guts_index); + Mock.vkCmdSetPerformanceMarkerINTEL_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCmdSetPerformanceMarkerINTEL_IgnoreBool = (char)1; +} + +void vkCmdSetPerformanceMarkerINTEL_CMockStopIgnore(void) +{ + if(Mock.vkCmdSetPerformanceMarkerINTEL_IgnoreBool) + Mock.vkCmdSetPerformanceMarkerINTEL_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetPerformanceMarkerINTEL_CallInstance); + Mock.vkCmdSetPerformanceMarkerINTEL_IgnoreBool = (char)0; +} + +void vkCmdSetPerformanceMarkerINTEL_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetPerformanceMarkerINTEL_CALL_INSTANCE)); + CMOCK_vkCmdSetPerformanceMarkerINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPerformanceMarkerINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetPerformanceMarkerINTEL_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetPerformanceMarkerINTEL_CallInstance, cmock_guts_index); + Mock.vkCmdSetPerformanceMarkerINTEL_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetPerformanceMarkerINTEL_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetPerformanceMarkerINTEL_CALL_INSTANCE)); + CMOCK_vkCmdSetPerformanceMarkerINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPerformanceMarkerINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetPerformanceMarkerINTEL_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetPerformanceMarkerINTEL_CallInstance, cmock_guts_index); + Mock.vkCmdSetPerformanceMarkerINTEL_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetPerformanceMarkerINTEL(cmock_call_instance, commandBuffer, pMarkerInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCmdSetPerformanceMarkerINTEL_AddCallback(CMOCK_vkCmdSetPerformanceMarkerINTEL_CALLBACK Callback) +{ + Mock.vkCmdSetPerformanceMarkerINTEL_IgnoreBool = (char)0; + Mock.vkCmdSetPerformanceMarkerINTEL_CallbackBool = (char)1; + Mock.vkCmdSetPerformanceMarkerINTEL_CallbackFunctionPointer = Callback; +} + +void vkCmdSetPerformanceMarkerINTEL_Stub(CMOCK_vkCmdSetPerformanceMarkerINTEL_CALLBACK Callback) +{ + Mock.vkCmdSetPerformanceMarkerINTEL_IgnoreBool = (char)0; + Mock.vkCmdSetPerformanceMarkerINTEL_CallbackBool = (char)0; + Mock.vkCmdSetPerformanceMarkerINTEL_CallbackFunctionPointer = Callback; +} + +void vkCmdSetPerformanceMarkerINTEL_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetPerformanceMarkerINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPerformanceMarkerINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetPerformanceMarkerINTEL_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetPerformanceMarkerINTEL_CMockIgnoreArg_pMarkerInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetPerformanceMarkerINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPerformanceMarkerINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetPerformanceMarkerINTEL_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMarkerInfo = 1; +} + +VkResult vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetPerformanceStreamMarkerINTEL_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetPerformanceStreamMarkerINTEL); + cmock_call_instance = (CMOCK_vkCmdSetPerformanceStreamMarkerINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetPerformanceStreamMarkerINTEL_CallInstance); + Mock.vkCmdSetPerformanceStreamMarkerINTEL_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetPerformanceStreamMarkerINTEL_CallInstance); + if (Mock.vkCmdSetPerformanceStreamMarkerINTEL_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCmdSetPerformanceStreamMarkerINTEL_FinalReturn; + memcpy((void*)(&Mock.vkCmdSetPerformanceStreamMarkerINTEL_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCmdSetPerformanceStreamMarkerINTEL_CallbackBool && + Mock.vkCmdSetPerformanceStreamMarkerINTEL_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCmdSetPerformanceStreamMarkerINTEL_CallbackFunctionPointer(commandBuffer, pMarkerInfo, Mock.vkCmdSetPerformanceStreamMarkerINTEL_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetPerformanceStreamMarkerINTEL,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMarkerInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetPerformanceStreamMarkerINTEL,CMockString_pMarkerInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMarkerInfo), (void*)(pMarkerInfo), sizeof(const VkPerformanceStreamMarkerInfoINTEL), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetPerformanceStreamMarkerINTEL_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCmdSetPerformanceStreamMarkerINTEL_CallbackFunctionPointer(commandBuffer, pMarkerInfo, Mock.vkCmdSetPerformanceStreamMarkerINTEL_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCmdSetPerformanceStreamMarkerINTEL(CMOCK_vkCmdSetPerformanceStreamMarkerINTEL_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo); +void CMockExpectParameters_vkCmdSetPerformanceStreamMarkerINTEL(CMOCK_vkCmdSetPerformanceStreamMarkerINTEL_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pMarkerInfo = pMarkerInfo; + cmock_call_instance->IgnoreArg_pMarkerInfo = 0; +} + +void vkCmdSetPerformanceStreamMarkerINTEL_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetPerformanceStreamMarkerINTEL_CALL_INSTANCE)); + CMOCK_vkCmdSetPerformanceStreamMarkerINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPerformanceStreamMarkerINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetPerformanceStreamMarkerINTEL_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetPerformanceStreamMarkerINTEL_CallInstance, cmock_guts_index); + Mock.vkCmdSetPerformanceStreamMarkerINTEL_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCmdSetPerformanceStreamMarkerINTEL_IgnoreBool = (char)1; +} + +void vkCmdSetPerformanceStreamMarkerINTEL_CMockStopIgnore(void) +{ + if(Mock.vkCmdSetPerformanceStreamMarkerINTEL_IgnoreBool) + Mock.vkCmdSetPerformanceStreamMarkerINTEL_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetPerformanceStreamMarkerINTEL_CallInstance); + Mock.vkCmdSetPerformanceStreamMarkerINTEL_IgnoreBool = (char)0; +} + +void vkCmdSetPerformanceStreamMarkerINTEL_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetPerformanceStreamMarkerINTEL_CALL_INSTANCE)); + CMOCK_vkCmdSetPerformanceStreamMarkerINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPerformanceStreamMarkerINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetPerformanceStreamMarkerINTEL_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetPerformanceStreamMarkerINTEL_CallInstance, cmock_guts_index); + Mock.vkCmdSetPerformanceStreamMarkerINTEL_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetPerformanceStreamMarkerINTEL_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetPerformanceStreamMarkerINTEL_CALL_INSTANCE)); + CMOCK_vkCmdSetPerformanceStreamMarkerINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPerformanceStreamMarkerINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetPerformanceStreamMarkerINTEL_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetPerformanceStreamMarkerINTEL_CallInstance, cmock_guts_index); + Mock.vkCmdSetPerformanceStreamMarkerINTEL_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetPerformanceStreamMarkerINTEL(cmock_call_instance, commandBuffer, pMarkerInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCmdSetPerformanceStreamMarkerINTEL_AddCallback(CMOCK_vkCmdSetPerformanceStreamMarkerINTEL_CALLBACK Callback) +{ + Mock.vkCmdSetPerformanceStreamMarkerINTEL_IgnoreBool = (char)0; + Mock.vkCmdSetPerformanceStreamMarkerINTEL_CallbackBool = (char)1; + Mock.vkCmdSetPerformanceStreamMarkerINTEL_CallbackFunctionPointer = Callback; +} + +void vkCmdSetPerformanceStreamMarkerINTEL_Stub(CMOCK_vkCmdSetPerformanceStreamMarkerINTEL_CALLBACK Callback) +{ + Mock.vkCmdSetPerformanceStreamMarkerINTEL_IgnoreBool = (char)0; + Mock.vkCmdSetPerformanceStreamMarkerINTEL_CallbackBool = (char)0; + Mock.vkCmdSetPerformanceStreamMarkerINTEL_CallbackFunctionPointer = Callback; +} + +void vkCmdSetPerformanceStreamMarkerINTEL_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetPerformanceStreamMarkerINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPerformanceStreamMarkerINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetPerformanceStreamMarkerINTEL_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetPerformanceStreamMarkerINTEL_CMockIgnoreArg_pMarkerInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetPerformanceStreamMarkerINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPerformanceStreamMarkerINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetPerformanceStreamMarkerINTEL_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMarkerInfo = 1; +} + +VkResult vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetPerformanceOverrideINTEL_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetPerformanceOverrideINTEL); + cmock_call_instance = (CMOCK_vkCmdSetPerformanceOverrideINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetPerformanceOverrideINTEL_CallInstance); + Mock.vkCmdSetPerformanceOverrideINTEL_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetPerformanceOverrideINTEL_CallInstance); + if (Mock.vkCmdSetPerformanceOverrideINTEL_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCmdSetPerformanceOverrideINTEL_FinalReturn; + memcpy((void*)(&Mock.vkCmdSetPerformanceOverrideINTEL_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCmdSetPerformanceOverrideINTEL_CallbackBool && + Mock.vkCmdSetPerformanceOverrideINTEL_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCmdSetPerformanceOverrideINTEL_CallbackFunctionPointer(commandBuffer, pOverrideInfo, Mock.vkCmdSetPerformanceOverrideINTEL_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetPerformanceOverrideINTEL,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pOverrideInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetPerformanceOverrideINTEL,CMockString_pOverrideInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pOverrideInfo), (void*)(pOverrideInfo), sizeof(const VkPerformanceOverrideInfoINTEL), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetPerformanceOverrideINTEL_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCmdSetPerformanceOverrideINTEL_CallbackFunctionPointer(commandBuffer, pOverrideInfo, Mock.vkCmdSetPerformanceOverrideINTEL_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCmdSetPerformanceOverrideINTEL(CMOCK_vkCmdSetPerformanceOverrideINTEL_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo); +void CMockExpectParameters_vkCmdSetPerformanceOverrideINTEL(CMOCK_vkCmdSetPerformanceOverrideINTEL_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pOverrideInfo = pOverrideInfo; + cmock_call_instance->IgnoreArg_pOverrideInfo = 0; +} + +void vkCmdSetPerformanceOverrideINTEL_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetPerformanceOverrideINTEL_CALL_INSTANCE)); + CMOCK_vkCmdSetPerformanceOverrideINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPerformanceOverrideINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetPerformanceOverrideINTEL_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetPerformanceOverrideINTEL_CallInstance, cmock_guts_index); + Mock.vkCmdSetPerformanceOverrideINTEL_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCmdSetPerformanceOverrideINTEL_IgnoreBool = (char)1; +} + +void vkCmdSetPerformanceOverrideINTEL_CMockStopIgnore(void) +{ + if(Mock.vkCmdSetPerformanceOverrideINTEL_IgnoreBool) + Mock.vkCmdSetPerformanceOverrideINTEL_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetPerformanceOverrideINTEL_CallInstance); + Mock.vkCmdSetPerformanceOverrideINTEL_IgnoreBool = (char)0; +} + +void vkCmdSetPerformanceOverrideINTEL_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetPerformanceOverrideINTEL_CALL_INSTANCE)); + CMOCK_vkCmdSetPerformanceOverrideINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPerformanceOverrideINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetPerformanceOverrideINTEL_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetPerformanceOverrideINTEL_CallInstance, cmock_guts_index); + Mock.vkCmdSetPerformanceOverrideINTEL_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetPerformanceOverrideINTEL_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetPerformanceOverrideINTEL_CALL_INSTANCE)); + CMOCK_vkCmdSetPerformanceOverrideINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPerformanceOverrideINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetPerformanceOverrideINTEL_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetPerformanceOverrideINTEL_CallInstance, cmock_guts_index); + Mock.vkCmdSetPerformanceOverrideINTEL_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetPerformanceOverrideINTEL(cmock_call_instance, commandBuffer, pOverrideInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCmdSetPerformanceOverrideINTEL_AddCallback(CMOCK_vkCmdSetPerformanceOverrideINTEL_CALLBACK Callback) +{ + Mock.vkCmdSetPerformanceOverrideINTEL_IgnoreBool = (char)0; + Mock.vkCmdSetPerformanceOverrideINTEL_CallbackBool = (char)1; + Mock.vkCmdSetPerformanceOverrideINTEL_CallbackFunctionPointer = Callback; +} + +void vkCmdSetPerformanceOverrideINTEL_Stub(CMOCK_vkCmdSetPerformanceOverrideINTEL_CALLBACK Callback) +{ + Mock.vkCmdSetPerformanceOverrideINTEL_IgnoreBool = (char)0; + Mock.vkCmdSetPerformanceOverrideINTEL_CallbackBool = (char)0; + Mock.vkCmdSetPerformanceOverrideINTEL_CallbackFunctionPointer = Callback; +} + +void vkCmdSetPerformanceOverrideINTEL_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetPerformanceOverrideINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPerformanceOverrideINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetPerformanceOverrideINTEL_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetPerformanceOverrideINTEL_CMockIgnoreArg_pOverrideInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetPerformanceOverrideINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPerformanceOverrideINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetPerformanceOverrideINTEL_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pOverrideInfo = 1; +} + +VkResult vkAcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkAcquirePerformanceConfigurationINTEL_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkAcquirePerformanceConfigurationINTEL); + cmock_call_instance = (CMOCK_vkAcquirePerformanceConfigurationINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkAcquirePerformanceConfigurationINTEL_CallInstance); + Mock.vkAcquirePerformanceConfigurationINTEL_CallInstance = CMock_Guts_MemNext(Mock.vkAcquirePerformanceConfigurationINTEL_CallInstance); + if (Mock.vkAcquirePerformanceConfigurationINTEL_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkAcquirePerformanceConfigurationINTEL_FinalReturn; + memcpy((void*)(&Mock.vkAcquirePerformanceConfigurationINTEL_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkAcquirePerformanceConfigurationINTEL_CallbackBool && + Mock.vkAcquirePerformanceConfigurationINTEL_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkAcquirePerformanceConfigurationINTEL_CallbackFunctionPointer(device, pAcquireInfo, pConfiguration, Mock.vkAcquirePerformanceConfigurationINTEL_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkAcquirePerformanceConfigurationINTEL,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAcquireInfo) + { + UNITY_SET_DETAILS(CMockString_vkAcquirePerformanceConfigurationINTEL,CMockString_pAcquireInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAcquireInfo), (void*)(pAcquireInfo), sizeof(const VkPerformanceConfigurationAcquireInfoINTEL), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pConfiguration) + { + UNITY_SET_DETAILS(CMockString_vkAcquirePerformanceConfigurationINTEL,CMockString_pConfiguration); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pConfiguration), (void*)(pConfiguration), sizeof(VkPerformanceConfigurationINTEL), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkAcquirePerformanceConfigurationINTEL_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkAcquirePerformanceConfigurationINTEL_CallbackFunctionPointer(device, pAcquireInfo, pConfiguration, Mock.vkAcquirePerformanceConfigurationINTEL_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pConfiguration_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pConfiguration, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pConfiguration, (const void*)cmock_call_instance->ReturnThruPtr_pConfiguration_Val, + cmock_call_instance->ReturnThruPtr_pConfiguration_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkAcquirePerformanceConfigurationINTEL(CMOCK_vkAcquirePerformanceConfigurationINTEL_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration); +void CMockExpectParameters_vkAcquirePerformanceConfigurationINTEL(CMOCK_vkAcquirePerformanceConfigurationINTEL_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pAcquireInfo = pAcquireInfo; + cmock_call_instance->IgnoreArg_pAcquireInfo = 0; + cmock_call_instance->Expected_pConfiguration = pConfiguration; + cmock_call_instance->IgnoreArg_pConfiguration = 0; + cmock_call_instance->ReturnThruPtr_pConfiguration_Used = 0; +} + +void vkAcquirePerformanceConfigurationINTEL_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkAcquirePerformanceConfigurationINTEL_CALL_INSTANCE)); + CMOCK_vkAcquirePerformanceConfigurationINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquirePerformanceConfigurationINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkAcquirePerformanceConfigurationINTEL_CallInstance = CMock_Guts_MemChain(Mock.vkAcquirePerformanceConfigurationINTEL_CallInstance, cmock_guts_index); + Mock.vkAcquirePerformanceConfigurationINTEL_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkAcquirePerformanceConfigurationINTEL_IgnoreBool = (char)1; +} + +void vkAcquirePerformanceConfigurationINTEL_CMockStopIgnore(void) +{ + if(Mock.vkAcquirePerformanceConfigurationINTEL_IgnoreBool) + Mock.vkAcquirePerformanceConfigurationINTEL_CallInstance = CMock_Guts_MemNext(Mock.vkAcquirePerformanceConfigurationINTEL_CallInstance); + Mock.vkAcquirePerformanceConfigurationINTEL_IgnoreBool = (char)0; +} + +void vkAcquirePerformanceConfigurationINTEL_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkAcquirePerformanceConfigurationINTEL_CALL_INSTANCE)); + CMOCK_vkAcquirePerformanceConfigurationINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquirePerformanceConfigurationINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkAcquirePerformanceConfigurationINTEL_CallInstance = CMock_Guts_MemChain(Mock.vkAcquirePerformanceConfigurationINTEL_CallInstance, cmock_guts_index); + Mock.vkAcquirePerformanceConfigurationINTEL_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkAcquirePerformanceConfigurationINTEL_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkAcquirePerformanceConfigurationINTEL_CALL_INSTANCE)); + CMOCK_vkAcquirePerformanceConfigurationINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquirePerformanceConfigurationINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkAcquirePerformanceConfigurationINTEL_CallInstance = CMock_Guts_MemChain(Mock.vkAcquirePerformanceConfigurationINTEL_CallInstance, cmock_guts_index); + Mock.vkAcquirePerformanceConfigurationINTEL_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkAcquirePerformanceConfigurationINTEL(cmock_call_instance, device, pAcquireInfo, pConfiguration); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkAcquirePerformanceConfigurationINTEL_AddCallback(CMOCK_vkAcquirePerformanceConfigurationINTEL_CALLBACK Callback) +{ + Mock.vkAcquirePerformanceConfigurationINTEL_IgnoreBool = (char)0; + Mock.vkAcquirePerformanceConfigurationINTEL_CallbackBool = (char)1; + Mock.vkAcquirePerformanceConfigurationINTEL_CallbackFunctionPointer = Callback; +} + +void vkAcquirePerformanceConfigurationINTEL_Stub(CMOCK_vkAcquirePerformanceConfigurationINTEL_CALLBACK Callback) +{ + Mock.vkAcquirePerformanceConfigurationINTEL_IgnoreBool = (char)0; + Mock.vkAcquirePerformanceConfigurationINTEL_CallbackBool = (char)0; + Mock.vkAcquirePerformanceConfigurationINTEL_CallbackFunctionPointer = Callback; +} + +void vkAcquirePerformanceConfigurationINTEL_CMockReturnMemThruPtr_pConfiguration(UNITY_LINE_TYPE cmock_line, VkPerformanceConfigurationINTEL const* pConfiguration, size_t cmock_size) +{ + CMOCK_vkAcquirePerformanceConfigurationINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquirePerformanceConfigurationINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAcquirePerformanceConfigurationINTEL_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pConfiguration_Used = 1; + cmock_call_instance->ReturnThruPtr_pConfiguration_Val = pConfiguration; + cmock_call_instance->ReturnThruPtr_pConfiguration_Size = cmock_size; +} + +void vkAcquirePerformanceConfigurationINTEL_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkAcquirePerformanceConfigurationINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquirePerformanceConfigurationINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAcquirePerformanceConfigurationINTEL_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkAcquirePerformanceConfigurationINTEL_CMockIgnoreArg_pAcquireInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkAcquirePerformanceConfigurationINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquirePerformanceConfigurationINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAcquirePerformanceConfigurationINTEL_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAcquireInfo = 1; +} + +void vkAcquirePerformanceConfigurationINTEL_CMockIgnoreArg_pConfiguration(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkAcquirePerformanceConfigurationINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquirePerformanceConfigurationINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAcquirePerformanceConfigurationINTEL_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pConfiguration = 1; +} + +VkResult vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkReleasePerformanceConfigurationINTEL_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkReleasePerformanceConfigurationINTEL); + cmock_call_instance = (CMOCK_vkReleasePerformanceConfigurationINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkReleasePerformanceConfigurationINTEL_CallInstance); + Mock.vkReleasePerformanceConfigurationINTEL_CallInstance = CMock_Guts_MemNext(Mock.vkReleasePerformanceConfigurationINTEL_CallInstance); + if (Mock.vkReleasePerformanceConfigurationINTEL_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkReleasePerformanceConfigurationINTEL_FinalReturn; + memcpy((void*)(&Mock.vkReleasePerformanceConfigurationINTEL_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkReleasePerformanceConfigurationINTEL_CallbackBool && + Mock.vkReleasePerformanceConfigurationINTEL_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkReleasePerformanceConfigurationINTEL_CallbackFunctionPointer(device, configuration, Mock.vkReleasePerformanceConfigurationINTEL_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkReleasePerformanceConfigurationINTEL,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_configuration) + { + UNITY_SET_DETAILS(CMockString_vkReleasePerformanceConfigurationINTEL,CMockString_configuration); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_configuration), (void*)(&configuration), sizeof(VkPerformanceConfigurationINTEL), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkReleasePerformanceConfigurationINTEL_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkReleasePerformanceConfigurationINTEL_CallbackFunctionPointer(device, configuration, Mock.vkReleasePerformanceConfigurationINTEL_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkReleasePerformanceConfigurationINTEL(CMOCK_vkReleasePerformanceConfigurationINTEL_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPerformanceConfigurationINTEL configuration); +void CMockExpectParameters_vkReleasePerformanceConfigurationINTEL(CMOCK_vkReleasePerformanceConfigurationINTEL_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPerformanceConfigurationINTEL configuration) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_configuration), (void*)(&configuration), + sizeof(VkPerformanceConfigurationINTEL[sizeof(configuration) == sizeof(VkPerformanceConfigurationINTEL) ? 1 : -1])); /* add VkPerformanceConfigurationINTEL to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_configuration = 0; +} + +void vkReleasePerformanceConfigurationINTEL_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkReleasePerformanceConfigurationINTEL_CALL_INSTANCE)); + CMOCK_vkReleasePerformanceConfigurationINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkReleasePerformanceConfigurationINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkReleasePerformanceConfigurationINTEL_CallInstance = CMock_Guts_MemChain(Mock.vkReleasePerformanceConfigurationINTEL_CallInstance, cmock_guts_index); + Mock.vkReleasePerformanceConfigurationINTEL_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkReleasePerformanceConfigurationINTEL_IgnoreBool = (char)1; +} + +void vkReleasePerformanceConfigurationINTEL_CMockStopIgnore(void) +{ + if(Mock.vkReleasePerformanceConfigurationINTEL_IgnoreBool) + Mock.vkReleasePerformanceConfigurationINTEL_CallInstance = CMock_Guts_MemNext(Mock.vkReleasePerformanceConfigurationINTEL_CallInstance); + Mock.vkReleasePerformanceConfigurationINTEL_IgnoreBool = (char)0; +} + +void vkReleasePerformanceConfigurationINTEL_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkReleasePerformanceConfigurationINTEL_CALL_INSTANCE)); + CMOCK_vkReleasePerformanceConfigurationINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkReleasePerformanceConfigurationINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkReleasePerformanceConfigurationINTEL_CallInstance = CMock_Guts_MemChain(Mock.vkReleasePerformanceConfigurationINTEL_CallInstance, cmock_guts_index); + Mock.vkReleasePerformanceConfigurationINTEL_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkReleasePerformanceConfigurationINTEL_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPerformanceConfigurationINTEL configuration, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkReleasePerformanceConfigurationINTEL_CALL_INSTANCE)); + CMOCK_vkReleasePerformanceConfigurationINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkReleasePerformanceConfigurationINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkReleasePerformanceConfigurationINTEL_CallInstance = CMock_Guts_MemChain(Mock.vkReleasePerformanceConfigurationINTEL_CallInstance, cmock_guts_index); + Mock.vkReleasePerformanceConfigurationINTEL_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkReleasePerformanceConfigurationINTEL(cmock_call_instance, device, configuration); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkReleasePerformanceConfigurationINTEL_AddCallback(CMOCK_vkReleasePerformanceConfigurationINTEL_CALLBACK Callback) +{ + Mock.vkReleasePerformanceConfigurationINTEL_IgnoreBool = (char)0; + Mock.vkReleasePerformanceConfigurationINTEL_CallbackBool = (char)1; + Mock.vkReleasePerformanceConfigurationINTEL_CallbackFunctionPointer = Callback; +} + +void vkReleasePerformanceConfigurationINTEL_Stub(CMOCK_vkReleasePerformanceConfigurationINTEL_CALLBACK Callback) +{ + Mock.vkReleasePerformanceConfigurationINTEL_IgnoreBool = (char)0; + Mock.vkReleasePerformanceConfigurationINTEL_CallbackBool = (char)0; + Mock.vkReleasePerformanceConfigurationINTEL_CallbackFunctionPointer = Callback; +} + +void vkReleasePerformanceConfigurationINTEL_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkReleasePerformanceConfigurationINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkReleasePerformanceConfigurationINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkReleasePerformanceConfigurationINTEL_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkReleasePerformanceConfigurationINTEL_CMockIgnoreArg_configuration(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkReleasePerformanceConfigurationINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkReleasePerformanceConfigurationINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkReleasePerformanceConfigurationINTEL_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_configuration = 1; +} + +VkResult vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkQueueSetPerformanceConfigurationINTEL_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkQueueSetPerformanceConfigurationINTEL); + cmock_call_instance = (CMOCK_vkQueueSetPerformanceConfigurationINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkQueueSetPerformanceConfigurationINTEL_CallInstance); + Mock.vkQueueSetPerformanceConfigurationINTEL_CallInstance = CMock_Guts_MemNext(Mock.vkQueueSetPerformanceConfigurationINTEL_CallInstance); + if (Mock.vkQueueSetPerformanceConfigurationINTEL_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkQueueSetPerformanceConfigurationINTEL_FinalReturn; + memcpy((void*)(&Mock.vkQueueSetPerformanceConfigurationINTEL_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkQueueSetPerformanceConfigurationINTEL_CallbackBool && + Mock.vkQueueSetPerformanceConfigurationINTEL_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkQueueSetPerformanceConfigurationINTEL_CallbackFunctionPointer(queue, configuration, Mock.vkQueueSetPerformanceConfigurationINTEL_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_queue) + { + UNITY_SET_DETAILS(CMockString_vkQueueSetPerformanceConfigurationINTEL,CMockString_queue); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queue), (void*)(&queue), sizeof(VkQueue), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_configuration) + { + UNITY_SET_DETAILS(CMockString_vkQueueSetPerformanceConfigurationINTEL,CMockString_configuration); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_configuration), (void*)(&configuration), sizeof(VkPerformanceConfigurationINTEL), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkQueueSetPerformanceConfigurationINTEL_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkQueueSetPerformanceConfigurationINTEL_CallbackFunctionPointer(queue, configuration, Mock.vkQueueSetPerformanceConfigurationINTEL_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkQueueSetPerformanceConfigurationINTEL(CMOCK_vkQueueSetPerformanceConfigurationINTEL_CALL_INSTANCE* cmock_call_instance, VkQueue queue, VkPerformanceConfigurationINTEL configuration); +void CMockExpectParameters_vkQueueSetPerformanceConfigurationINTEL(CMOCK_vkQueueSetPerformanceConfigurationINTEL_CALL_INSTANCE* cmock_call_instance, VkQueue queue, VkPerformanceConfigurationINTEL configuration) +{ + memcpy((void*)(&cmock_call_instance->Expected_queue), (void*)(&queue), + sizeof(VkQueue[sizeof(queue) == sizeof(VkQueue) ? 1 : -1])); /* add VkQueue to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queue = 0; + memcpy((void*)(&cmock_call_instance->Expected_configuration), (void*)(&configuration), + sizeof(VkPerformanceConfigurationINTEL[sizeof(configuration) == sizeof(VkPerformanceConfigurationINTEL) ? 1 : -1])); /* add VkPerformanceConfigurationINTEL to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_configuration = 0; +} + +void vkQueueSetPerformanceConfigurationINTEL_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkQueueSetPerformanceConfigurationINTEL_CALL_INSTANCE)); + CMOCK_vkQueueSetPerformanceConfigurationINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueSetPerformanceConfigurationINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkQueueSetPerformanceConfigurationINTEL_CallInstance = CMock_Guts_MemChain(Mock.vkQueueSetPerformanceConfigurationINTEL_CallInstance, cmock_guts_index); + Mock.vkQueueSetPerformanceConfigurationINTEL_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkQueueSetPerformanceConfigurationINTEL_IgnoreBool = (char)1; +} + +void vkQueueSetPerformanceConfigurationINTEL_CMockStopIgnore(void) +{ + if(Mock.vkQueueSetPerformanceConfigurationINTEL_IgnoreBool) + Mock.vkQueueSetPerformanceConfigurationINTEL_CallInstance = CMock_Guts_MemNext(Mock.vkQueueSetPerformanceConfigurationINTEL_CallInstance); + Mock.vkQueueSetPerformanceConfigurationINTEL_IgnoreBool = (char)0; +} + +void vkQueueSetPerformanceConfigurationINTEL_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkQueueSetPerformanceConfigurationINTEL_CALL_INSTANCE)); + CMOCK_vkQueueSetPerformanceConfigurationINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueSetPerformanceConfigurationINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkQueueSetPerformanceConfigurationINTEL_CallInstance = CMock_Guts_MemChain(Mock.vkQueueSetPerformanceConfigurationINTEL_CallInstance, cmock_guts_index); + Mock.vkQueueSetPerformanceConfigurationINTEL_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkQueueSetPerformanceConfigurationINTEL_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkQueue queue, VkPerformanceConfigurationINTEL configuration, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkQueueSetPerformanceConfigurationINTEL_CALL_INSTANCE)); + CMOCK_vkQueueSetPerformanceConfigurationINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueSetPerformanceConfigurationINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkQueueSetPerformanceConfigurationINTEL_CallInstance = CMock_Guts_MemChain(Mock.vkQueueSetPerformanceConfigurationINTEL_CallInstance, cmock_guts_index); + Mock.vkQueueSetPerformanceConfigurationINTEL_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkQueueSetPerformanceConfigurationINTEL(cmock_call_instance, queue, configuration); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkQueueSetPerformanceConfigurationINTEL_AddCallback(CMOCK_vkQueueSetPerformanceConfigurationINTEL_CALLBACK Callback) +{ + Mock.vkQueueSetPerformanceConfigurationINTEL_IgnoreBool = (char)0; + Mock.vkQueueSetPerformanceConfigurationINTEL_CallbackBool = (char)1; + Mock.vkQueueSetPerformanceConfigurationINTEL_CallbackFunctionPointer = Callback; +} + +void vkQueueSetPerformanceConfigurationINTEL_Stub(CMOCK_vkQueueSetPerformanceConfigurationINTEL_CALLBACK Callback) +{ + Mock.vkQueueSetPerformanceConfigurationINTEL_IgnoreBool = (char)0; + Mock.vkQueueSetPerformanceConfigurationINTEL_CallbackBool = (char)0; + Mock.vkQueueSetPerformanceConfigurationINTEL_CallbackFunctionPointer = Callback; +} + +void vkQueueSetPerformanceConfigurationINTEL_CMockIgnoreArg_queue(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkQueueSetPerformanceConfigurationINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueSetPerformanceConfigurationINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkQueueSetPerformanceConfigurationINTEL_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queue = 1; +} + +void vkQueueSetPerformanceConfigurationINTEL_CMockIgnoreArg_configuration(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkQueueSetPerformanceConfigurationINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkQueueSetPerformanceConfigurationINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkQueueSetPerformanceConfigurationINTEL_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_configuration = 1; +} + +VkResult vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPerformanceParameterINTEL_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPerformanceParameterINTEL); + cmock_call_instance = (CMOCK_vkGetPerformanceParameterINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPerformanceParameterINTEL_CallInstance); + Mock.vkGetPerformanceParameterINTEL_CallInstance = CMock_Guts_MemNext(Mock.vkGetPerformanceParameterINTEL_CallInstance); + if (Mock.vkGetPerformanceParameterINTEL_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPerformanceParameterINTEL_FinalReturn; + memcpy((void*)(&Mock.vkGetPerformanceParameterINTEL_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPerformanceParameterINTEL_CallbackBool && + Mock.vkGetPerformanceParameterINTEL_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPerformanceParameterINTEL_CallbackFunctionPointer(device, parameter, pValue, Mock.vkGetPerformanceParameterINTEL_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetPerformanceParameterINTEL,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_parameter) + { + UNITY_SET_DETAILS(CMockString_vkGetPerformanceParameterINTEL,CMockString_parameter); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_parameter), (void*)(¶meter), sizeof(VkPerformanceParameterTypeINTEL), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pValue) + { + UNITY_SET_DETAILS(CMockString_vkGetPerformanceParameterINTEL,CMockString_pValue); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pValue), (void*)(pValue), sizeof(VkPerformanceValueINTEL), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPerformanceParameterINTEL_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPerformanceParameterINTEL_CallbackFunctionPointer(device, parameter, pValue, Mock.vkGetPerformanceParameterINTEL_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pValue_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pValue, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pValue, (const void*)cmock_call_instance->ReturnThruPtr_pValue_Val, + cmock_call_instance->ReturnThruPtr_pValue_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPerformanceParameterINTEL(CMOCK_vkGetPerformanceParameterINTEL_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue); +void CMockExpectParameters_vkGetPerformanceParameterINTEL(CMOCK_vkGetPerformanceParameterINTEL_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_parameter), (void*)(¶meter), + sizeof(VkPerformanceParameterTypeINTEL[sizeof(parameter) == sizeof(VkPerformanceParameterTypeINTEL) ? 1 : -1])); /* add VkPerformanceParameterTypeINTEL to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_parameter = 0; + cmock_call_instance->Expected_pValue = pValue; + cmock_call_instance->IgnoreArg_pValue = 0; + cmock_call_instance->ReturnThruPtr_pValue_Used = 0; +} + +void vkGetPerformanceParameterINTEL_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPerformanceParameterINTEL_CALL_INSTANCE)); + CMOCK_vkGetPerformanceParameterINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPerformanceParameterINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPerformanceParameterINTEL_CallInstance = CMock_Guts_MemChain(Mock.vkGetPerformanceParameterINTEL_CallInstance, cmock_guts_index); + Mock.vkGetPerformanceParameterINTEL_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPerformanceParameterINTEL_IgnoreBool = (char)1; +} + +void vkGetPerformanceParameterINTEL_CMockStopIgnore(void) +{ + if(Mock.vkGetPerformanceParameterINTEL_IgnoreBool) + Mock.vkGetPerformanceParameterINTEL_CallInstance = CMock_Guts_MemNext(Mock.vkGetPerformanceParameterINTEL_CallInstance); + Mock.vkGetPerformanceParameterINTEL_IgnoreBool = (char)0; +} + +void vkGetPerformanceParameterINTEL_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPerformanceParameterINTEL_CALL_INSTANCE)); + CMOCK_vkGetPerformanceParameterINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPerformanceParameterINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPerformanceParameterINTEL_CallInstance = CMock_Guts_MemChain(Mock.vkGetPerformanceParameterINTEL_CallInstance, cmock_guts_index); + Mock.vkGetPerformanceParameterINTEL_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPerformanceParameterINTEL_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPerformanceParameterINTEL_CALL_INSTANCE)); + CMOCK_vkGetPerformanceParameterINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPerformanceParameterINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPerformanceParameterINTEL_CallInstance = CMock_Guts_MemChain(Mock.vkGetPerformanceParameterINTEL_CallInstance, cmock_guts_index); + Mock.vkGetPerformanceParameterINTEL_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPerformanceParameterINTEL(cmock_call_instance, device, parameter, pValue); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPerformanceParameterINTEL_AddCallback(CMOCK_vkGetPerformanceParameterINTEL_CALLBACK Callback) +{ + Mock.vkGetPerformanceParameterINTEL_IgnoreBool = (char)0; + Mock.vkGetPerformanceParameterINTEL_CallbackBool = (char)1; + Mock.vkGetPerformanceParameterINTEL_CallbackFunctionPointer = Callback; +} + +void vkGetPerformanceParameterINTEL_Stub(CMOCK_vkGetPerformanceParameterINTEL_CALLBACK Callback) +{ + Mock.vkGetPerformanceParameterINTEL_IgnoreBool = (char)0; + Mock.vkGetPerformanceParameterINTEL_CallbackBool = (char)0; + Mock.vkGetPerformanceParameterINTEL_CallbackFunctionPointer = Callback; +} + +void vkGetPerformanceParameterINTEL_CMockReturnMemThruPtr_pValue(UNITY_LINE_TYPE cmock_line, VkPerformanceValueINTEL const* pValue, size_t cmock_size) +{ + CMOCK_vkGetPerformanceParameterINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPerformanceParameterINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPerformanceParameterINTEL_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pValue_Used = 1; + cmock_call_instance->ReturnThruPtr_pValue_Val = pValue; + cmock_call_instance->ReturnThruPtr_pValue_Size = cmock_size; +} + +void vkGetPerformanceParameterINTEL_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPerformanceParameterINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPerformanceParameterINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPerformanceParameterINTEL_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetPerformanceParameterINTEL_CMockIgnoreArg_parameter(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPerformanceParameterINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPerformanceParameterINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPerformanceParameterINTEL_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_parameter = 1; +} + +void vkGetPerformanceParameterINTEL_CMockIgnoreArg_pValue(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPerformanceParameterINTEL_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPerformanceParameterINTEL_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPerformanceParameterINTEL_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pValue = 1; +} + +void vkSetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkSetLocalDimmingAMD_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkSetLocalDimmingAMD); + cmock_call_instance = (CMOCK_vkSetLocalDimmingAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkSetLocalDimmingAMD_CallInstance); + Mock.vkSetLocalDimmingAMD_CallInstance = CMock_Guts_MemNext(Mock.vkSetLocalDimmingAMD_CallInstance); + if (Mock.vkSetLocalDimmingAMD_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkSetLocalDimmingAMD_CallbackBool && + Mock.vkSetLocalDimmingAMD_CallbackFunctionPointer != NULL) + { + Mock.vkSetLocalDimmingAMD_CallbackFunctionPointer(device, swapChain, localDimmingEnable, Mock.vkSetLocalDimmingAMD_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkSetLocalDimmingAMD,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_swapChain) + { + UNITY_SET_DETAILS(CMockString_vkSetLocalDimmingAMD,CMockString_swapChain); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_swapChain), (void*)(&swapChain), sizeof(VkSwapchainKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_localDimmingEnable) + { + UNITY_SET_DETAILS(CMockString_vkSetLocalDimmingAMD,CMockString_localDimmingEnable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_localDimmingEnable), (void*)(&localDimmingEnable), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkSetLocalDimmingAMD_CallbackFunctionPointer != NULL) + { + Mock.vkSetLocalDimmingAMD_CallbackFunctionPointer(device, swapChain, localDimmingEnable, Mock.vkSetLocalDimmingAMD_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkSetLocalDimmingAMD(CMOCK_vkSetLocalDimmingAMD_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable); +void CMockExpectParameters_vkSetLocalDimmingAMD(CMOCK_vkSetLocalDimmingAMD_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_swapChain), (void*)(&swapChain), + sizeof(VkSwapchainKHR[sizeof(swapChain) == sizeof(VkSwapchainKHR) ? 1 : -1])); /* add VkSwapchainKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_swapChain = 0; + memcpy((void*)(&cmock_call_instance->Expected_localDimmingEnable), (void*)(&localDimmingEnable), + sizeof(VkBool32[sizeof(localDimmingEnable) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_localDimmingEnable = 0; +} + +void vkSetLocalDimmingAMD_CMockIgnore(void) +{ + Mock.vkSetLocalDimmingAMD_IgnoreBool = (char)1; +} + +void vkSetLocalDimmingAMD_CMockStopIgnore(void) +{ + Mock.vkSetLocalDimmingAMD_IgnoreBool = (char)0; +} + +void vkSetLocalDimmingAMD_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkSetLocalDimmingAMD_CALL_INSTANCE)); + CMOCK_vkSetLocalDimmingAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetLocalDimmingAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkSetLocalDimmingAMD_CallInstance = CMock_Guts_MemChain(Mock.vkSetLocalDimmingAMD_CallInstance, cmock_guts_index); + Mock.vkSetLocalDimmingAMD_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkSetLocalDimmingAMD_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkSetLocalDimmingAMD_CALL_INSTANCE)); + CMOCK_vkSetLocalDimmingAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetLocalDimmingAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkSetLocalDimmingAMD_CallInstance = CMock_Guts_MemChain(Mock.vkSetLocalDimmingAMD_CallInstance, cmock_guts_index); + Mock.vkSetLocalDimmingAMD_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkSetLocalDimmingAMD(cmock_call_instance, device, swapChain, localDimmingEnable); +} + +void vkSetLocalDimmingAMD_AddCallback(CMOCK_vkSetLocalDimmingAMD_CALLBACK Callback) +{ + Mock.vkSetLocalDimmingAMD_IgnoreBool = (char)0; + Mock.vkSetLocalDimmingAMD_CallbackBool = (char)1; + Mock.vkSetLocalDimmingAMD_CallbackFunctionPointer = Callback; +} + +void vkSetLocalDimmingAMD_Stub(CMOCK_vkSetLocalDimmingAMD_CALLBACK Callback) +{ + Mock.vkSetLocalDimmingAMD_IgnoreBool = (char)0; + Mock.vkSetLocalDimmingAMD_CallbackBool = (char)0; + Mock.vkSetLocalDimmingAMD_CallbackFunctionPointer = Callback; +} + +void vkSetLocalDimmingAMD_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSetLocalDimmingAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetLocalDimmingAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSetLocalDimmingAMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkSetLocalDimmingAMD_CMockIgnoreArg_swapChain(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSetLocalDimmingAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetLocalDimmingAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSetLocalDimmingAMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_swapChain = 1; +} + +void vkSetLocalDimmingAMD_CMockIgnoreArg_localDimmingEnable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSetLocalDimmingAMD_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetLocalDimmingAMD_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSetLocalDimmingAMD_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_localDimmingEnable = 1; +} + +VkDeviceAddress vkGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetBufferDeviceAddressEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetBufferDeviceAddressEXT); + cmock_call_instance = (CMOCK_vkGetBufferDeviceAddressEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetBufferDeviceAddressEXT_CallInstance); + Mock.vkGetBufferDeviceAddressEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetBufferDeviceAddressEXT_CallInstance); + if (Mock.vkGetBufferDeviceAddressEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetBufferDeviceAddressEXT_FinalReturn; + memcpy((void*)(&Mock.vkGetBufferDeviceAddressEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkDeviceAddress[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkDeviceAddress) ? 1 : -1])); /* add VkDeviceAddress to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetBufferDeviceAddressEXT_CallbackBool && + Mock.vkGetBufferDeviceAddressEXT_CallbackFunctionPointer != NULL) + { + VkDeviceAddress cmock_cb_ret = Mock.vkGetBufferDeviceAddressEXT_CallbackFunctionPointer(device, pInfo, Mock.vkGetBufferDeviceAddressEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetBufferDeviceAddressEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetBufferDeviceAddressEXT,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkBufferDeviceAddressInfo), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetBufferDeviceAddressEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetBufferDeviceAddressEXT_CallbackFunctionPointer(device, pInfo, Mock.vkGetBufferDeviceAddressEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetBufferDeviceAddressEXT(CMOCK_vkGetBufferDeviceAddressEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkBufferDeviceAddressInfo* pInfo); +void CMockExpectParameters_vkGetBufferDeviceAddressEXT(CMOCK_vkGetBufferDeviceAddressEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkBufferDeviceAddressInfo* pInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; +} + +void vkGetBufferDeviceAddressEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkDeviceAddress cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetBufferDeviceAddressEXT_CALL_INSTANCE)); + CMOCK_vkGetBufferDeviceAddressEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferDeviceAddressEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetBufferDeviceAddressEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetBufferDeviceAddressEXT_CallInstance, cmock_guts_index); + Mock.vkGetBufferDeviceAddressEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetBufferDeviceAddressEXT_IgnoreBool = (char)1; +} + +void vkGetBufferDeviceAddressEXT_CMockStopIgnore(void) +{ + if(Mock.vkGetBufferDeviceAddressEXT_IgnoreBool) + Mock.vkGetBufferDeviceAddressEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetBufferDeviceAddressEXT_CallInstance); + Mock.vkGetBufferDeviceAddressEXT_IgnoreBool = (char)0; +} + +void vkGetBufferDeviceAddressEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkDeviceAddress cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetBufferDeviceAddressEXT_CALL_INSTANCE)); + CMOCK_vkGetBufferDeviceAddressEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferDeviceAddressEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetBufferDeviceAddressEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetBufferDeviceAddressEXT_CallInstance, cmock_guts_index); + Mock.vkGetBufferDeviceAddressEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetBufferDeviceAddressEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkBufferDeviceAddressInfo* pInfo, VkDeviceAddress cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetBufferDeviceAddressEXT_CALL_INSTANCE)); + CMOCK_vkGetBufferDeviceAddressEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferDeviceAddressEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetBufferDeviceAddressEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetBufferDeviceAddressEXT_CallInstance, cmock_guts_index); + Mock.vkGetBufferDeviceAddressEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetBufferDeviceAddressEXT(cmock_call_instance, device, pInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkDeviceAddress[sizeof(cmock_to_return) == sizeof(VkDeviceAddress) ? 1 : -1])); /* add VkDeviceAddress to :treat_as_array if this causes an error */ +} + +void vkGetBufferDeviceAddressEXT_AddCallback(CMOCK_vkGetBufferDeviceAddressEXT_CALLBACK Callback) +{ + Mock.vkGetBufferDeviceAddressEXT_IgnoreBool = (char)0; + Mock.vkGetBufferDeviceAddressEXT_CallbackBool = (char)1; + Mock.vkGetBufferDeviceAddressEXT_CallbackFunctionPointer = Callback; +} + +void vkGetBufferDeviceAddressEXT_Stub(CMOCK_vkGetBufferDeviceAddressEXT_CALLBACK Callback) +{ + Mock.vkGetBufferDeviceAddressEXT_IgnoreBool = (char)0; + Mock.vkGetBufferDeviceAddressEXT_CallbackBool = (char)0; + Mock.vkGetBufferDeviceAddressEXT_CallbackFunctionPointer = Callback; +} + +void vkGetBufferDeviceAddressEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetBufferDeviceAddressEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferDeviceAddressEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetBufferDeviceAddressEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetBufferDeviceAddressEXT_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetBufferDeviceAddressEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferDeviceAddressEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetBufferDeviceAddressEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +VkResult vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceToolPropertiesEXT); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceToolPropertiesEXT_CallInstance); + Mock.vkGetPhysicalDeviceToolPropertiesEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceToolPropertiesEXT_CallInstance); + if (Mock.vkGetPhysicalDeviceToolPropertiesEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPhysicalDeviceToolPropertiesEXT_FinalReturn; + memcpy((void*)(&Mock.vkGetPhysicalDeviceToolPropertiesEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPhysicalDeviceToolPropertiesEXT_CallbackBool && + Mock.vkGetPhysicalDeviceToolPropertiesEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPhysicalDeviceToolPropertiesEXT_CallbackFunctionPointer(physicalDevice, pToolCount, pToolProperties, Mock.vkGetPhysicalDeviceToolPropertiesEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceToolPropertiesEXT,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pToolCount) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceToolPropertiesEXT,CMockString_pToolCount); + if (cmock_call_instance->Expected_pToolCount == NULL) + { UNITY_TEST_ASSERT_NULL(pToolCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pToolCount, pToolCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pToolProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceToolPropertiesEXT,CMockString_pToolProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pToolProperties), (void*)(pToolProperties), sizeof(VkPhysicalDeviceToolProperties), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceToolPropertiesEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPhysicalDeviceToolPropertiesEXT_CallbackFunctionPointer(physicalDevice, pToolCount, pToolProperties, Mock.vkGetPhysicalDeviceToolPropertiesEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pToolCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pToolCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pToolCount, (const void*)cmock_call_instance->ReturnThruPtr_pToolCount_Val, + cmock_call_instance->ReturnThruPtr_pToolCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pToolProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pToolProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pToolProperties, (const void*)cmock_call_instance->ReturnThruPtr_pToolProperties_Val, + cmock_call_instance->ReturnThruPtr_pToolProperties_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPhysicalDeviceToolPropertiesEXT(CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties); +void CMockExpectParameters_vkGetPhysicalDeviceToolPropertiesEXT(CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pToolCount = pToolCount; + cmock_call_instance->IgnoreArg_pToolCount = 0; + cmock_call_instance->ReturnThruPtr_pToolCount_Used = 0; + cmock_call_instance->Expected_pToolProperties = pToolProperties; + cmock_call_instance->IgnoreArg_pToolProperties = 0; + cmock_call_instance->ReturnThruPtr_pToolProperties_Used = 0; +} + +void vkGetPhysicalDeviceToolPropertiesEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceToolPropertiesEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceToolPropertiesEXT_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceToolPropertiesEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPhysicalDeviceToolPropertiesEXT_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceToolPropertiesEXT_CMockStopIgnore(void) +{ + if(Mock.vkGetPhysicalDeviceToolPropertiesEXT_IgnoreBool) + Mock.vkGetPhysicalDeviceToolPropertiesEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceToolPropertiesEXT_CallInstance); + Mock.vkGetPhysicalDeviceToolPropertiesEXT_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceToolPropertiesEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceToolPropertiesEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceToolPropertiesEXT_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceToolPropertiesEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceToolPropertiesEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceToolPropertiesEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceToolPropertiesEXT_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceToolPropertiesEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceToolPropertiesEXT(cmock_call_instance, physicalDevice, pToolCount, pToolProperties); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPhysicalDeviceToolPropertiesEXT_AddCallback(CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceToolPropertiesEXT_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceToolPropertiesEXT_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceToolPropertiesEXT_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceToolPropertiesEXT_Stub(CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceToolPropertiesEXT_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceToolPropertiesEXT_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceToolPropertiesEXT_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceToolPropertiesEXT_CMockReturnMemThruPtr_pToolCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pToolCount, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceToolPropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pToolCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pToolCount_Val = pToolCount; + cmock_call_instance->ReturnThruPtr_pToolCount_Size = cmock_size; +} + +void vkGetPhysicalDeviceToolPropertiesEXT_CMockReturnMemThruPtr_pToolProperties(UNITY_LINE_TYPE cmock_line, VkPhysicalDeviceToolProperties const* pToolProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceToolPropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pToolProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pToolProperties_Val = pToolProperties; + cmock_call_instance->ReturnThruPtr_pToolProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceToolPropertiesEXT_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceToolPropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceToolPropertiesEXT_CMockIgnoreArg_pToolCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceToolPropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pToolCount = 1; +} + +void vkGetPhysicalDeviceToolPropertiesEXT_CMockIgnoreArg_pToolProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceToolPropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pToolProperties = 1; +} + +VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallInstance); + Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallInstance); + if (Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_FinalReturn; + memcpy((void*)(&Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallbackBool && + Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallbackFunctionPointer(physicalDevice, pPropertyCount, pProperties, Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPropertyCount) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,CMockString_pPropertyCount); + if (cmock_call_instance->Expected_pPropertyCount == NULL) + { UNITY_TEST_ASSERT_NULL(pPropertyCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pPropertyCount, pPropertyCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,CMockString_pProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pProperties), (void*)(pProperties), sizeof(VkCooperativeMatrixPropertiesNV), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallbackFunctionPointer(physicalDevice, pPropertyCount, pProperties, Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPropertyCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPropertyCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPropertyCount, (const void*)cmock_call_instance->ReturnThruPtr_pPropertyCount_Val, + cmock_call_instance->ReturnThruPtr_pPropertyCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pProperties, (const void*)cmock_call_instance->ReturnThruPtr_pProperties_Val, + cmock_call_instance->ReturnThruPtr_pProperties_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties); +void CMockExpectParameters_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pPropertyCount = pPropertyCount; + cmock_call_instance->IgnoreArg_pPropertyCount = 0; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Used = 0; + cmock_call_instance->Expected_pProperties = pProperties; + cmock_call_instance->IgnoreArg_pProperties = 0; + cmock_call_instance->ReturnThruPtr_pProperties_Used = 0; +} + +void vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockStopIgnore(void) +{ + if(Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_IgnoreBool) + Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallInstance); + Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(cmock_call_instance, physicalDevice, pPropertyCount, pProperties); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_AddCallback(CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_Stub(CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockReturnMemThruPtr_pPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPropertyCount, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPropertyCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Val = pPropertyCount; + cmock_call_instance->ReturnThruPtr_pPropertyCount_Size = cmock_size; +} + +void vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkCooperativeMatrixPropertiesNV const* pProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pProperties_Val = pProperties; + cmock_call_instance->ReturnThruPtr_pProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockIgnoreArg_pPropertyCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPropertyCount = 1; +} + +void vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pProperties = 1; +} + +VkResult vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallInstance); + Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallInstance); + if (Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_FinalReturn; + memcpy((void*)(&Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallbackBool && + Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallbackFunctionPointer(physicalDevice, pCombinationCount, pCombinations, Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCombinationCount) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV,CMockString_pCombinationCount); + if (cmock_call_instance->Expected_pCombinationCount == NULL) + { UNITY_TEST_ASSERT_NULL(pCombinationCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pCombinationCount, pCombinationCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pCombinations) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV,CMockString_pCombinations); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCombinations), (void*)(pCombinations), sizeof(VkFramebufferMixedSamplesCombinationNV), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallbackFunctionPointer(physicalDevice, pCombinationCount, pCombinations, Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pCombinationCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pCombinationCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pCombinationCount, (const void*)cmock_call_instance->ReturnThruPtr_pCombinationCount_Val, + cmock_call_instance->ReturnThruPtr_pCombinationCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pCombinations_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pCombinations, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pCombinations, (const void*)cmock_call_instance->ReturnThruPtr_pCombinations_Val, + cmock_call_instance->ReturnThruPtr_pCombinations_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations); +void CMockExpectParameters_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pCombinationCount = pCombinationCount; + cmock_call_instance->IgnoreArg_pCombinationCount = 0; + cmock_call_instance->ReturnThruPtr_pCombinationCount_Used = 0; + cmock_call_instance->Expected_pCombinations = pCombinations; + cmock_call_instance->IgnoreArg_pCombinations = 0; + cmock_call_instance->ReturnThruPtr_pCombinations_Used = 0; +} + +void vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockStopIgnore(void) +{ + if(Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_IgnoreBool) + Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallInstance); + Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(cmock_call_instance, physicalDevice, pCombinationCount, pCombinations); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_AddCallback(CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_Stub(CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockReturnMemThruPtr_pCombinationCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pCombinationCount, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pCombinationCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pCombinationCount_Val = pCombinationCount; + cmock_call_instance->ReturnThruPtr_pCombinationCount_Size = cmock_size; +} + +void vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockReturnMemThruPtr_pCombinations(UNITY_LINE_TYPE cmock_line, VkFramebufferMixedSamplesCombinationNV const* pCombinations, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pCombinations_Used = 1; + cmock_call_instance->ReturnThruPtr_pCombinations_Val = pCombinations; + cmock_call_instance->ReturnThruPtr_pCombinations_Size = cmock_size; +} + +void vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockIgnoreArg_pCombinationCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCombinationCount = 1; +} + +void vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockIgnoreArg_pCombinations(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCombinations = 1; +} + +VkResult vkCreateHeadlessSurfaceEXT(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateHeadlessSurfaceEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateHeadlessSurfaceEXT); + cmock_call_instance = (CMOCK_vkCreateHeadlessSurfaceEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateHeadlessSurfaceEXT_CallInstance); + Mock.vkCreateHeadlessSurfaceEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCreateHeadlessSurfaceEXT_CallInstance); + if (Mock.vkCreateHeadlessSurfaceEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateHeadlessSurfaceEXT_FinalReturn; + memcpy((void*)(&Mock.vkCreateHeadlessSurfaceEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateHeadlessSurfaceEXT_CallbackBool && + Mock.vkCreateHeadlessSurfaceEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateHeadlessSurfaceEXT_CallbackFunctionPointer(instance, pCreateInfo, pAllocator, pSurface, Mock.vkCreateHeadlessSurfaceEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_instance) + { + UNITY_SET_DETAILS(CMockString_vkCreateHeadlessSurfaceEXT,CMockString_instance); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), sizeof(VkInstance), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateHeadlessSurfaceEXT,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkHeadlessSurfaceCreateInfoEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateHeadlessSurfaceEXT,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSurface) + { + UNITY_SET_DETAILS(CMockString_vkCreateHeadlessSurfaceEXT,CMockString_pSurface); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSurface), (void*)(pSurface), sizeof(VkSurfaceKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateHeadlessSurfaceEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateHeadlessSurfaceEXT_CallbackFunctionPointer(instance, pCreateInfo, pAllocator, pSurface, Mock.vkCreateHeadlessSurfaceEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pSurface_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSurface, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSurface, (const void*)cmock_call_instance->ReturnThruPtr_pSurface_Val, + cmock_call_instance->ReturnThruPtr_pSurface_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateHeadlessSurfaceEXT(CMOCK_vkCreateHeadlessSurfaceEXT_CALL_INSTANCE* cmock_call_instance, VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +void CMockExpectParameters_vkCreateHeadlessSurfaceEXT(CMOCK_vkCreateHeadlessSurfaceEXT_CALL_INSTANCE* cmock_call_instance, VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) +{ + memcpy((void*)(&cmock_call_instance->Expected_instance), (void*)(&instance), + sizeof(VkInstance[sizeof(instance) == sizeof(VkInstance) ? 1 : -1])); /* add VkInstance to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_instance = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pSurface = pSurface; + cmock_call_instance->IgnoreArg_pSurface = 0; + cmock_call_instance->ReturnThruPtr_pSurface_Used = 0; +} + +void vkCreateHeadlessSurfaceEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateHeadlessSurfaceEXT_CALL_INSTANCE)); + CMOCK_vkCreateHeadlessSurfaceEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateHeadlessSurfaceEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateHeadlessSurfaceEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCreateHeadlessSurfaceEXT_CallInstance, cmock_guts_index); + Mock.vkCreateHeadlessSurfaceEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateHeadlessSurfaceEXT_IgnoreBool = (char)1; +} + +void vkCreateHeadlessSurfaceEXT_CMockStopIgnore(void) +{ + if(Mock.vkCreateHeadlessSurfaceEXT_IgnoreBool) + Mock.vkCreateHeadlessSurfaceEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCreateHeadlessSurfaceEXT_CallInstance); + Mock.vkCreateHeadlessSurfaceEXT_IgnoreBool = (char)0; +} + +void vkCreateHeadlessSurfaceEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateHeadlessSurfaceEXT_CALL_INSTANCE)); + CMOCK_vkCreateHeadlessSurfaceEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateHeadlessSurfaceEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateHeadlessSurfaceEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCreateHeadlessSurfaceEXT_CallInstance, cmock_guts_index); + Mock.vkCreateHeadlessSurfaceEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateHeadlessSurfaceEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateHeadlessSurfaceEXT_CALL_INSTANCE)); + CMOCK_vkCreateHeadlessSurfaceEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateHeadlessSurfaceEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateHeadlessSurfaceEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCreateHeadlessSurfaceEXT_CallInstance, cmock_guts_index); + Mock.vkCreateHeadlessSurfaceEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateHeadlessSurfaceEXT(cmock_call_instance, instance, pCreateInfo, pAllocator, pSurface); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateHeadlessSurfaceEXT_AddCallback(CMOCK_vkCreateHeadlessSurfaceEXT_CALLBACK Callback) +{ + Mock.vkCreateHeadlessSurfaceEXT_IgnoreBool = (char)0; + Mock.vkCreateHeadlessSurfaceEXT_CallbackBool = (char)1; + Mock.vkCreateHeadlessSurfaceEXT_CallbackFunctionPointer = Callback; +} + +void vkCreateHeadlessSurfaceEXT_Stub(CMOCK_vkCreateHeadlessSurfaceEXT_CALLBACK Callback) +{ + Mock.vkCreateHeadlessSurfaceEXT_IgnoreBool = (char)0; + Mock.vkCreateHeadlessSurfaceEXT_CallbackBool = (char)0; + Mock.vkCreateHeadlessSurfaceEXT_CallbackFunctionPointer = Callback; +} + +void vkCreateHeadlessSurfaceEXT_CMockReturnMemThruPtr_pSurface(UNITY_LINE_TYPE cmock_line, VkSurfaceKHR const* pSurface, size_t cmock_size) +{ + CMOCK_vkCreateHeadlessSurfaceEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateHeadlessSurfaceEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateHeadlessSurfaceEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSurface_Used = 1; + cmock_call_instance->ReturnThruPtr_pSurface_Val = pSurface; + cmock_call_instance->ReturnThruPtr_pSurface_Size = cmock_size; +} + +void vkCreateHeadlessSurfaceEXT_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateHeadlessSurfaceEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateHeadlessSurfaceEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateHeadlessSurfaceEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_instance = 1; +} + +void vkCreateHeadlessSurfaceEXT_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateHeadlessSurfaceEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateHeadlessSurfaceEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateHeadlessSurfaceEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateHeadlessSurfaceEXT_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateHeadlessSurfaceEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateHeadlessSurfaceEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateHeadlessSurfaceEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateHeadlessSurfaceEXT_CMockIgnoreArg_pSurface(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateHeadlessSurfaceEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateHeadlessSurfaceEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateHeadlessSurfaceEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSurface = 1; +} + +void vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetLineStippleEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetLineStippleEXT); + cmock_call_instance = (CMOCK_vkCmdSetLineStippleEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetLineStippleEXT_CallInstance); + Mock.vkCmdSetLineStippleEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetLineStippleEXT_CallInstance); + if (Mock.vkCmdSetLineStippleEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetLineStippleEXT_CallbackBool && + Mock.vkCmdSetLineStippleEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetLineStippleEXT_CallbackFunctionPointer(commandBuffer, lineStippleFactor, lineStipplePattern, Mock.vkCmdSetLineStippleEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetLineStippleEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_lineStippleFactor) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetLineStippleEXT,CMockString_lineStippleFactor); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_lineStippleFactor, lineStippleFactor, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_lineStipplePattern) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetLineStippleEXT,CMockString_lineStipplePattern); + UNITY_TEST_ASSERT_EQUAL_HEX16(cmock_call_instance->Expected_lineStipplePattern, lineStipplePattern, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetLineStippleEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetLineStippleEXT_CallbackFunctionPointer(commandBuffer, lineStippleFactor, lineStipplePattern, Mock.vkCmdSetLineStippleEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetLineStippleEXT(CMOCK_vkCmdSetLineStippleEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern); +void CMockExpectParameters_vkCmdSetLineStippleEXT(CMOCK_vkCmdSetLineStippleEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_lineStippleFactor = lineStippleFactor; + cmock_call_instance->IgnoreArg_lineStippleFactor = 0; + cmock_call_instance->Expected_lineStipplePattern = lineStipplePattern; + cmock_call_instance->IgnoreArg_lineStipplePattern = 0; +} + +void vkCmdSetLineStippleEXT_CMockIgnore(void) +{ + Mock.vkCmdSetLineStippleEXT_IgnoreBool = (char)1; +} + +void vkCmdSetLineStippleEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetLineStippleEXT_IgnoreBool = (char)0; +} + +void vkCmdSetLineStippleEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetLineStippleEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetLineStippleEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetLineStippleEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetLineStippleEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetLineStippleEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetLineStippleEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetLineStippleEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetLineStippleEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetLineStippleEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetLineStippleEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetLineStippleEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetLineStippleEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetLineStippleEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetLineStippleEXT(cmock_call_instance, commandBuffer, lineStippleFactor, lineStipplePattern); +} + +void vkCmdSetLineStippleEXT_AddCallback(CMOCK_vkCmdSetLineStippleEXT_CALLBACK Callback) +{ + Mock.vkCmdSetLineStippleEXT_IgnoreBool = (char)0; + Mock.vkCmdSetLineStippleEXT_CallbackBool = (char)1; + Mock.vkCmdSetLineStippleEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetLineStippleEXT_Stub(CMOCK_vkCmdSetLineStippleEXT_CALLBACK Callback) +{ + Mock.vkCmdSetLineStippleEXT_IgnoreBool = (char)0; + Mock.vkCmdSetLineStippleEXT_CallbackBool = (char)0; + Mock.vkCmdSetLineStippleEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetLineStippleEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetLineStippleEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetLineStippleEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetLineStippleEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetLineStippleEXT_CMockIgnoreArg_lineStippleFactor(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetLineStippleEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetLineStippleEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetLineStippleEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_lineStippleFactor = 1; +} + +void vkCmdSetLineStippleEXT_CMockIgnoreArg_lineStipplePattern(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetLineStippleEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetLineStippleEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetLineStippleEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_lineStipplePattern = 1; +} + +void vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkResetQueryPoolEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkResetQueryPoolEXT); + cmock_call_instance = (CMOCK_vkResetQueryPoolEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkResetQueryPoolEXT_CallInstance); + Mock.vkResetQueryPoolEXT_CallInstance = CMock_Guts_MemNext(Mock.vkResetQueryPoolEXT_CallInstance); + if (Mock.vkResetQueryPoolEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkResetQueryPoolEXT_CallbackBool && + Mock.vkResetQueryPoolEXT_CallbackFunctionPointer != NULL) + { + Mock.vkResetQueryPoolEXT_CallbackFunctionPointer(device, queryPool, firstQuery, queryCount, Mock.vkResetQueryPoolEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkResetQueryPoolEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queryPool) + { + UNITY_SET_DETAILS(CMockString_vkResetQueryPoolEXT,CMockString_queryPool); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), sizeof(VkQueryPool), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstQuery) + { + UNITY_SET_DETAILS(CMockString_vkResetQueryPoolEXT,CMockString_firstQuery); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstQuery, firstQuery, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queryCount) + { + UNITY_SET_DETAILS(CMockString_vkResetQueryPoolEXT,CMockString_queryCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_queryCount, queryCount, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkResetQueryPoolEXT_CallbackFunctionPointer != NULL) + { + Mock.vkResetQueryPoolEXT_CallbackFunctionPointer(device, queryPool, firstQuery, queryCount, Mock.vkResetQueryPoolEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkResetQueryPoolEXT(CMOCK_vkResetQueryPoolEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); +void CMockExpectParameters_vkResetQueryPoolEXT(CMOCK_vkResetQueryPoolEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), + sizeof(VkQueryPool[sizeof(queryPool) == sizeof(VkQueryPool) ? 1 : -1])); /* add VkQueryPool to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queryPool = 0; + cmock_call_instance->Expected_firstQuery = firstQuery; + cmock_call_instance->IgnoreArg_firstQuery = 0; + cmock_call_instance->Expected_queryCount = queryCount; + cmock_call_instance->IgnoreArg_queryCount = 0; +} + +void vkResetQueryPoolEXT_CMockIgnore(void) +{ + Mock.vkResetQueryPoolEXT_IgnoreBool = (char)1; +} + +void vkResetQueryPoolEXT_CMockStopIgnore(void) +{ + Mock.vkResetQueryPoolEXT_IgnoreBool = (char)0; +} + +void vkResetQueryPoolEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkResetQueryPoolEXT_CALL_INSTANCE)); + CMOCK_vkResetQueryPoolEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetQueryPoolEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkResetQueryPoolEXT_CallInstance = CMock_Guts_MemChain(Mock.vkResetQueryPoolEXT_CallInstance, cmock_guts_index); + Mock.vkResetQueryPoolEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkResetQueryPoolEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkResetQueryPoolEXT_CALL_INSTANCE)); + CMOCK_vkResetQueryPoolEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetQueryPoolEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkResetQueryPoolEXT_CallInstance = CMock_Guts_MemChain(Mock.vkResetQueryPoolEXT_CallInstance, cmock_guts_index); + Mock.vkResetQueryPoolEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkResetQueryPoolEXT(cmock_call_instance, device, queryPool, firstQuery, queryCount); +} + +void vkResetQueryPoolEXT_AddCallback(CMOCK_vkResetQueryPoolEXT_CALLBACK Callback) +{ + Mock.vkResetQueryPoolEXT_IgnoreBool = (char)0; + Mock.vkResetQueryPoolEXT_CallbackBool = (char)1; + Mock.vkResetQueryPoolEXT_CallbackFunctionPointer = Callback; +} + +void vkResetQueryPoolEXT_Stub(CMOCK_vkResetQueryPoolEXT_CALLBACK Callback) +{ + Mock.vkResetQueryPoolEXT_IgnoreBool = (char)0; + Mock.vkResetQueryPoolEXT_CallbackBool = (char)0; + Mock.vkResetQueryPoolEXT_CallbackFunctionPointer = Callback; +} + +void vkResetQueryPoolEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkResetQueryPoolEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetQueryPoolEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkResetQueryPoolEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkResetQueryPoolEXT_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkResetQueryPoolEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetQueryPoolEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkResetQueryPoolEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queryPool = 1; +} + +void vkResetQueryPoolEXT_CMockIgnoreArg_firstQuery(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkResetQueryPoolEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetQueryPoolEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkResetQueryPoolEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstQuery = 1; +} + +void vkResetQueryPoolEXT_CMockIgnoreArg_queryCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkResetQueryPoolEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkResetQueryPoolEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkResetQueryPoolEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queryCount = 1; +} + +void vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetCullModeEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetCullModeEXT); + cmock_call_instance = (CMOCK_vkCmdSetCullModeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetCullModeEXT_CallInstance); + Mock.vkCmdSetCullModeEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetCullModeEXT_CallInstance); + if (Mock.vkCmdSetCullModeEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetCullModeEXT_CallbackBool && + Mock.vkCmdSetCullModeEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetCullModeEXT_CallbackFunctionPointer(commandBuffer, cullMode, Mock.vkCmdSetCullModeEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetCullModeEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_cullMode) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetCullModeEXT,CMockString_cullMode); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_cullMode), (void*)(&cullMode), sizeof(VkCullModeFlags), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetCullModeEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetCullModeEXT_CallbackFunctionPointer(commandBuffer, cullMode, Mock.vkCmdSetCullModeEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetCullModeEXT(CMOCK_vkCmdSetCullModeEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkCullModeFlags cullMode); +void CMockExpectParameters_vkCmdSetCullModeEXT(CMOCK_vkCmdSetCullModeEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_cullMode), (void*)(&cullMode), + sizeof(VkCullModeFlags[sizeof(cullMode) == sizeof(VkCullModeFlags) ? 1 : -1])); /* add VkCullModeFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_cullMode = 0; +} + +void vkCmdSetCullModeEXT_CMockIgnore(void) +{ + Mock.vkCmdSetCullModeEXT_IgnoreBool = (char)1; +} + +void vkCmdSetCullModeEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetCullModeEXT_IgnoreBool = (char)0; +} + +void vkCmdSetCullModeEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetCullModeEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetCullModeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCullModeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetCullModeEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetCullModeEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetCullModeEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetCullModeEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetCullModeEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetCullModeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCullModeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetCullModeEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetCullModeEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetCullModeEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetCullModeEXT(cmock_call_instance, commandBuffer, cullMode); +} + +void vkCmdSetCullModeEXT_AddCallback(CMOCK_vkCmdSetCullModeEXT_CALLBACK Callback) +{ + Mock.vkCmdSetCullModeEXT_IgnoreBool = (char)0; + Mock.vkCmdSetCullModeEXT_CallbackBool = (char)1; + Mock.vkCmdSetCullModeEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetCullModeEXT_Stub(CMOCK_vkCmdSetCullModeEXT_CALLBACK Callback) +{ + Mock.vkCmdSetCullModeEXT_IgnoreBool = (char)0; + Mock.vkCmdSetCullModeEXT_CallbackBool = (char)0; + Mock.vkCmdSetCullModeEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetCullModeEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetCullModeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCullModeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetCullModeEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetCullModeEXT_CMockIgnoreArg_cullMode(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetCullModeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCullModeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetCullModeEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_cullMode = 1; +} + +void vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetFrontFaceEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetFrontFaceEXT); + cmock_call_instance = (CMOCK_vkCmdSetFrontFaceEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetFrontFaceEXT_CallInstance); + Mock.vkCmdSetFrontFaceEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetFrontFaceEXT_CallInstance); + if (Mock.vkCmdSetFrontFaceEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetFrontFaceEXT_CallbackBool && + Mock.vkCmdSetFrontFaceEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetFrontFaceEXT_CallbackFunctionPointer(commandBuffer, frontFace, Mock.vkCmdSetFrontFaceEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetFrontFaceEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_frontFace) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetFrontFaceEXT,CMockString_frontFace); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_frontFace), (void*)(&frontFace), sizeof(VkFrontFace), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetFrontFaceEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetFrontFaceEXT_CallbackFunctionPointer(commandBuffer, frontFace, Mock.vkCmdSetFrontFaceEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetFrontFaceEXT(CMOCK_vkCmdSetFrontFaceEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkFrontFace frontFace); +void CMockExpectParameters_vkCmdSetFrontFaceEXT(CMOCK_vkCmdSetFrontFaceEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkFrontFace frontFace) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_frontFace), (void*)(&frontFace), + sizeof(VkFrontFace[sizeof(frontFace) == sizeof(VkFrontFace) ? 1 : -1])); /* add VkFrontFace to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_frontFace = 0; +} + +void vkCmdSetFrontFaceEXT_CMockIgnore(void) +{ + Mock.vkCmdSetFrontFaceEXT_IgnoreBool = (char)1; +} + +void vkCmdSetFrontFaceEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetFrontFaceEXT_IgnoreBool = (char)0; +} + +void vkCmdSetFrontFaceEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetFrontFaceEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetFrontFaceEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetFrontFaceEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetFrontFaceEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetFrontFaceEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetFrontFaceEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetFrontFaceEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkFrontFace frontFace) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetFrontFaceEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetFrontFaceEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetFrontFaceEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetFrontFaceEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetFrontFaceEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetFrontFaceEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetFrontFaceEXT(cmock_call_instance, commandBuffer, frontFace); +} + +void vkCmdSetFrontFaceEXT_AddCallback(CMOCK_vkCmdSetFrontFaceEXT_CALLBACK Callback) +{ + Mock.vkCmdSetFrontFaceEXT_IgnoreBool = (char)0; + Mock.vkCmdSetFrontFaceEXT_CallbackBool = (char)1; + Mock.vkCmdSetFrontFaceEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetFrontFaceEXT_Stub(CMOCK_vkCmdSetFrontFaceEXT_CALLBACK Callback) +{ + Mock.vkCmdSetFrontFaceEXT_IgnoreBool = (char)0; + Mock.vkCmdSetFrontFaceEXT_CallbackBool = (char)0; + Mock.vkCmdSetFrontFaceEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetFrontFaceEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetFrontFaceEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetFrontFaceEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetFrontFaceEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetFrontFaceEXT_CMockIgnoreArg_frontFace(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetFrontFaceEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetFrontFaceEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetFrontFaceEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_frontFace = 1; +} + +void vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetPrimitiveTopologyEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetPrimitiveTopologyEXT); + cmock_call_instance = (CMOCK_vkCmdSetPrimitiveTopologyEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetPrimitiveTopologyEXT_CallInstance); + Mock.vkCmdSetPrimitiveTopologyEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetPrimitiveTopologyEXT_CallInstance); + if (Mock.vkCmdSetPrimitiveTopologyEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetPrimitiveTopologyEXT_CallbackBool && + Mock.vkCmdSetPrimitiveTopologyEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetPrimitiveTopologyEXT_CallbackFunctionPointer(commandBuffer, primitiveTopology, Mock.vkCmdSetPrimitiveTopologyEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetPrimitiveTopologyEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_primitiveTopology) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetPrimitiveTopologyEXT,CMockString_primitiveTopology); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_primitiveTopology), (void*)(&primitiveTopology), sizeof(VkPrimitiveTopology), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetPrimitiveTopologyEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetPrimitiveTopologyEXT_CallbackFunctionPointer(commandBuffer, primitiveTopology, Mock.vkCmdSetPrimitiveTopologyEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetPrimitiveTopologyEXT(CMOCK_vkCmdSetPrimitiveTopologyEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology); +void CMockExpectParameters_vkCmdSetPrimitiveTopologyEXT(CMOCK_vkCmdSetPrimitiveTopologyEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_primitiveTopology), (void*)(&primitiveTopology), + sizeof(VkPrimitiveTopology[sizeof(primitiveTopology) == sizeof(VkPrimitiveTopology) ? 1 : -1])); /* add VkPrimitiveTopology to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_primitiveTopology = 0; +} + +void vkCmdSetPrimitiveTopologyEXT_CMockIgnore(void) +{ + Mock.vkCmdSetPrimitiveTopologyEXT_IgnoreBool = (char)1; +} + +void vkCmdSetPrimitiveTopologyEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetPrimitiveTopologyEXT_IgnoreBool = (char)0; +} + +void vkCmdSetPrimitiveTopologyEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetPrimitiveTopologyEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetPrimitiveTopologyEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPrimitiveTopologyEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetPrimitiveTopologyEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetPrimitiveTopologyEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetPrimitiveTopologyEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetPrimitiveTopologyEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetPrimitiveTopologyEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetPrimitiveTopologyEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPrimitiveTopologyEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetPrimitiveTopologyEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetPrimitiveTopologyEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetPrimitiveTopologyEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetPrimitiveTopologyEXT(cmock_call_instance, commandBuffer, primitiveTopology); +} + +void vkCmdSetPrimitiveTopologyEXT_AddCallback(CMOCK_vkCmdSetPrimitiveTopologyEXT_CALLBACK Callback) +{ + Mock.vkCmdSetPrimitiveTopologyEXT_IgnoreBool = (char)0; + Mock.vkCmdSetPrimitiveTopologyEXT_CallbackBool = (char)1; + Mock.vkCmdSetPrimitiveTopologyEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetPrimitiveTopologyEXT_Stub(CMOCK_vkCmdSetPrimitiveTopologyEXT_CALLBACK Callback) +{ + Mock.vkCmdSetPrimitiveTopologyEXT_IgnoreBool = (char)0; + Mock.vkCmdSetPrimitiveTopologyEXT_CallbackBool = (char)0; + Mock.vkCmdSetPrimitiveTopologyEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetPrimitiveTopologyEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetPrimitiveTopologyEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPrimitiveTopologyEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetPrimitiveTopologyEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetPrimitiveTopologyEXT_CMockIgnoreArg_primitiveTopology(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetPrimitiveTopologyEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPrimitiveTopologyEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetPrimitiveTopologyEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_primitiveTopology = 1; +} + +void vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetViewportWithCountEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetViewportWithCountEXT); + cmock_call_instance = (CMOCK_vkCmdSetViewportWithCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetViewportWithCountEXT_CallInstance); + Mock.vkCmdSetViewportWithCountEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetViewportWithCountEXT_CallInstance); + if (Mock.vkCmdSetViewportWithCountEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetViewportWithCountEXT_CallbackBool && + Mock.vkCmdSetViewportWithCountEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetViewportWithCountEXT_CallbackFunctionPointer(commandBuffer, viewportCount, pViewports, Mock.vkCmdSetViewportWithCountEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetViewportWithCountEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_viewportCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetViewportWithCountEXT,CMockString_viewportCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_viewportCount, viewportCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pViewports) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetViewportWithCountEXT,CMockString_pViewports); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pViewports), (void*)(pViewports), sizeof(const VkViewport), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetViewportWithCountEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetViewportWithCountEXT_CallbackFunctionPointer(commandBuffer, viewportCount, pViewports, Mock.vkCmdSetViewportWithCountEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetViewportWithCountEXT(CMOCK_vkCmdSetViewportWithCountEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports); +void CMockExpectParameters_vkCmdSetViewportWithCountEXT(CMOCK_vkCmdSetViewportWithCountEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_viewportCount = viewportCount; + cmock_call_instance->IgnoreArg_viewportCount = 0; + cmock_call_instance->Expected_pViewports = pViewports; + cmock_call_instance->IgnoreArg_pViewports = 0; +} + +void vkCmdSetViewportWithCountEXT_CMockIgnore(void) +{ + Mock.vkCmdSetViewportWithCountEXT_IgnoreBool = (char)1; +} + +void vkCmdSetViewportWithCountEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetViewportWithCountEXT_IgnoreBool = (char)0; +} + +void vkCmdSetViewportWithCountEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetViewportWithCountEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetViewportWithCountEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportWithCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetViewportWithCountEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetViewportWithCountEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetViewportWithCountEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetViewportWithCountEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetViewportWithCountEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetViewportWithCountEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportWithCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetViewportWithCountEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetViewportWithCountEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetViewportWithCountEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetViewportWithCountEXT(cmock_call_instance, commandBuffer, viewportCount, pViewports); +} + +void vkCmdSetViewportWithCountEXT_AddCallback(CMOCK_vkCmdSetViewportWithCountEXT_CALLBACK Callback) +{ + Mock.vkCmdSetViewportWithCountEXT_IgnoreBool = (char)0; + Mock.vkCmdSetViewportWithCountEXT_CallbackBool = (char)1; + Mock.vkCmdSetViewportWithCountEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetViewportWithCountEXT_Stub(CMOCK_vkCmdSetViewportWithCountEXT_CALLBACK Callback) +{ + Mock.vkCmdSetViewportWithCountEXT_IgnoreBool = (char)0; + Mock.vkCmdSetViewportWithCountEXT_CallbackBool = (char)0; + Mock.vkCmdSetViewportWithCountEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetViewportWithCountEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetViewportWithCountEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportWithCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetViewportWithCountEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetViewportWithCountEXT_CMockIgnoreArg_viewportCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetViewportWithCountEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportWithCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetViewportWithCountEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_viewportCount = 1; +} + +void vkCmdSetViewportWithCountEXT_CMockIgnoreArg_pViewports(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetViewportWithCountEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportWithCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetViewportWithCountEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pViewports = 1; +} + +void vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetScissorWithCountEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetScissorWithCountEXT); + cmock_call_instance = (CMOCK_vkCmdSetScissorWithCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetScissorWithCountEXT_CallInstance); + Mock.vkCmdSetScissorWithCountEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetScissorWithCountEXT_CallInstance); + if (Mock.vkCmdSetScissorWithCountEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetScissorWithCountEXT_CallbackBool && + Mock.vkCmdSetScissorWithCountEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetScissorWithCountEXT_CallbackFunctionPointer(commandBuffer, scissorCount, pScissors, Mock.vkCmdSetScissorWithCountEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetScissorWithCountEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_scissorCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetScissorWithCountEXT,CMockString_scissorCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_scissorCount, scissorCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pScissors) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetScissorWithCountEXT,CMockString_pScissors); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pScissors), (void*)(pScissors), sizeof(const VkRect2D), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetScissorWithCountEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetScissorWithCountEXT_CallbackFunctionPointer(commandBuffer, scissorCount, pScissors, Mock.vkCmdSetScissorWithCountEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetScissorWithCountEXT(CMOCK_vkCmdSetScissorWithCountEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors); +void CMockExpectParameters_vkCmdSetScissorWithCountEXT(CMOCK_vkCmdSetScissorWithCountEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_scissorCount = scissorCount; + cmock_call_instance->IgnoreArg_scissorCount = 0; + cmock_call_instance->Expected_pScissors = pScissors; + cmock_call_instance->IgnoreArg_pScissors = 0; +} + +void vkCmdSetScissorWithCountEXT_CMockIgnore(void) +{ + Mock.vkCmdSetScissorWithCountEXT_IgnoreBool = (char)1; +} + +void vkCmdSetScissorWithCountEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetScissorWithCountEXT_IgnoreBool = (char)0; +} + +void vkCmdSetScissorWithCountEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetScissorWithCountEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetScissorWithCountEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetScissorWithCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetScissorWithCountEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetScissorWithCountEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetScissorWithCountEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetScissorWithCountEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetScissorWithCountEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetScissorWithCountEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetScissorWithCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetScissorWithCountEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetScissorWithCountEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetScissorWithCountEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetScissorWithCountEXT(cmock_call_instance, commandBuffer, scissorCount, pScissors); +} + +void vkCmdSetScissorWithCountEXT_AddCallback(CMOCK_vkCmdSetScissorWithCountEXT_CALLBACK Callback) +{ + Mock.vkCmdSetScissorWithCountEXT_IgnoreBool = (char)0; + Mock.vkCmdSetScissorWithCountEXT_CallbackBool = (char)1; + Mock.vkCmdSetScissorWithCountEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetScissorWithCountEXT_Stub(CMOCK_vkCmdSetScissorWithCountEXT_CALLBACK Callback) +{ + Mock.vkCmdSetScissorWithCountEXT_IgnoreBool = (char)0; + Mock.vkCmdSetScissorWithCountEXT_CallbackBool = (char)0; + Mock.vkCmdSetScissorWithCountEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetScissorWithCountEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetScissorWithCountEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetScissorWithCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetScissorWithCountEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetScissorWithCountEXT_CMockIgnoreArg_scissorCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetScissorWithCountEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetScissorWithCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetScissorWithCountEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_scissorCount = 1; +} + +void vkCmdSetScissorWithCountEXT_CMockIgnoreArg_pScissors(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetScissorWithCountEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetScissorWithCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetScissorWithCountEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pScissors = 1; +} + +void vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBindVertexBuffers2EXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBindVertexBuffers2EXT); + cmock_call_instance = (CMOCK_vkCmdBindVertexBuffers2EXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBindVertexBuffers2EXT_CallInstance); + Mock.vkCmdBindVertexBuffers2EXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBindVertexBuffers2EXT_CallInstance); + if (Mock.vkCmdBindVertexBuffers2EXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBindVertexBuffers2EXT_CallbackBool && + Mock.vkCmdBindVertexBuffers2EXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBindVertexBuffers2EXT_CallbackFunctionPointer(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides, Mock.vkCmdBindVertexBuffers2EXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindVertexBuffers2EXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstBinding) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindVertexBuffers2EXT,CMockString_firstBinding); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstBinding, firstBinding, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_bindingCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindVertexBuffers2EXT,CMockString_bindingCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_bindingCount, bindingCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pBuffers) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindVertexBuffers2EXT,CMockString_pBuffers); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pBuffers), (void*)(pBuffers), sizeof(const VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pOffsets) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindVertexBuffers2EXT,CMockString_pOffsets); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pOffsets), (void*)(pOffsets), sizeof(const VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSizes) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindVertexBuffers2EXT,CMockString_pSizes); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSizes), (void*)(pSizes), sizeof(const VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pStrides) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindVertexBuffers2EXT,CMockString_pStrides); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pStrides), (void*)(pStrides), sizeof(const VkDeviceSize), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdBindVertexBuffers2EXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBindVertexBuffers2EXT_CallbackFunctionPointer(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides, Mock.vkCmdBindVertexBuffers2EXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBindVertexBuffers2EXT(CMOCK_vkCmdBindVertexBuffers2EXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides); +void CMockExpectParameters_vkCmdBindVertexBuffers2EXT(CMOCK_vkCmdBindVertexBuffers2EXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_firstBinding = firstBinding; + cmock_call_instance->IgnoreArg_firstBinding = 0; + cmock_call_instance->Expected_bindingCount = bindingCount; + cmock_call_instance->IgnoreArg_bindingCount = 0; + cmock_call_instance->Expected_pBuffers = pBuffers; + cmock_call_instance->IgnoreArg_pBuffers = 0; + cmock_call_instance->Expected_pOffsets = pOffsets; + cmock_call_instance->IgnoreArg_pOffsets = 0; + cmock_call_instance->Expected_pSizes = pSizes; + cmock_call_instance->IgnoreArg_pSizes = 0; + cmock_call_instance->Expected_pStrides = pStrides; + cmock_call_instance->IgnoreArg_pStrides = 0; +} + +void vkCmdBindVertexBuffers2EXT_CMockIgnore(void) +{ + Mock.vkCmdBindVertexBuffers2EXT_IgnoreBool = (char)1; +} + +void vkCmdBindVertexBuffers2EXT_CMockStopIgnore(void) +{ + Mock.vkCmdBindVertexBuffers2EXT_IgnoreBool = (char)0; +} + +void vkCmdBindVertexBuffers2EXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBindVertexBuffers2EXT_CALL_INSTANCE)); + CMOCK_vkCmdBindVertexBuffers2EXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindVertexBuffers2EXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBindVertexBuffers2EXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBindVertexBuffers2EXT_CallInstance, cmock_guts_index); + Mock.vkCmdBindVertexBuffers2EXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBindVertexBuffers2EXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBindVertexBuffers2EXT_CALL_INSTANCE)); + CMOCK_vkCmdBindVertexBuffers2EXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindVertexBuffers2EXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBindVertexBuffers2EXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBindVertexBuffers2EXT_CallInstance, cmock_guts_index); + Mock.vkCmdBindVertexBuffers2EXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBindVertexBuffers2EXT(cmock_call_instance, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); +} + +void vkCmdBindVertexBuffers2EXT_AddCallback(CMOCK_vkCmdBindVertexBuffers2EXT_CALLBACK Callback) +{ + Mock.vkCmdBindVertexBuffers2EXT_IgnoreBool = (char)0; + Mock.vkCmdBindVertexBuffers2EXT_CallbackBool = (char)1; + Mock.vkCmdBindVertexBuffers2EXT_CallbackFunctionPointer = Callback; +} + +void vkCmdBindVertexBuffers2EXT_Stub(CMOCK_vkCmdBindVertexBuffers2EXT_CALLBACK Callback) +{ + Mock.vkCmdBindVertexBuffers2EXT_IgnoreBool = (char)0; + Mock.vkCmdBindVertexBuffers2EXT_CallbackBool = (char)0; + Mock.vkCmdBindVertexBuffers2EXT_CallbackFunctionPointer = Callback; +} + +void vkCmdBindVertexBuffers2EXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindVertexBuffers2EXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindVertexBuffers2EXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindVertexBuffers2EXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBindVertexBuffers2EXT_CMockIgnoreArg_firstBinding(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindVertexBuffers2EXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindVertexBuffers2EXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindVertexBuffers2EXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstBinding = 1; +} + +void vkCmdBindVertexBuffers2EXT_CMockIgnoreArg_bindingCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindVertexBuffers2EXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindVertexBuffers2EXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindVertexBuffers2EXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_bindingCount = 1; +} + +void vkCmdBindVertexBuffers2EXT_CMockIgnoreArg_pBuffers(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindVertexBuffers2EXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindVertexBuffers2EXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindVertexBuffers2EXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pBuffers = 1; +} + +void vkCmdBindVertexBuffers2EXT_CMockIgnoreArg_pOffsets(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindVertexBuffers2EXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindVertexBuffers2EXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindVertexBuffers2EXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pOffsets = 1; +} + +void vkCmdBindVertexBuffers2EXT_CMockIgnoreArg_pSizes(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindVertexBuffers2EXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindVertexBuffers2EXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindVertexBuffers2EXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSizes = 1; +} + +void vkCmdBindVertexBuffers2EXT_CMockIgnoreArg_pStrides(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindVertexBuffers2EXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindVertexBuffers2EXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindVertexBuffers2EXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pStrides = 1; +} + +void vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetDepthTestEnableEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetDepthTestEnableEXT); + cmock_call_instance = (CMOCK_vkCmdSetDepthTestEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetDepthTestEnableEXT_CallInstance); + Mock.vkCmdSetDepthTestEnableEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetDepthTestEnableEXT_CallInstance); + if (Mock.vkCmdSetDepthTestEnableEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetDepthTestEnableEXT_CallbackBool && + Mock.vkCmdSetDepthTestEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDepthTestEnableEXT_CallbackFunctionPointer(commandBuffer, depthTestEnable, Mock.vkCmdSetDepthTestEnableEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthTestEnableEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_depthTestEnable) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthTestEnableEXT,CMockString_depthTestEnable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_depthTestEnable), (void*)(&depthTestEnable), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetDepthTestEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDepthTestEnableEXT_CallbackFunctionPointer(commandBuffer, depthTestEnable, Mock.vkCmdSetDepthTestEnableEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetDepthTestEnableEXT(CMOCK_vkCmdSetDepthTestEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 depthTestEnable); +void CMockExpectParameters_vkCmdSetDepthTestEnableEXT(CMOCK_vkCmdSetDepthTestEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_depthTestEnable), (void*)(&depthTestEnable), + sizeof(VkBool32[sizeof(depthTestEnable) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_depthTestEnable = 0; +} + +void vkCmdSetDepthTestEnableEXT_CMockIgnore(void) +{ + Mock.vkCmdSetDepthTestEnableEXT_IgnoreBool = (char)1; +} + +void vkCmdSetDepthTestEnableEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetDepthTestEnableEXT_IgnoreBool = (char)0; +} + +void vkCmdSetDepthTestEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDepthTestEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetDepthTestEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthTestEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDepthTestEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDepthTestEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetDepthTestEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetDepthTestEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDepthTestEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetDepthTestEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthTestEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDepthTestEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDepthTestEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetDepthTestEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetDepthTestEnableEXT(cmock_call_instance, commandBuffer, depthTestEnable); +} + +void vkCmdSetDepthTestEnableEXT_AddCallback(CMOCK_vkCmdSetDepthTestEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetDepthTestEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetDepthTestEnableEXT_CallbackBool = (char)1; + Mock.vkCmdSetDepthTestEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDepthTestEnableEXT_Stub(CMOCK_vkCmdSetDepthTestEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetDepthTestEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetDepthTestEnableEXT_CallbackBool = (char)0; + Mock.vkCmdSetDepthTestEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDepthTestEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthTestEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthTestEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthTestEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetDepthTestEnableEXT_CMockIgnoreArg_depthTestEnable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthTestEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthTestEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthTestEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_depthTestEnable = 1; +} + +void vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetDepthWriteEnableEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetDepthWriteEnableEXT); + cmock_call_instance = (CMOCK_vkCmdSetDepthWriteEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetDepthWriteEnableEXT_CallInstance); + Mock.vkCmdSetDepthWriteEnableEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetDepthWriteEnableEXT_CallInstance); + if (Mock.vkCmdSetDepthWriteEnableEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetDepthWriteEnableEXT_CallbackBool && + Mock.vkCmdSetDepthWriteEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDepthWriteEnableEXT_CallbackFunctionPointer(commandBuffer, depthWriteEnable, Mock.vkCmdSetDepthWriteEnableEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthWriteEnableEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_depthWriteEnable) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthWriteEnableEXT,CMockString_depthWriteEnable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_depthWriteEnable), (void*)(&depthWriteEnable), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetDepthWriteEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDepthWriteEnableEXT_CallbackFunctionPointer(commandBuffer, depthWriteEnable, Mock.vkCmdSetDepthWriteEnableEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetDepthWriteEnableEXT(CMOCK_vkCmdSetDepthWriteEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); +void CMockExpectParameters_vkCmdSetDepthWriteEnableEXT(CMOCK_vkCmdSetDepthWriteEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_depthWriteEnable), (void*)(&depthWriteEnable), + sizeof(VkBool32[sizeof(depthWriteEnable) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_depthWriteEnable = 0; +} + +void vkCmdSetDepthWriteEnableEXT_CMockIgnore(void) +{ + Mock.vkCmdSetDepthWriteEnableEXT_IgnoreBool = (char)1; +} + +void vkCmdSetDepthWriteEnableEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetDepthWriteEnableEXT_IgnoreBool = (char)0; +} + +void vkCmdSetDepthWriteEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDepthWriteEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetDepthWriteEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthWriteEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDepthWriteEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDepthWriteEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetDepthWriteEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetDepthWriteEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDepthWriteEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetDepthWriteEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthWriteEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDepthWriteEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDepthWriteEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetDepthWriteEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetDepthWriteEnableEXT(cmock_call_instance, commandBuffer, depthWriteEnable); +} + +void vkCmdSetDepthWriteEnableEXT_AddCallback(CMOCK_vkCmdSetDepthWriteEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetDepthWriteEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetDepthWriteEnableEXT_CallbackBool = (char)1; + Mock.vkCmdSetDepthWriteEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDepthWriteEnableEXT_Stub(CMOCK_vkCmdSetDepthWriteEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetDepthWriteEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetDepthWriteEnableEXT_CallbackBool = (char)0; + Mock.vkCmdSetDepthWriteEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDepthWriteEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthWriteEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthWriteEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthWriteEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetDepthWriteEnableEXT_CMockIgnoreArg_depthWriteEnable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthWriteEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthWriteEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthWriteEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_depthWriteEnable = 1; +} + +void vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetDepthCompareOpEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetDepthCompareOpEXT); + cmock_call_instance = (CMOCK_vkCmdSetDepthCompareOpEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetDepthCompareOpEXT_CallInstance); + Mock.vkCmdSetDepthCompareOpEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetDepthCompareOpEXT_CallInstance); + if (Mock.vkCmdSetDepthCompareOpEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetDepthCompareOpEXT_CallbackBool && + Mock.vkCmdSetDepthCompareOpEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDepthCompareOpEXT_CallbackFunctionPointer(commandBuffer, depthCompareOp, Mock.vkCmdSetDepthCompareOpEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthCompareOpEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_depthCompareOp) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthCompareOpEXT,CMockString_depthCompareOp); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_depthCompareOp), (void*)(&depthCompareOp), sizeof(VkCompareOp), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetDepthCompareOpEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDepthCompareOpEXT_CallbackFunctionPointer(commandBuffer, depthCompareOp, Mock.vkCmdSetDepthCompareOpEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetDepthCompareOpEXT(CMOCK_vkCmdSetDepthCompareOpEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp); +void CMockExpectParameters_vkCmdSetDepthCompareOpEXT(CMOCK_vkCmdSetDepthCompareOpEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_depthCompareOp), (void*)(&depthCompareOp), + sizeof(VkCompareOp[sizeof(depthCompareOp) == sizeof(VkCompareOp) ? 1 : -1])); /* add VkCompareOp to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_depthCompareOp = 0; +} + +void vkCmdSetDepthCompareOpEXT_CMockIgnore(void) +{ + Mock.vkCmdSetDepthCompareOpEXT_IgnoreBool = (char)1; +} + +void vkCmdSetDepthCompareOpEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetDepthCompareOpEXT_IgnoreBool = (char)0; +} + +void vkCmdSetDepthCompareOpEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDepthCompareOpEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetDepthCompareOpEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthCompareOpEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDepthCompareOpEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDepthCompareOpEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetDepthCompareOpEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetDepthCompareOpEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDepthCompareOpEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetDepthCompareOpEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthCompareOpEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDepthCompareOpEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDepthCompareOpEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetDepthCompareOpEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetDepthCompareOpEXT(cmock_call_instance, commandBuffer, depthCompareOp); +} + +void vkCmdSetDepthCompareOpEXT_AddCallback(CMOCK_vkCmdSetDepthCompareOpEXT_CALLBACK Callback) +{ + Mock.vkCmdSetDepthCompareOpEXT_IgnoreBool = (char)0; + Mock.vkCmdSetDepthCompareOpEXT_CallbackBool = (char)1; + Mock.vkCmdSetDepthCompareOpEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDepthCompareOpEXT_Stub(CMOCK_vkCmdSetDepthCompareOpEXT_CALLBACK Callback) +{ + Mock.vkCmdSetDepthCompareOpEXT_IgnoreBool = (char)0; + Mock.vkCmdSetDepthCompareOpEXT_CallbackBool = (char)0; + Mock.vkCmdSetDepthCompareOpEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDepthCompareOpEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthCompareOpEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthCompareOpEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthCompareOpEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetDepthCompareOpEXT_CMockIgnoreArg_depthCompareOp(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthCompareOpEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthCompareOpEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthCompareOpEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_depthCompareOp = 1; +} + +void vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetDepthBoundsTestEnableEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetDepthBoundsTestEnableEXT); + cmock_call_instance = (CMOCK_vkCmdSetDepthBoundsTestEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetDepthBoundsTestEnableEXT_CallInstance); + Mock.vkCmdSetDepthBoundsTestEnableEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetDepthBoundsTestEnableEXT_CallInstance); + if (Mock.vkCmdSetDepthBoundsTestEnableEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetDepthBoundsTestEnableEXT_CallbackBool && + Mock.vkCmdSetDepthBoundsTestEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDepthBoundsTestEnableEXT_CallbackFunctionPointer(commandBuffer, depthBoundsTestEnable, Mock.vkCmdSetDepthBoundsTestEnableEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthBoundsTestEnableEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_depthBoundsTestEnable) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthBoundsTestEnableEXT,CMockString_depthBoundsTestEnable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_depthBoundsTestEnable), (void*)(&depthBoundsTestEnable), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetDepthBoundsTestEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDepthBoundsTestEnableEXT_CallbackFunctionPointer(commandBuffer, depthBoundsTestEnable, Mock.vkCmdSetDepthBoundsTestEnableEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetDepthBoundsTestEnableEXT(CMOCK_vkCmdSetDepthBoundsTestEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable); +void CMockExpectParameters_vkCmdSetDepthBoundsTestEnableEXT(CMOCK_vkCmdSetDepthBoundsTestEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_depthBoundsTestEnable), (void*)(&depthBoundsTestEnable), + sizeof(VkBool32[sizeof(depthBoundsTestEnable) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_depthBoundsTestEnable = 0; +} + +void vkCmdSetDepthBoundsTestEnableEXT_CMockIgnore(void) +{ + Mock.vkCmdSetDepthBoundsTestEnableEXT_IgnoreBool = (char)1; +} + +void vkCmdSetDepthBoundsTestEnableEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetDepthBoundsTestEnableEXT_IgnoreBool = (char)0; +} + +void vkCmdSetDepthBoundsTestEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDepthBoundsTestEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetDepthBoundsTestEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthBoundsTestEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDepthBoundsTestEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDepthBoundsTestEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetDepthBoundsTestEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetDepthBoundsTestEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDepthBoundsTestEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetDepthBoundsTestEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthBoundsTestEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDepthBoundsTestEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDepthBoundsTestEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetDepthBoundsTestEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetDepthBoundsTestEnableEXT(cmock_call_instance, commandBuffer, depthBoundsTestEnable); +} + +void vkCmdSetDepthBoundsTestEnableEXT_AddCallback(CMOCK_vkCmdSetDepthBoundsTestEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetDepthBoundsTestEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetDepthBoundsTestEnableEXT_CallbackBool = (char)1; + Mock.vkCmdSetDepthBoundsTestEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDepthBoundsTestEnableEXT_Stub(CMOCK_vkCmdSetDepthBoundsTestEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetDepthBoundsTestEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetDepthBoundsTestEnableEXT_CallbackBool = (char)0; + Mock.vkCmdSetDepthBoundsTestEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDepthBoundsTestEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthBoundsTestEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthBoundsTestEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthBoundsTestEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetDepthBoundsTestEnableEXT_CMockIgnoreArg_depthBoundsTestEnable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthBoundsTestEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthBoundsTestEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthBoundsTestEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_depthBoundsTestEnable = 1; +} + +void vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetStencilTestEnableEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetStencilTestEnableEXT); + cmock_call_instance = (CMOCK_vkCmdSetStencilTestEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetStencilTestEnableEXT_CallInstance); + Mock.vkCmdSetStencilTestEnableEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetStencilTestEnableEXT_CallInstance); + if (Mock.vkCmdSetStencilTestEnableEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetStencilTestEnableEXT_CallbackBool && + Mock.vkCmdSetStencilTestEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetStencilTestEnableEXT_CallbackFunctionPointer(commandBuffer, stencilTestEnable, Mock.vkCmdSetStencilTestEnableEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetStencilTestEnableEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_stencilTestEnable) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetStencilTestEnableEXT,CMockString_stencilTestEnable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_stencilTestEnable), (void*)(&stencilTestEnable), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetStencilTestEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetStencilTestEnableEXT_CallbackFunctionPointer(commandBuffer, stencilTestEnable, Mock.vkCmdSetStencilTestEnableEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetStencilTestEnableEXT(CMOCK_vkCmdSetStencilTestEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable); +void CMockExpectParameters_vkCmdSetStencilTestEnableEXT(CMOCK_vkCmdSetStencilTestEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_stencilTestEnable), (void*)(&stencilTestEnable), + sizeof(VkBool32[sizeof(stencilTestEnable) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_stencilTestEnable = 0; +} + +void vkCmdSetStencilTestEnableEXT_CMockIgnore(void) +{ + Mock.vkCmdSetStencilTestEnableEXT_IgnoreBool = (char)1; +} + +void vkCmdSetStencilTestEnableEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetStencilTestEnableEXT_IgnoreBool = (char)0; +} + +void vkCmdSetStencilTestEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetStencilTestEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetStencilTestEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilTestEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetStencilTestEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetStencilTestEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetStencilTestEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetStencilTestEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetStencilTestEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetStencilTestEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilTestEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetStencilTestEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetStencilTestEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetStencilTestEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetStencilTestEnableEXT(cmock_call_instance, commandBuffer, stencilTestEnable); +} + +void vkCmdSetStencilTestEnableEXT_AddCallback(CMOCK_vkCmdSetStencilTestEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetStencilTestEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetStencilTestEnableEXT_CallbackBool = (char)1; + Mock.vkCmdSetStencilTestEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetStencilTestEnableEXT_Stub(CMOCK_vkCmdSetStencilTestEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetStencilTestEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetStencilTestEnableEXT_CallbackBool = (char)0; + Mock.vkCmdSetStencilTestEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetStencilTestEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetStencilTestEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilTestEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetStencilTestEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetStencilTestEnableEXT_CMockIgnoreArg_stencilTestEnable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetStencilTestEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilTestEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetStencilTestEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stencilTestEnable = 1; +} + +void vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetStencilOpEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetStencilOpEXT); + cmock_call_instance = (CMOCK_vkCmdSetStencilOpEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetStencilOpEXT_CallInstance); + Mock.vkCmdSetStencilOpEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetStencilOpEXT_CallInstance); + if (Mock.vkCmdSetStencilOpEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetStencilOpEXT_CallbackBool && + Mock.vkCmdSetStencilOpEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetStencilOpEXT_CallbackFunctionPointer(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp, Mock.vkCmdSetStencilOpEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetStencilOpEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_faceMask) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetStencilOpEXT,CMockString_faceMask); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_faceMask), (void*)(&faceMask), sizeof(VkStencilFaceFlags), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_failOp) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetStencilOpEXT,CMockString_failOp); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_failOp), (void*)(&failOp), sizeof(VkStencilOp), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_passOp) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetStencilOpEXT,CMockString_passOp); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_passOp), (void*)(&passOp), sizeof(VkStencilOp), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_depthFailOp) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetStencilOpEXT,CMockString_depthFailOp); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_depthFailOp), (void*)(&depthFailOp), sizeof(VkStencilOp), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_compareOp) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetStencilOpEXT,CMockString_compareOp); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_compareOp), (void*)(&compareOp), sizeof(VkCompareOp), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetStencilOpEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetStencilOpEXT_CallbackFunctionPointer(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp, Mock.vkCmdSetStencilOpEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetStencilOpEXT(CMOCK_vkCmdSetStencilOpEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp); +void CMockExpectParameters_vkCmdSetStencilOpEXT(CMOCK_vkCmdSetStencilOpEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_faceMask), (void*)(&faceMask), + sizeof(VkStencilFaceFlags[sizeof(faceMask) == sizeof(VkStencilFaceFlags) ? 1 : -1])); /* add VkStencilFaceFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_faceMask = 0; + memcpy((void*)(&cmock_call_instance->Expected_failOp), (void*)(&failOp), + sizeof(VkStencilOp[sizeof(failOp) == sizeof(VkStencilOp) ? 1 : -1])); /* add VkStencilOp to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_failOp = 0; + memcpy((void*)(&cmock_call_instance->Expected_passOp), (void*)(&passOp), + sizeof(VkStencilOp[sizeof(passOp) == sizeof(VkStencilOp) ? 1 : -1])); /* add VkStencilOp to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_passOp = 0; + memcpy((void*)(&cmock_call_instance->Expected_depthFailOp), (void*)(&depthFailOp), + sizeof(VkStencilOp[sizeof(depthFailOp) == sizeof(VkStencilOp) ? 1 : -1])); /* add VkStencilOp to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_depthFailOp = 0; + memcpy((void*)(&cmock_call_instance->Expected_compareOp), (void*)(&compareOp), + sizeof(VkCompareOp[sizeof(compareOp) == sizeof(VkCompareOp) ? 1 : -1])); /* add VkCompareOp to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_compareOp = 0; +} + +void vkCmdSetStencilOpEXT_CMockIgnore(void) +{ + Mock.vkCmdSetStencilOpEXT_IgnoreBool = (char)1; +} + +void vkCmdSetStencilOpEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetStencilOpEXT_IgnoreBool = (char)0; +} + +void vkCmdSetStencilOpEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetStencilOpEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetStencilOpEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilOpEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetStencilOpEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetStencilOpEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetStencilOpEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetStencilOpEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetStencilOpEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetStencilOpEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilOpEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetStencilOpEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetStencilOpEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetStencilOpEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetStencilOpEXT(cmock_call_instance, commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); +} + +void vkCmdSetStencilOpEXT_AddCallback(CMOCK_vkCmdSetStencilOpEXT_CALLBACK Callback) +{ + Mock.vkCmdSetStencilOpEXT_IgnoreBool = (char)0; + Mock.vkCmdSetStencilOpEXT_CallbackBool = (char)1; + Mock.vkCmdSetStencilOpEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetStencilOpEXT_Stub(CMOCK_vkCmdSetStencilOpEXT_CALLBACK Callback) +{ + Mock.vkCmdSetStencilOpEXT_IgnoreBool = (char)0; + Mock.vkCmdSetStencilOpEXT_CallbackBool = (char)0; + Mock.vkCmdSetStencilOpEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetStencilOpEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetStencilOpEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilOpEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetStencilOpEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetStencilOpEXT_CMockIgnoreArg_faceMask(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetStencilOpEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilOpEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetStencilOpEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_faceMask = 1; +} + +void vkCmdSetStencilOpEXT_CMockIgnoreArg_failOp(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetStencilOpEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilOpEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetStencilOpEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_failOp = 1; +} + +void vkCmdSetStencilOpEXT_CMockIgnoreArg_passOp(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetStencilOpEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilOpEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetStencilOpEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_passOp = 1; +} + +void vkCmdSetStencilOpEXT_CMockIgnoreArg_depthFailOp(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetStencilOpEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilOpEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetStencilOpEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_depthFailOp = 1; +} + +void vkCmdSetStencilOpEXT_CMockIgnoreArg_compareOp(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetStencilOpEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetStencilOpEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetStencilOpEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_compareOp = 1; +} + +VkResult vkReleaseSwapchainImagesEXT(VkDevice device, const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkReleaseSwapchainImagesEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkReleaseSwapchainImagesEXT); + cmock_call_instance = (CMOCK_vkReleaseSwapchainImagesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkReleaseSwapchainImagesEXT_CallInstance); + Mock.vkReleaseSwapchainImagesEXT_CallInstance = CMock_Guts_MemNext(Mock.vkReleaseSwapchainImagesEXT_CallInstance); + if (Mock.vkReleaseSwapchainImagesEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkReleaseSwapchainImagesEXT_FinalReturn; + memcpy((void*)(&Mock.vkReleaseSwapchainImagesEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkReleaseSwapchainImagesEXT_CallbackBool && + Mock.vkReleaseSwapchainImagesEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkReleaseSwapchainImagesEXT_CallbackFunctionPointer(device, pReleaseInfo, Mock.vkReleaseSwapchainImagesEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkReleaseSwapchainImagesEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pReleaseInfo) + { + UNITY_SET_DETAILS(CMockString_vkReleaseSwapchainImagesEXT,CMockString_pReleaseInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pReleaseInfo), (void*)(pReleaseInfo), sizeof(const VkReleaseSwapchainImagesInfoEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkReleaseSwapchainImagesEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkReleaseSwapchainImagesEXT_CallbackFunctionPointer(device, pReleaseInfo, Mock.vkReleaseSwapchainImagesEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkReleaseSwapchainImagesEXT(CMOCK_vkReleaseSwapchainImagesEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo); +void CMockExpectParameters_vkReleaseSwapchainImagesEXT(CMOCK_vkReleaseSwapchainImagesEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pReleaseInfo = pReleaseInfo; + cmock_call_instance->IgnoreArg_pReleaseInfo = 0; +} + +void vkReleaseSwapchainImagesEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkReleaseSwapchainImagesEXT_CALL_INSTANCE)); + CMOCK_vkReleaseSwapchainImagesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkReleaseSwapchainImagesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkReleaseSwapchainImagesEXT_CallInstance = CMock_Guts_MemChain(Mock.vkReleaseSwapchainImagesEXT_CallInstance, cmock_guts_index); + Mock.vkReleaseSwapchainImagesEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkReleaseSwapchainImagesEXT_IgnoreBool = (char)1; +} + +void vkReleaseSwapchainImagesEXT_CMockStopIgnore(void) +{ + if(Mock.vkReleaseSwapchainImagesEXT_IgnoreBool) + Mock.vkReleaseSwapchainImagesEXT_CallInstance = CMock_Guts_MemNext(Mock.vkReleaseSwapchainImagesEXT_CallInstance); + Mock.vkReleaseSwapchainImagesEXT_IgnoreBool = (char)0; +} + +void vkReleaseSwapchainImagesEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkReleaseSwapchainImagesEXT_CALL_INSTANCE)); + CMOCK_vkReleaseSwapchainImagesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkReleaseSwapchainImagesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkReleaseSwapchainImagesEXT_CallInstance = CMock_Guts_MemChain(Mock.vkReleaseSwapchainImagesEXT_CallInstance, cmock_guts_index); + Mock.vkReleaseSwapchainImagesEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkReleaseSwapchainImagesEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkReleaseSwapchainImagesEXT_CALL_INSTANCE)); + CMOCK_vkReleaseSwapchainImagesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkReleaseSwapchainImagesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkReleaseSwapchainImagesEXT_CallInstance = CMock_Guts_MemChain(Mock.vkReleaseSwapchainImagesEXT_CallInstance, cmock_guts_index); + Mock.vkReleaseSwapchainImagesEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkReleaseSwapchainImagesEXT(cmock_call_instance, device, pReleaseInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkReleaseSwapchainImagesEXT_AddCallback(CMOCK_vkReleaseSwapchainImagesEXT_CALLBACK Callback) +{ + Mock.vkReleaseSwapchainImagesEXT_IgnoreBool = (char)0; + Mock.vkReleaseSwapchainImagesEXT_CallbackBool = (char)1; + Mock.vkReleaseSwapchainImagesEXT_CallbackFunctionPointer = Callback; +} + +void vkReleaseSwapchainImagesEXT_Stub(CMOCK_vkReleaseSwapchainImagesEXT_CALLBACK Callback) +{ + Mock.vkReleaseSwapchainImagesEXT_IgnoreBool = (char)0; + Mock.vkReleaseSwapchainImagesEXT_CallbackBool = (char)0; + Mock.vkReleaseSwapchainImagesEXT_CallbackFunctionPointer = Callback; +} + +void vkReleaseSwapchainImagesEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkReleaseSwapchainImagesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkReleaseSwapchainImagesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkReleaseSwapchainImagesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkReleaseSwapchainImagesEXT_CMockIgnoreArg_pReleaseInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkReleaseSwapchainImagesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkReleaseSwapchainImagesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkReleaseSwapchainImagesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pReleaseInfo = 1; +} + +void vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetGeneratedCommandsMemoryRequirementsNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetGeneratedCommandsMemoryRequirementsNV); + cmock_call_instance = (CMOCK_vkGetGeneratedCommandsMemoryRequirementsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetGeneratedCommandsMemoryRequirementsNV_CallInstance); + Mock.vkGetGeneratedCommandsMemoryRequirementsNV_CallInstance = CMock_Guts_MemNext(Mock.vkGetGeneratedCommandsMemoryRequirementsNV_CallInstance); + if (Mock.vkGetGeneratedCommandsMemoryRequirementsNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetGeneratedCommandsMemoryRequirementsNV_CallbackBool && + Mock.vkGetGeneratedCommandsMemoryRequirementsNV_CallbackFunctionPointer != NULL) + { + Mock.vkGetGeneratedCommandsMemoryRequirementsNV_CallbackFunctionPointer(device, pInfo, pMemoryRequirements, Mock.vkGetGeneratedCommandsMemoryRequirementsNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetGeneratedCommandsMemoryRequirementsNV,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetGeneratedCommandsMemoryRequirementsNV,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkGeneratedCommandsMemoryRequirementsInfoNV), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMemoryRequirements) + { + UNITY_SET_DETAILS(CMockString_vkGetGeneratedCommandsMemoryRequirementsNV,CMockString_pMemoryRequirements); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMemoryRequirements), (void*)(pMemoryRequirements), sizeof(VkMemoryRequirements2), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetGeneratedCommandsMemoryRequirementsNV_CallbackFunctionPointer != NULL) + { + Mock.vkGetGeneratedCommandsMemoryRequirementsNV_CallbackFunctionPointer(device, pInfo, pMemoryRequirements, Mock.vkGetGeneratedCommandsMemoryRequirementsNV_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pMemoryRequirements, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pMemoryRequirements, (const void*)cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Val, + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetGeneratedCommandsMemoryRequirementsNV(CMOCK_vkGetGeneratedCommandsMemoryRequirementsNV_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements); +void CMockExpectParameters_vkGetGeneratedCommandsMemoryRequirementsNV(CMOCK_vkGetGeneratedCommandsMemoryRequirementsNV_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; + cmock_call_instance->Expected_pMemoryRequirements = pMemoryRequirements; + cmock_call_instance->IgnoreArg_pMemoryRequirements = 0; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used = 0; +} + +void vkGetGeneratedCommandsMemoryRequirementsNV_CMockIgnore(void) +{ + Mock.vkGetGeneratedCommandsMemoryRequirementsNV_IgnoreBool = (char)1; +} + +void vkGetGeneratedCommandsMemoryRequirementsNV_CMockStopIgnore(void) +{ + Mock.vkGetGeneratedCommandsMemoryRequirementsNV_IgnoreBool = (char)0; +} + +void vkGetGeneratedCommandsMemoryRequirementsNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetGeneratedCommandsMemoryRequirementsNV_CALL_INSTANCE)); + CMOCK_vkGetGeneratedCommandsMemoryRequirementsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetGeneratedCommandsMemoryRequirementsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetGeneratedCommandsMemoryRequirementsNV_CallInstance = CMock_Guts_MemChain(Mock.vkGetGeneratedCommandsMemoryRequirementsNV_CallInstance, cmock_guts_index); + Mock.vkGetGeneratedCommandsMemoryRequirementsNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetGeneratedCommandsMemoryRequirementsNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetGeneratedCommandsMemoryRequirementsNV_CALL_INSTANCE)); + CMOCK_vkGetGeneratedCommandsMemoryRequirementsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetGeneratedCommandsMemoryRequirementsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetGeneratedCommandsMemoryRequirementsNV_CallInstance = CMock_Guts_MemChain(Mock.vkGetGeneratedCommandsMemoryRequirementsNV_CallInstance, cmock_guts_index); + Mock.vkGetGeneratedCommandsMemoryRequirementsNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetGeneratedCommandsMemoryRequirementsNV(cmock_call_instance, device, pInfo, pMemoryRequirements); +} + +void vkGetGeneratedCommandsMemoryRequirementsNV_AddCallback(CMOCK_vkGetGeneratedCommandsMemoryRequirementsNV_CALLBACK Callback) +{ + Mock.vkGetGeneratedCommandsMemoryRequirementsNV_IgnoreBool = (char)0; + Mock.vkGetGeneratedCommandsMemoryRequirementsNV_CallbackBool = (char)1; + Mock.vkGetGeneratedCommandsMemoryRequirementsNV_CallbackFunctionPointer = Callback; +} + +void vkGetGeneratedCommandsMemoryRequirementsNV_Stub(CMOCK_vkGetGeneratedCommandsMemoryRequirementsNV_CALLBACK Callback) +{ + Mock.vkGetGeneratedCommandsMemoryRequirementsNV_IgnoreBool = (char)0; + Mock.vkGetGeneratedCommandsMemoryRequirementsNV_CallbackBool = (char)0; + Mock.vkGetGeneratedCommandsMemoryRequirementsNV_CallbackFunctionPointer = Callback; +} + +void vkGetGeneratedCommandsMemoryRequirementsNV_CMockReturnMemThruPtr_pMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkMemoryRequirements2 const* pMemoryRequirements, size_t cmock_size) +{ + CMOCK_vkGetGeneratedCommandsMemoryRequirementsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetGeneratedCommandsMemoryRequirementsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetGeneratedCommandsMemoryRequirementsNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Used = 1; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Val = pMemoryRequirements; + cmock_call_instance->ReturnThruPtr_pMemoryRequirements_Size = cmock_size; +} + +void vkGetGeneratedCommandsMemoryRequirementsNV_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetGeneratedCommandsMemoryRequirementsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetGeneratedCommandsMemoryRequirementsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetGeneratedCommandsMemoryRequirementsNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetGeneratedCommandsMemoryRequirementsNV_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetGeneratedCommandsMemoryRequirementsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetGeneratedCommandsMemoryRequirementsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetGeneratedCommandsMemoryRequirementsNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +void vkGetGeneratedCommandsMemoryRequirementsNV_CMockIgnoreArg_pMemoryRequirements(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetGeneratedCommandsMemoryRequirementsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetGeneratedCommandsMemoryRequirementsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetGeneratedCommandsMemoryRequirementsNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMemoryRequirements = 1; +} + +void vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdPreprocessGeneratedCommandsNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdPreprocessGeneratedCommandsNV); + cmock_call_instance = (CMOCK_vkCmdPreprocessGeneratedCommandsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdPreprocessGeneratedCommandsNV_CallInstance); + Mock.vkCmdPreprocessGeneratedCommandsNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdPreprocessGeneratedCommandsNV_CallInstance); + if (Mock.vkCmdPreprocessGeneratedCommandsNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdPreprocessGeneratedCommandsNV_CallbackBool && + Mock.vkCmdPreprocessGeneratedCommandsNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdPreprocessGeneratedCommandsNV_CallbackFunctionPointer(commandBuffer, pGeneratedCommandsInfo, Mock.vkCmdPreprocessGeneratedCommandsNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdPreprocessGeneratedCommandsNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pGeneratedCommandsInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdPreprocessGeneratedCommandsNV,CMockString_pGeneratedCommandsInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pGeneratedCommandsInfo), (void*)(pGeneratedCommandsInfo), sizeof(const VkGeneratedCommandsInfoNV), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdPreprocessGeneratedCommandsNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdPreprocessGeneratedCommandsNV_CallbackFunctionPointer(commandBuffer, pGeneratedCommandsInfo, Mock.vkCmdPreprocessGeneratedCommandsNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdPreprocessGeneratedCommandsNV(CMOCK_vkCmdPreprocessGeneratedCommandsNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); +void CMockExpectParameters_vkCmdPreprocessGeneratedCommandsNV(CMOCK_vkCmdPreprocessGeneratedCommandsNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pGeneratedCommandsInfo = pGeneratedCommandsInfo; + cmock_call_instance->IgnoreArg_pGeneratedCommandsInfo = 0; +} + +void vkCmdPreprocessGeneratedCommandsNV_CMockIgnore(void) +{ + Mock.vkCmdPreprocessGeneratedCommandsNV_IgnoreBool = (char)1; +} + +void vkCmdPreprocessGeneratedCommandsNV_CMockStopIgnore(void) +{ + Mock.vkCmdPreprocessGeneratedCommandsNV_IgnoreBool = (char)0; +} + +void vkCmdPreprocessGeneratedCommandsNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdPreprocessGeneratedCommandsNV_CALL_INSTANCE)); + CMOCK_vkCmdPreprocessGeneratedCommandsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPreprocessGeneratedCommandsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdPreprocessGeneratedCommandsNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdPreprocessGeneratedCommandsNV_CallInstance, cmock_guts_index); + Mock.vkCmdPreprocessGeneratedCommandsNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdPreprocessGeneratedCommandsNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdPreprocessGeneratedCommandsNV_CALL_INSTANCE)); + CMOCK_vkCmdPreprocessGeneratedCommandsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPreprocessGeneratedCommandsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdPreprocessGeneratedCommandsNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdPreprocessGeneratedCommandsNV_CallInstance, cmock_guts_index); + Mock.vkCmdPreprocessGeneratedCommandsNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdPreprocessGeneratedCommandsNV(cmock_call_instance, commandBuffer, pGeneratedCommandsInfo); +} + +void vkCmdPreprocessGeneratedCommandsNV_AddCallback(CMOCK_vkCmdPreprocessGeneratedCommandsNV_CALLBACK Callback) +{ + Mock.vkCmdPreprocessGeneratedCommandsNV_IgnoreBool = (char)0; + Mock.vkCmdPreprocessGeneratedCommandsNV_CallbackBool = (char)1; + Mock.vkCmdPreprocessGeneratedCommandsNV_CallbackFunctionPointer = Callback; +} + +void vkCmdPreprocessGeneratedCommandsNV_Stub(CMOCK_vkCmdPreprocessGeneratedCommandsNV_CALLBACK Callback) +{ + Mock.vkCmdPreprocessGeneratedCommandsNV_IgnoreBool = (char)0; + Mock.vkCmdPreprocessGeneratedCommandsNV_CallbackBool = (char)0; + Mock.vkCmdPreprocessGeneratedCommandsNV_CallbackFunctionPointer = Callback; +} + +void vkCmdPreprocessGeneratedCommandsNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPreprocessGeneratedCommandsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPreprocessGeneratedCommandsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPreprocessGeneratedCommandsNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdPreprocessGeneratedCommandsNV_CMockIgnoreArg_pGeneratedCommandsInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdPreprocessGeneratedCommandsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdPreprocessGeneratedCommandsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdPreprocessGeneratedCommandsNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pGeneratedCommandsInfo = 1; +} + +void vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdExecuteGeneratedCommandsNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdExecuteGeneratedCommandsNV); + cmock_call_instance = (CMOCK_vkCmdExecuteGeneratedCommandsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdExecuteGeneratedCommandsNV_CallInstance); + Mock.vkCmdExecuteGeneratedCommandsNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdExecuteGeneratedCommandsNV_CallInstance); + if (Mock.vkCmdExecuteGeneratedCommandsNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdExecuteGeneratedCommandsNV_CallbackBool && + Mock.vkCmdExecuteGeneratedCommandsNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdExecuteGeneratedCommandsNV_CallbackFunctionPointer(commandBuffer, isPreprocessed, pGeneratedCommandsInfo, Mock.vkCmdExecuteGeneratedCommandsNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdExecuteGeneratedCommandsNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_isPreprocessed) + { + UNITY_SET_DETAILS(CMockString_vkCmdExecuteGeneratedCommandsNV,CMockString_isPreprocessed); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_isPreprocessed), (void*)(&isPreprocessed), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pGeneratedCommandsInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdExecuteGeneratedCommandsNV,CMockString_pGeneratedCommandsInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pGeneratedCommandsInfo), (void*)(pGeneratedCommandsInfo), sizeof(const VkGeneratedCommandsInfoNV), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdExecuteGeneratedCommandsNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdExecuteGeneratedCommandsNV_CallbackFunctionPointer(commandBuffer, isPreprocessed, pGeneratedCommandsInfo, Mock.vkCmdExecuteGeneratedCommandsNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdExecuteGeneratedCommandsNV(CMOCK_vkCmdExecuteGeneratedCommandsNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); +void CMockExpectParameters_vkCmdExecuteGeneratedCommandsNV(CMOCK_vkCmdExecuteGeneratedCommandsNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_isPreprocessed), (void*)(&isPreprocessed), + sizeof(VkBool32[sizeof(isPreprocessed) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_isPreprocessed = 0; + cmock_call_instance->Expected_pGeneratedCommandsInfo = pGeneratedCommandsInfo; + cmock_call_instance->IgnoreArg_pGeneratedCommandsInfo = 0; +} + +void vkCmdExecuteGeneratedCommandsNV_CMockIgnore(void) +{ + Mock.vkCmdExecuteGeneratedCommandsNV_IgnoreBool = (char)1; +} + +void vkCmdExecuteGeneratedCommandsNV_CMockStopIgnore(void) +{ + Mock.vkCmdExecuteGeneratedCommandsNV_IgnoreBool = (char)0; +} + +void vkCmdExecuteGeneratedCommandsNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdExecuteGeneratedCommandsNV_CALL_INSTANCE)); + CMOCK_vkCmdExecuteGeneratedCommandsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdExecuteGeneratedCommandsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdExecuteGeneratedCommandsNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdExecuteGeneratedCommandsNV_CallInstance, cmock_guts_index); + Mock.vkCmdExecuteGeneratedCommandsNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdExecuteGeneratedCommandsNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdExecuteGeneratedCommandsNV_CALL_INSTANCE)); + CMOCK_vkCmdExecuteGeneratedCommandsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdExecuteGeneratedCommandsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdExecuteGeneratedCommandsNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdExecuteGeneratedCommandsNV_CallInstance, cmock_guts_index); + Mock.vkCmdExecuteGeneratedCommandsNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdExecuteGeneratedCommandsNV(cmock_call_instance, commandBuffer, isPreprocessed, pGeneratedCommandsInfo); +} + +void vkCmdExecuteGeneratedCommandsNV_AddCallback(CMOCK_vkCmdExecuteGeneratedCommandsNV_CALLBACK Callback) +{ + Mock.vkCmdExecuteGeneratedCommandsNV_IgnoreBool = (char)0; + Mock.vkCmdExecuteGeneratedCommandsNV_CallbackBool = (char)1; + Mock.vkCmdExecuteGeneratedCommandsNV_CallbackFunctionPointer = Callback; +} + +void vkCmdExecuteGeneratedCommandsNV_Stub(CMOCK_vkCmdExecuteGeneratedCommandsNV_CALLBACK Callback) +{ + Mock.vkCmdExecuteGeneratedCommandsNV_IgnoreBool = (char)0; + Mock.vkCmdExecuteGeneratedCommandsNV_CallbackBool = (char)0; + Mock.vkCmdExecuteGeneratedCommandsNV_CallbackFunctionPointer = Callback; +} + +void vkCmdExecuteGeneratedCommandsNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdExecuteGeneratedCommandsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdExecuteGeneratedCommandsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdExecuteGeneratedCommandsNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdExecuteGeneratedCommandsNV_CMockIgnoreArg_isPreprocessed(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdExecuteGeneratedCommandsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdExecuteGeneratedCommandsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdExecuteGeneratedCommandsNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_isPreprocessed = 1; +} + +void vkCmdExecuteGeneratedCommandsNV_CMockIgnoreArg_pGeneratedCommandsInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdExecuteGeneratedCommandsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdExecuteGeneratedCommandsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdExecuteGeneratedCommandsNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pGeneratedCommandsInfo = 1; +} + +void vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBindPipelineShaderGroupNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBindPipelineShaderGroupNV); + cmock_call_instance = (CMOCK_vkCmdBindPipelineShaderGroupNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBindPipelineShaderGroupNV_CallInstance); + Mock.vkCmdBindPipelineShaderGroupNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBindPipelineShaderGroupNV_CallInstance); + if (Mock.vkCmdBindPipelineShaderGroupNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBindPipelineShaderGroupNV_CallbackBool && + Mock.vkCmdBindPipelineShaderGroupNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBindPipelineShaderGroupNV_CallbackFunctionPointer(commandBuffer, pipelineBindPoint, pipeline, groupIndex, Mock.vkCmdBindPipelineShaderGroupNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindPipelineShaderGroupNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pipelineBindPoint) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindPipelineShaderGroupNV,CMockString_pipelineBindPoint); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_pipelineBindPoint), (void*)(&pipelineBindPoint), sizeof(VkPipelineBindPoint), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pipeline) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindPipelineShaderGroupNV,CMockString_pipeline); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_pipeline), (void*)(&pipeline), sizeof(VkPipeline), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_groupIndex) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindPipelineShaderGroupNV,CMockString_groupIndex); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_groupIndex, groupIndex, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdBindPipelineShaderGroupNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBindPipelineShaderGroupNV_CallbackFunctionPointer(commandBuffer, pipelineBindPoint, pipeline, groupIndex, Mock.vkCmdBindPipelineShaderGroupNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBindPipelineShaderGroupNV(CMOCK_vkCmdBindPipelineShaderGroupNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex); +void CMockExpectParameters_vkCmdBindPipelineShaderGroupNV(CMOCK_vkCmdBindPipelineShaderGroupNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_pipelineBindPoint), (void*)(&pipelineBindPoint), + sizeof(VkPipelineBindPoint[sizeof(pipelineBindPoint) == sizeof(VkPipelineBindPoint) ? 1 : -1])); /* add VkPipelineBindPoint to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_pipelineBindPoint = 0; + memcpy((void*)(&cmock_call_instance->Expected_pipeline), (void*)(&pipeline), + sizeof(VkPipeline[sizeof(pipeline) == sizeof(VkPipeline) ? 1 : -1])); /* add VkPipeline to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_pipeline = 0; + cmock_call_instance->Expected_groupIndex = groupIndex; + cmock_call_instance->IgnoreArg_groupIndex = 0; +} + +void vkCmdBindPipelineShaderGroupNV_CMockIgnore(void) +{ + Mock.vkCmdBindPipelineShaderGroupNV_IgnoreBool = (char)1; +} + +void vkCmdBindPipelineShaderGroupNV_CMockStopIgnore(void) +{ + Mock.vkCmdBindPipelineShaderGroupNV_IgnoreBool = (char)0; +} + +void vkCmdBindPipelineShaderGroupNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBindPipelineShaderGroupNV_CALL_INSTANCE)); + CMOCK_vkCmdBindPipelineShaderGroupNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindPipelineShaderGroupNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBindPipelineShaderGroupNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBindPipelineShaderGroupNV_CallInstance, cmock_guts_index); + Mock.vkCmdBindPipelineShaderGroupNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBindPipelineShaderGroupNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBindPipelineShaderGroupNV_CALL_INSTANCE)); + CMOCK_vkCmdBindPipelineShaderGroupNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindPipelineShaderGroupNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBindPipelineShaderGroupNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBindPipelineShaderGroupNV_CallInstance, cmock_guts_index); + Mock.vkCmdBindPipelineShaderGroupNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBindPipelineShaderGroupNV(cmock_call_instance, commandBuffer, pipelineBindPoint, pipeline, groupIndex); +} + +void vkCmdBindPipelineShaderGroupNV_AddCallback(CMOCK_vkCmdBindPipelineShaderGroupNV_CALLBACK Callback) +{ + Mock.vkCmdBindPipelineShaderGroupNV_IgnoreBool = (char)0; + Mock.vkCmdBindPipelineShaderGroupNV_CallbackBool = (char)1; + Mock.vkCmdBindPipelineShaderGroupNV_CallbackFunctionPointer = Callback; +} + +void vkCmdBindPipelineShaderGroupNV_Stub(CMOCK_vkCmdBindPipelineShaderGroupNV_CALLBACK Callback) +{ + Mock.vkCmdBindPipelineShaderGroupNV_IgnoreBool = (char)0; + Mock.vkCmdBindPipelineShaderGroupNV_CallbackBool = (char)0; + Mock.vkCmdBindPipelineShaderGroupNV_CallbackFunctionPointer = Callback; +} + +void vkCmdBindPipelineShaderGroupNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindPipelineShaderGroupNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindPipelineShaderGroupNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindPipelineShaderGroupNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBindPipelineShaderGroupNV_CMockIgnoreArg_pipelineBindPoint(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindPipelineShaderGroupNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindPipelineShaderGroupNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindPipelineShaderGroupNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pipelineBindPoint = 1; +} + +void vkCmdBindPipelineShaderGroupNV_CMockIgnoreArg_pipeline(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindPipelineShaderGroupNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindPipelineShaderGroupNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindPipelineShaderGroupNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pipeline = 1; +} + +void vkCmdBindPipelineShaderGroupNV_CMockIgnoreArg_groupIndex(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindPipelineShaderGroupNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindPipelineShaderGroupNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindPipelineShaderGroupNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_groupIndex = 1; +} + +VkResult vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateIndirectCommandsLayoutNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateIndirectCommandsLayoutNV); + cmock_call_instance = (CMOCK_vkCreateIndirectCommandsLayoutNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateIndirectCommandsLayoutNV_CallInstance); + Mock.vkCreateIndirectCommandsLayoutNV_CallInstance = CMock_Guts_MemNext(Mock.vkCreateIndirectCommandsLayoutNV_CallInstance); + if (Mock.vkCreateIndirectCommandsLayoutNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateIndirectCommandsLayoutNV_FinalReturn; + memcpy((void*)(&Mock.vkCreateIndirectCommandsLayoutNV_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateIndirectCommandsLayoutNV_CallbackBool && + Mock.vkCreateIndirectCommandsLayoutNV_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateIndirectCommandsLayoutNV_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pIndirectCommandsLayout, Mock.vkCreateIndirectCommandsLayoutNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateIndirectCommandsLayoutNV,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateIndirectCommandsLayoutNV,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkIndirectCommandsLayoutCreateInfoNV), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateIndirectCommandsLayoutNV,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pIndirectCommandsLayout) + { + UNITY_SET_DETAILS(CMockString_vkCreateIndirectCommandsLayoutNV,CMockString_pIndirectCommandsLayout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pIndirectCommandsLayout), (void*)(pIndirectCommandsLayout), sizeof(VkIndirectCommandsLayoutNV), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateIndirectCommandsLayoutNV_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateIndirectCommandsLayoutNV_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pIndirectCommandsLayout, Mock.vkCreateIndirectCommandsLayoutNV_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pIndirectCommandsLayout_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pIndirectCommandsLayout, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pIndirectCommandsLayout, (const void*)cmock_call_instance->ReturnThruPtr_pIndirectCommandsLayout_Val, + cmock_call_instance->ReturnThruPtr_pIndirectCommandsLayout_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateIndirectCommandsLayoutNV(CMOCK_vkCreateIndirectCommandsLayoutNV_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout); +void CMockExpectParameters_vkCreateIndirectCommandsLayoutNV(CMOCK_vkCreateIndirectCommandsLayoutNV_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pIndirectCommandsLayout = pIndirectCommandsLayout; + cmock_call_instance->IgnoreArg_pIndirectCommandsLayout = 0; + cmock_call_instance->ReturnThruPtr_pIndirectCommandsLayout_Used = 0; +} + +void vkCreateIndirectCommandsLayoutNV_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateIndirectCommandsLayoutNV_CALL_INSTANCE)); + CMOCK_vkCreateIndirectCommandsLayoutNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateIndirectCommandsLayoutNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateIndirectCommandsLayoutNV_CallInstance = CMock_Guts_MemChain(Mock.vkCreateIndirectCommandsLayoutNV_CallInstance, cmock_guts_index); + Mock.vkCreateIndirectCommandsLayoutNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateIndirectCommandsLayoutNV_IgnoreBool = (char)1; +} + +void vkCreateIndirectCommandsLayoutNV_CMockStopIgnore(void) +{ + if(Mock.vkCreateIndirectCommandsLayoutNV_IgnoreBool) + Mock.vkCreateIndirectCommandsLayoutNV_CallInstance = CMock_Guts_MemNext(Mock.vkCreateIndirectCommandsLayoutNV_CallInstance); + Mock.vkCreateIndirectCommandsLayoutNV_IgnoreBool = (char)0; +} + +void vkCreateIndirectCommandsLayoutNV_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateIndirectCommandsLayoutNV_CALL_INSTANCE)); + CMOCK_vkCreateIndirectCommandsLayoutNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateIndirectCommandsLayoutNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateIndirectCommandsLayoutNV_CallInstance = CMock_Guts_MemChain(Mock.vkCreateIndirectCommandsLayoutNV_CallInstance, cmock_guts_index); + Mock.vkCreateIndirectCommandsLayoutNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateIndirectCommandsLayoutNV_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateIndirectCommandsLayoutNV_CALL_INSTANCE)); + CMOCK_vkCreateIndirectCommandsLayoutNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateIndirectCommandsLayoutNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateIndirectCommandsLayoutNV_CallInstance = CMock_Guts_MemChain(Mock.vkCreateIndirectCommandsLayoutNV_CallInstance, cmock_guts_index); + Mock.vkCreateIndirectCommandsLayoutNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateIndirectCommandsLayoutNV(cmock_call_instance, device, pCreateInfo, pAllocator, pIndirectCommandsLayout); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateIndirectCommandsLayoutNV_AddCallback(CMOCK_vkCreateIndirectCommandsLayoutNV_CALLBACK Callback) +{ + Mock.vkCreateIndirectCommandsLayoutNV_IgnoreBool = (char)0; + Mock.vkCreateIndirectCommandsLayoutNV_CallbackBool = (char)1; + Mock.vkCreateIndirectCommandsLayoutNV_CallbackFunctionPointer = Callback; +} + +void vkCreateIndirectCommandsLayoutNV_Stub(CMOCK_vkCreateIndirectCommandsLayoutNV_CALLBACK Callback) +{ + Mock.vkCreateIndirectCommandsLayoutNV_IgnoreBool = (char)0; + Mock.vkCreateIndirectCommandsLayoutNV_CallbackBool = (char)0; + Mock.vkCreateIndirectCommandsLayoutNV_CallbackFunctionPointer = Callback; +} + +void vkCreateIndirectCommandsLayoutNV_CMockReturnMemThruPtr_pIndirectCommandsLayout(UNITY_LINE_TYPE cmock_line, VkIndirectCommandsLayoutNV const* pIndirectCommandsLayout, size_t cmock_size) +{ + CMOCK_vkCreateIndirectCommandsLayoutNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateIndirectCommandsLayoutNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateIndirectCommandsLayoutNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pIndirectCommandsLayout_Used = 1; + cmock_call_instance->ReturnThruPtr_pIndirectCommandsLayout_Val = pIndirectCommandsLayout; + cmock_call_instance->ReturnThruPtr_pIndirectCommandsLayout_Size = cmock_size; +} + +void vkCreateIndirectCommandsLayoutNV_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateIndirectCommandsLayoutNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateIndirectCommandsLayoutNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateIndirectCommandsLayoutNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateIndirectCommandsLayoutNV_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateIndirectCommandsLayoutNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateIndirectCommandsLayoutNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateIndirectCommandsLayoutNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateIndirectCommandsLayoutNV_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateIndirectCommandsLayoutNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateIndirectCommandsLayoutNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateIndirectCommandsLayoutNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateIndirectCommandsLayoutNV_CMockIgnoreArg_pIndirectCommandsLayout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateIndirectCommandsLayoutNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateIndirectCommandsLayoutNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateIndirectCommandsLayoutNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pIndirectCommandsLayout = 1; +} + +void vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyIndirectCommandsLayoutNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyIndirectCommandsLayoutNV); + cmock_call_instance = (CMOCK_vkDestroyIndirectCommandsLayoutNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyIndirectCommandsLayoutNV_CallInstance); + Mock.vkDestroyIndirectCommandsLayoutNV_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyIndirectCommandsLayoutNV_CallInstance); + if (Mock.vkDestroyIndirectCommandsLayoutNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyIndirectCommandsLayoutNV_CallbackBool && + Mock.vkDestroyIndirectCommandsLayoutNV_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyIndirectCommandsLayoutNV_CallbackFunctionPointer(device, indirectCommandsLayout, pAllocator, Mock.vkDestroyIndirectCommandsLayoutNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyIndirectCommandsLayoutNV,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_indirectCommandsLayout) + { + UNITY_SET_DETAILS(CMockString_vkDestroyIndirectCommandsLayoutNV,CMockString_indirectCommandsLayout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_indirectCommandsLayout), (void*)(&indirectCommandsLayout), sizeof(VkIndirectCommandsLayoutNV), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyIndirectCommandsLayoutNV,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyIndirectCommandsLayoutNV_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyIndirectCommandsLayoutNV_CallbackFunctionPointer(device, indirectCommandsLayout, pAllocator, Mock.vkDestroyIndirectCommandsLayoutNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyIndirectCommandsLayoutNV(CMOCK_vkDestroyIndirectCommandsLayoutNV_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyIndirectCommandsLayoutNV(CMOCK_vkDestroyIndirectCommandsLayoutNV_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_indirectCommandsLayout), (void*)(&indirectCommandsLayout), + sizeof(VkIndirectCommandsLayoutNV[sizeof(indirectCommandsLayout) == sizeof(VkIndirectCommandsLayoutNV) ? 1 : -1])); /* add VkIndirectCommandsLayoutNV to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_indirectCommandsLayout = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyIndirectCommandsLayoutNV_CMockIgnore(void) +{ + Mock.vkDestroyIndirectCommandsLayoutNV_IgnoreBool = (char)1; +} + +void vkDestroyIndirectCommandsLayoutNV_CMockStopIgnore(void) +{ + Mock.vkDestroyIndirectCommandsLayoutNV_IgnoreBool = (char)0; +} + +void vkDestroyIndirectCommandsLayoutNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyIndirectCommandsLayoutNV_CALL_INSTANCE)); + CMOCK_vkDestroyIndirectCommandsLayoutNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyIndirectCommandsLayoutNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyIndirectCommandsLayoutNV_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyIndirectCommandsLayoutNV_CallInstance, cmock_guts_index); + Mock.vkDestroyIndirectCommandsLayoutNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyIndirectCommandsLayoutNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyIndirectCommandsLayoutNV_CALL_INSTANCE)); + CMOCK_vkDestroyIndirectCommandsLayoutNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyIndirectCommandsLayoutNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyIndirectCommandsLayoutNV_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyIndirectCommandsLayoutNV_CallInstance, cmock_guts_index); + Mock.vkDestroyIndirectCommandsLayoutNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyIndirectCommandsLayoutNV(cmock_call_instance, device, indirectCommandsLayout, pAllocator); +} + +void vkDestroyIndirectCommandsLayoutNV_AddCallback(CMOCK_vkDestroyIndirectCommandsLayoutNV_CALLBACK Callback) +{ + Mock.vkDestroyIndirectCommandsLayoutNV_IgnoreBool = (char)0; + Mock.vkDestroyIndirectCommandsLayoutNV_CallbackBool = (char)1; + Mock.vkDestroyIndirectCommandsLayoutNV_CallbackFunctionPointer = Callback; +} + +void vkDestroyIndirectCommandsLayoutNV_Stub(CMOCK_vkDestroyIndirectCommandsLayoutNV_CALLBACK Callback) +{ + Mock.vkDestroyIndirectCommandsLayoutNV_IgnoreBool = (char)0; + Mock.vkDestroyIndirectCommandsLayoutNV_CallbackBool = (char)0; + Mock.vkDestroyIndirectCommandsLayoutNV_CallbackFunctionPointer = Callback; +} + +void vkDestroyIndirectCommandsLayoutNV_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyIndirectCommandsLayoutNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyIndirectCommandsLayoutNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyIndirectCommandsLayoutNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyIndirectCommandsLayoutNV_CMockIgnoreArg_indirectCommandsLayout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyIndirectCommandsLayoutNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyIndirectCommandsLayoutNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyIndirectCommandsLayoutNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_indirectCommandsLayout = 1; +} + +void vkDestroyIndirectCommandsLayoutNV_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyIndirectCommandsLayoutNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyIndirectCommandsLayoutNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyIndirectCommandsLayoutNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +VkResult vkAcquireDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkAcquireDrmDisplayEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkAcquireDrmDisplayEXT); + cmock_call_instance = (CMOCK_vkAcquireDrmDisplayEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkAcquireDrmDisplayEXT_CallInstance); + Mock.vkAcquireDrmDisplayEXT_CallInstance = CMock_Guts_MemNext(Mock.vkAcquireDrmDisplayEXT_CallInstance); + if (Mock.vkAcquireDrmDisplayEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkAcquireDrmDisplayEXT_FinalReturn; + memcpy((void*)(&Mock.vkAcquireDrmDisplayEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkAcquireDrmDisplayEXT_CallbackBool && + Mock.vkAcquireDrmDisplayEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkAcquireDrmDisplayEXT_CallbackFunctionPointer(physicalDevice, drmFd, display, Mock.vkAcquireDrmDisplayEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkAcquireDrmDisplayEXT,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_drmFd) + { + UNITY_SET_DETAILS(CMockString_vkAcquireDrmDisplayEXT,CMockString_drmFd); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_drmFd, drmFd, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_display) + { + UNITY_SET_DETAILS(CMockString_vkAcquireDrmDisplayEXT,CMockString_display); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_display), (void*)(&display), sizeof(VkDisplayKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkAcquireDrmDisplayEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkAcquireDrmDisplayEXT_CallbackFunctionPointer(physicalDevice, drmFd, display, Mock.vkAcquireDrmDisplayEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkAcquireDrmDisplayEXT(CMOCK_vkAcquireDrmDisplayEXT_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display); +void CMockExpectParameters_vkAcquireDrmDisplayEXT(CMOCK_vkAcquireDrmDisplayEXT_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_drmFd = drmFd; + cmock_call_instance->IgnoreArg_drmFd = 0; + memcpy((void*)(&cmock_call_instance->Expected_display), (void*)(&display), + sizeof(VkDisplayKHR[sizeof(display) == sizeof(VkDisplayKHR) ? 1 : -1])); /* add VkDisplayKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_display = 0; +} + +void vkAcquireDrmDisplayEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkAcquireDrmDisplayEXT_CALL_INSTANCE)); + CMOCK_vkAcquireDrmDisplayEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquireDrmDisplayEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkAcquireDrmDisplayEXT_CallInstance = CMock_Guts_MemChain(Mock.vkAcquireDrmDisplayEXT_CallInstance, cmock_guts_index); + Mock.vkAcquireDrmDisplayEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkAcquireDrmDisplayEXT_IgnoreBool = (char)1; +} + +void vkAcquireDrmDisplayEXT_CMockStopIgnore(void) +{ + if(Mock.vkAcquireDrmDisplayEXT_IgnoreBool) + Mock.vkAcquireDrmDisplayEXT_CallInstance = CMock_Guts_MemNext(Mock.vkAcquireDrmDisplayEXT_CallInstance); + Mock.vkAcquireDrmDisplayEXT_IgnoreBool = (char)0; +} + +void vkAcquireDrmDisplayEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkAcquireDrmDisplayEXT_CALL_INSTANCE)); + CMOCK_vkAcquireDrmDisplayEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquireDrmDisplayEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkAcquireDrmDisplayEXT_CallInstance = CMock_Guts_MemChain(Mock.vkAcquireDrmDisplayEXT_CallInstance, cmock_guts_index); + Mock.vkAcquireDrmDisplayEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkAcquireDrmDisplayEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkAcquireDrmDisplayEXT_CALL_INSTANCE)); + CMOCK_vkAcquireDrmDisplayEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquireDrmDisplayEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkAcquireDrmDisplayEXT_CallInstance = CMock_Guts_MemChain(Mock.vkAcquireDrmDisplayEXT_CallInstance, cmock_guts_index); + Mock.vkAcquireDrmDisplayEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkAcquireDrmDisplayEXT(cmock_call_instance, physicalDevice, drmFd, display); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkAcquireDrmDisplayEXT_AddCallback(CMOCK_vkAcquireDrmDisplayEXT_CALLBACK Callback) +{ + Mock.vkAcquireDrmDisplayEXT_IgnoreBool = (char)0; + Mock.vkAcquireDrmDisplayEXT_CallbackBool = (char)1; + Mock.vkAcquireDrmDisplayEXT_CallbackFunctionPointer = Callback; +} + +void vkAcquireDrmDisplayEXT_Stub(CMOCK_vkAcquireDrmDisplayEXT_CALLBACK Callback) +{ + Mock.vkAcquireDrmDisplayEXT_IgnoreBool = (char)0; + Mock.vkAcquireDrmDisplayEXT_CallbackBool = (char)0; + Mock.vkAcquireDrmDisplayEXT_CallbackFunctionPointer = Callback; +} + +void vkAcquireDrmDisplayEXT_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkAcquireDrmDisplayEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquireDrmDisplayEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAcquireDrmDisplayEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkAcquireDrmDisplayEXT_CMockIgnoreArg_drmFd(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkAcquireDrmDisplayEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquireDrmDisplayEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAcquireDrmDisplayEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_drmFd = 1; +} + +void vkAcquireDrmDisplayEXT_CMockIgnoreArg_display(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkAcquireDrmDisplayEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkAcquireDrmDisplayEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkAcquireDrmDisplayEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_display = 1; +} + +VkResult vkGetDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDrmDisplayEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDrmDisplayEXT); + cmock_call_instance = (CMOCK_vkGetDrmDisplayEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDrmDisplayEXT_CallInstance); + Mock.vkGetDrmDisplayEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetDrmDisplayEXT_CallInstance); + if (Mock.vkGetDrmDisplayEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetDrmDisplayEXT_FinalReturn; + memcpy((void*)(&Mock.vkGetDrmDisplayEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetDrmDisplayEXT_CallbackBool && + Mock.vkGetDrmDisplayEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetDrmDisplayEXT_CallbackFunctionPointer(physicalDevice, drmFd, connectorId, display, Mock.vkGetDrmDisplayEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetDrmDisplayEXT,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_drmFd) + { + UNITY_SET_DETAILS(CMockString_vkGetDrmDisplayEXT,CMockString_drmFd); + UNITY_TEST_ASSERT_EQUAL_INT(cmock_call_instance->Expected_drmFd, drmFd, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_connectorId) + { + UNITY_SET_DETAILS(CMockString_vkGetDrmDisplayEXT,CMockString_connectorId); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_connectorId, connectorId, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_display) + { + UNITY_SET_DETAILS(CMockString_vkGetDrmDisplayEXT,CMockString_display); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_display), (void*)(display), sizeof(VkDisplayKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDrmDisplayEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetDrmDisplayEXT_CallbackFunctionPointer(physicalDevice, drmFd, connectorId, display, Mock.vkGetDrmDisplayEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_display_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(display, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)display, (const void*)cmock_call_instance->ReturnThruPtr_display_Val, + cmock_call_instance->ReturnThruPtr_display_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetDrmDisplayEXT(CMOCK_vkGetDrmDisplayEXT_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display); +void CMockExpectParameters_vkGetDrmDisplayEXT(CMOCK_vkGetDrmDisplayEXT_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_drmFd = drmFd; + cmock_call_instance->IgnoreArg_drmFd = 0; + cmock_call_instance->Expected_connectorId = connectorId; + cmock_call_instance->IgnoreArg_connectorId = 0; + cmock_call_instance->Expected_display = display; + cmock_call_instance->IgnoreArg_display = 0; + cmock_call_instance->ReturnThruPtr_display_Used = 0; +} + +void vkGetDrmDisplayEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDrmDisplayEXT_CALL_INSTANCE)); + CMOCK_vkGetDrmDisplayEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDrmDisplayEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDrmDisplayEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetDrmDisplayEXT_CallInstance, cmock_guts_index); + Mock.vkGetDrmDisplayEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetDrmDisplayEXT_IgnoreBool = (char)1; +} + +void vkGetDrmDisplayEXT_CMockStopIgnore(void) +{ + if(Mock.vkGetDrmDisplayEXT_IgnoreBool) + Mock.vkGetDrmDisplayEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetDrmDisplayEXT_CallInstance); + Mock.vkGetDrmDisplayEXT_IgnoreBool = (char)0; +} + +void vkGetDrmDisplayEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDrmDisplayEXT_CALL_INSTANCE)); + CMOCK_vkGetDrmDisplayEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDrmDisplayEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDrmDisplayEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetDrmDisplayEXT_CallInstance, cmock_guts_index); + Mock.vkGetDrmDisplayEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDrmDisplayEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDrmDisplayEXT_CALL_INSTANCE)); + CMOCK_vkGetDrmDisplayEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDrmDisplayEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDrmDisplayEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetDrmDisplayEXT_CallInstance, cmock_guts_index); + Mock.vkGetDrmDisplayEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDrmDisplayEXT(cmock_call_instance, physicalDevice, drmFd, connectorId, display); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetDrmDisplayEXT_AddCallback(CMOCK_vkGetDrmDisplayEXT_CALLBACK Callback) +{ + Mock.vkGetDrmDisplayEXT_IgnoreBool = (char)0; + Mock.vkGetDrmDisplayEXT_CallbackBool = (char)1; + Mock.vkGetDrmDisplayEXT_CallbackFunctionPointer = Callback; +} + +void vkGetDrmDisplayEXT_Stub(CMOCK_vkGetDrmDisplayEXT_CALLBACK Callback) +{ + Mock.vkGetDrmDisplayEXT_IgnoreBool = (char)0; + Mock.vkGetDrmDisplayEXT_CallbackBool = (char)0; + Mock.vkGetDrmDisplayEXT_CallbackFunctionPointer = Callback; +} + +void vkGetDrmDisplayEXT_CMockReturnMemThruPtr_display(UNITY_LINE_TYPE cmock_line, VkDisplayKHR const* display, size_t cmock_size) +{ + CMOCK_vkGetDrmDisplayEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDrmDisplayEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDrmDisplayEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_display_Used = 1; + cmock_call_instance->ReturnThruPtr_display_Val = display; + cmock_call_instance->ReturnThruPtr_display_Size = cmock_size; +} + +void vkGetDrmDisplayEXT_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDrmDisplayEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDrmDisplayEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDrmDisplayEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetDrmDisplayEXT_CMockIgnoreArg_drmFd(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDrmDisplayEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDrmDisplayEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDrmDisplayEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_drmFd = 1; +} + +void vkGetDrmDisplayEXT_CMockIgnoreArg_connectorId(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDrmDisplayEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDrmDisplayEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDrmDisplayEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_connectorId = 1; +} + +void vkGetDrmDisplayEXT_CMockIgnoreArg_display(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDrmDisplayEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDrmDisplayEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDrmDisplayEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_display = 1; +} + +VkResult vkCreatePrivateDataSlotEXT(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreatePrivateDataSlotEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreatePrivateDataSlotEXT); + cmock_call_instance = (CMOCK_vkCreatePrivateDataSlotEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreatePrivateDataSlotEXT_CallInstance); + Mock.vkCreatePrivateDataSlotEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCreatePrivateDataSlotEXT_CallInstance); + if (Mock.vkCreatePrivateDataSlotEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreatePrivateDataSlotEXT_FinalReturn; + memcpy((void*)(&Mock.vkCreatePrivateDataSlotEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreatePrivateDataSlotEXT_CallbackBool && + Mock.vkCreatePrivateDataSlotEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreatePrivateDataSlotEXT_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pPrivateDataSlot, Mock.vkCreatePrivateDataSlotEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreatePrivateDataSlotEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreatePrivateDataSlotEXT,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkPrivateDataSlotCreateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreatePrivateDataSlotEXT,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPrivateDataSlot) + { + UNITY_SET_DETAILS(CMockString_vkCreatePrivateDataSlotEXT,CMockString_pPrivateDataSlot); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pPrivateDataSlot), (void*)(pPrivateDataSlot), sizeof(VkPrivateDataSlot), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreatePrivateDataSlotEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreatePrivateDataSlotEXT_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pPrivateDataSlot, Mock.vkCreatePrivateDataSlotEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPrivateDataSlot_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPrivateDataSlot, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPrivateDataSlot, (const void*)cmock_call_instance->ReturnThruPtr_pPrivateDataSlot_Val, + cmock_call_instance->ReturnThruPtr_pPrivateDataSlot_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreatePrivateDataSlotEXT(CMOCK_vkCreatePrivateDataSlotEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot); +void CMockExpectParameters_vkCreatePrivateDataSlotEXT(CMOCK_vkCreatePrivateDataSlotEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pPrivateDataSlot = pPrivateDataSlot; + cmock_call_instance->IgnoreArg_pPrivateDataSlot = 0; + cmock_call_instance->ReturnThruPtr_pPrivateDataSlot_Used = 0; +} + +void vkCreatePrivateDataSlotEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreatePrivateDataSlotEXT_CALL_INSTANCE)); + CMOCK_vkCreatePrivateDataSlotEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePrivateDataSlotEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreatePrivateDataSlotEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCreatePrivateDataSlotEXT_CallInstance, cmock_guts_index); + Mock.vkCreatePrivateDataSlotEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreatePrivateDataSlotEXT_IgnoreBool = (char)1; +} + +void vkCreatePrivateDataSlotEXT_CMockStopIgnore(void) +{ + if(Mock.vkCreatePrivateDataSlotEXT_IgnoreBool) + Mock.vkCreatePrivateDataSlotEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCreatePrivateDataSlotEXT_CallInstance); + Mock.vkCreatePrivateDataSlotEXT_IgnoreBool = (char)0; +} + +void vkCreatePrivateDataSlotEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreatePrivateDataSlotEXT_CALL_INSTANCE)); + CMOCK_vkCreatePrivateDataSlotEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePrivateDataSlotEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreatePrivateDataSlotEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCreatePrivateDataSlotEXT_CallInstance, cmock_guts_index); + Mock.vkCreatePrivateDataSlotEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreatePrivateDataSlotEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreatePrivateDataSlotEXT_CALL_INSTANCE)); + CMOCK_vkCreatePrivateDataSlotEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePrivateDataSlotEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreatePrivateDataSlotEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCreatePrivateDataSlotEXT_CallInstance, cmock_guts_index); + Mock.vkCreatePrivateDataSlotEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreatePrivateDataSlotEXT(cmock_call_instance, device, pCreateInfo, pAllocator, pPrivateDataSlot); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreatePrivateDataSlotEXT_AddCallback(CMOCK_vkCreatePrivateDataSlotEXT_CALLBACK Callback) +{ + Mock.vkCreatePrivateDataSlotEXT_IgnoreBool = (char)0; + Mock.vkCreatePrivateDataSlotEXT_CallbackBool = (char)1; + Mock.vkCreatePrivateDataSlotEXT_CallbackFunctionPointer = Callback; +} + +void vkCreatePrivateDataSlotEXT_Stub(CMOCK_vkCreatePrivateDataSlotEXT_CALLBACK Callback) +{ + Mock.vkCreatePrivateDataSlotEXT_IgnoreBool = (char)0; + Mock.vkCreatePrivateDataSlotEXT_CallbackBool = (char)0; + Mock.vkCreatePrivateDataSlotEXT_CallbackFunctionPointer = Callback; +} + +void vkCreatePrivateDataSlotEXT_CMockReturnMemThruPtr_pPrivateDataSlot(UNITY_LINE_TYPE cmock_line, VkPrivateDataSlot const* pPrivateDataSlot, size_t cmock_size) +{ + CMOCK_vkCreatePrivateDataSlotEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePrivateDataSlotEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreatePrivateDataSlotEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPrivateDataSlot_Used = 1; + cmock_call_instance->ReturnThruPtr_pPrivateDataSlot_Val = pPrivateDataSlot; + cmock_call_instance->ReturnThruPtr_pPrivateDataSlot_Size = cmock_size; +} + +void vkCreatePrivateDataSlotEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreatePrivateDataSlotEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePrivateDataSlotEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreatePrivateDataSlotEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreatePrivateDataSlotEXT_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreatePrivateDataSlotEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePrivateDataSlotEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreatePrivateDataSlotEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreatePrivateDataSlotEXT_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreatePrivateDataSlotEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePrivateDataSlotEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreatePrivateDataSlotEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreatePrivateDataSlotEXT_CMockIgnoreArg_pPrivateDataSlot(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreatePrivateDataSlotEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreatePrivateDataSlotEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreatePrivateDataSlotEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPrivateDataSlot = 1; +} + +void vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyPrivateDataSlotEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyPrivateDataSlotEXT); + cmock_call_instance = (CMOCK_vkDestroyPrivateDataSlotEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyPrivateDataSlotEXT_CallInstance); + Mock.vkDestroyPrivateDataSlotEXT_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyPrivateDataSlotEXT_CallInstance); + if (Mock.vkDestroyPrivateDataSlotEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyPrivateDataSlotEXT_CallbackBool && + Mock.vkDestroyPrivateDataSlotEXT_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyPrivateDataSlotEXT_CallbackFunctionPointer(device, privateDataSlot, pAllocator, Mock.vkDestroyPrivateDataSlotEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyPrivateDataSlotEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_privateDataSlot) + { + UNITY_SET_DETAILS(CMockString_vkDestroyPrivateDataSlotEXT,CMockString_privateDataSlot); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_privateDataSlot), (void*)(&privateDataSlot), sizeof(VkPrivateDataSlot), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyPrivateDataSlotEXT,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyPrivateDataSlotEXT_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyPrivateDataSlotEXT_CallbackFunctionPointer(device, privateDataSlot, pAllocator, Mock.vkDestroyPrivateDataSlotEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyPrivateDataSlotEXT(CMOCK_vkDestroyPrivateDataSlotEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyPrivateDataSlotEXT(CMOCK_vkDestroyPrivateDataSlotEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_privateDataSlot), (void*)(&privateDataSlot), + sizeof(VkPrivateDataSlot[sizeof(privateDataSlot) == sizeof(VkPrivateDataSlot) ? 1 : -1])); /* add VkPrivateDataSlot to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_privateDataSlot = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyPrivateDataSlotEXT_CMockIgnore(void) +{ + Mock.vkDestroyPrivateDataSlotEXT_IgnoreBool = (char)1; +} + +void vkDestroyPrivateDataSlotEXT_CMockStopIgnore(void) +{ + Mock.vkDestroyPrivateDataSlotEXT_IgnoreBool = (char)0; +} + +void vkDestroyPrivateDataSlotEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyPrivateDataSlotEXT_CALL_INSTANCE)); + CMOCK_vkDestroyPrivateDataSlotEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyPrivateDataSlotEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyPrivateDataSlotEXT_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyPrivateDataSlotEXT_CallInstance, cmock_guts_index); + Mock.vkDestroyPrivateDataSlotEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyPrivateDataSlotEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyPrivateDataSlotEXT_CALL_INSTANCE)); + CMOCK_vkDestroyPrivateDataSlotEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyPrivateDataSlotEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyPrivateDataSlotEXT_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyPrivateDataSlotEXT_CallInstance, cmock_guts_index); + Mock.vkDestroyPrivateDataSlotEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyPrivateDataSlotEXT(cmock_call_instance, device, privateDataSlot, pAllocator); +} + +void vkDestroyPrivateDataSlotEXT_AddCallback(CMOCK_vkDestroyPrivateDataSlotEXT_CALLBACK Callback) +{ + Mock.vkDestroyPrivateDataSlotEXT_IgnoreBool = (char)0; + Mock.vkDestroyPrivateDataSlotEXT_CallbackBool = (char)1; + Mock.vkDestroyPrivateDataSlotEXT_CallbackFunctionPointer = Callback; +} + +void vkDestroyPrivateDataSlotEXT_Stub(CMOCK_vkDestroyPrivateDataSlotEXT_CALLBACK Callback) +{ + Mock.vkDestroyPrivateDataSlotEXT_IgnoreBool = (char)0; + Mock.vkDestroyPrivateDataSlotEXT_CallbackBool = (char)0; + Mock.vkDestroyPrivateDataSlotEXT_CallbackFunctionPointer = Callback; +} + +void vkDestroyPrivateDataSlotEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyPrivateDataSlotEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyPrivateDataSlotEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyPrivateDataSlotEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyPrivateDataSlotEXT_CMockIgnoreArg_privateDataSlot(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyPrivateDataSlotEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyPrivateDataSlotEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyPrivateDataSlotEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_privateDataSlot = 1; +} + +void vkDestroyPrivateDataSlotEXT_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyPrivateDataSlotEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyPrivateDataSlotEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyPrivateDataSlotEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +VkResult vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkSetPrivateDataEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkSetPrivateDataEXT); + cmock_call_instance = (CMOCK_vkSetPrivateDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkSetPrivateDataEXT_CallInstance); + Mock.vkSetPrivateDataEXT_CallInstance = CMock_Guts_MemNext(Mock.vkSetPrivateDataEXT_CallInstance); + if (Mock.vkSetPrivateDataEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkSetPrivateDataEXT_FinalReturn; + memcpy((void*)(&Mock.vkSetPrivateDataEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkSetPrivateDataEXT_CallbackBool && + Mock.vkSetPrivateDataEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkSetPrivateDataEXT_CallbackFunctionPointer(device, objectType, objectHandle, privateDataSlot, data, Mock.vkSetPrivateDataEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkSetPrivateDataEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_objectType) + { + UNITY_SET_DETAILS(CMockString_vkSetPrivateDataEXT,CMockString_objectType); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_objectType), (void*)(&objectType), sizeof(VkObjectType), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_objectHandle) + { + UNITY_SET_DETAILS(CMockString_vkSetPrivateDataEXT,CMockString_objectHandle); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_objectHandle), (void*)(&objectHandle), sizeof(uint64_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_privateDataSlot) + { + UNITY_SET_DETAILS(CMockString_vkSetPrivateDataEXT,CMockString_privateDataSlot); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_privateDataSlot), (void*)(&privateDataSlot), sizeof(VkPrivateDataSlot), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_data) + { + UNITY_SET_DETAILS(CMockString_vkSetPrivateDataEXT,CMockString_data); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_data), (void*)(&data), sizeof(uint64_t), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkSetPrivateDataEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkSetPrivateDataEXT_CallbackFunctionPointer(device, objectType, objectHandle, privateDataSlot, data, Mock.vkSetPrivateDataEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkSetPrivateDataEXT(CMOCK_vkSetPrivateDataEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data); +void CMockExpectParameters_vkSetPrivateDataEXT(CMOCK_vkSetPrivateDataEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_objectType), (void*)(&objectType), + sizeof(VkObjectType[sizeof(objectType) == sizeof(VkObjectType) ? 1 : -1])); /* add VkObjectType to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_objectType = 0; + memcpy((void*)(&cmock_call_instance->Expected_objectHandle), (void*)(&objectHandle), + sizeof(uint64_t[sizeof(objectHandle) == sizeof(uint64_t) ? 1 : -1])); /* add uint64_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_objectHandle = 0; + memcpy((void*)(&cmock_call_instance->Expected_privateDataSlot), (void*)(&privateDataSlot), + sizeof(VkPrivateDataSlot[sizeof(privateDataSlot) == sizeof(VkPrivateDataSlot) ? 1 : -1])); /* add VkPrivateDataSlot to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_privateDataSlot = 0; + memcpy((void*)(&cmock_call_instance->Expected_data), (void*)(&data), + sizeof(uint64_t[sizeof(data) == sizeof(uint64_t) ? 1 : -1])); /* add uint64_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_data = 0; +} + +void vkSetPrivateDataEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkSetPrivateDataEXT_CALL_INSTANCE)); + CMOCK_vkSetPrivateDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetPrivateDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkSetPrivateDataEXT_CallInstance = CMock_Guts_MemChain(Mock.vkSetPrivateDataEXT_CallInstance, cmock_guts_index); + Mock.vkSetPrivateDataEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkSetPrivateDataEXT_IgnoreBool = (char)1; +} + +void vkSetPrivateDataEXT_CMockStopIgnore(void) +{ + if(Mock.vkSetPrivateDataEXT_IgnoreBool) + Mock.vkSetPrivateDataEXT_CallInstance = CMock_Guts_MemNext(Mock.vkSetPrivateDataEXT_CallInstance); + Mock.vkSetPrivateDataEXT_IgnoreBool = (char)0; +} + +void vkSetPrivateDataEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkSetPrivateDataEXT_CALL_INSTANCE)); + CMOCK_vkSetPrivateDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetPrivateDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkSetPrivateDataEXT_CallInstance = CMock_Guts_MemChain(Mock.vkSetPrivateDataEXT_CallInstance, cmock_guts_index); + Mock.vkSetPrivateDataEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkSetPrivateDataEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkSetPrivateDataEXT_CALL_INSTANCE)); + CMOCK_vkSetPrivateDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetPrivateDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkSetPrivateDataEXT_CallInstance = CMock_Guts_MemChain(Mock.vkSetPrivateDataEXT_CallInstance, cmock_guts_index); + Mock.vkSetPrivateDataEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkSetPrivateDataEXT(cmock_call_instance, device, objectType, objectHandle, privateDataSlot, data); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkSetPrivateDataEXT_AddCallback(CMOCK_vkSetPrivateDataEXT_CALLBACK Callback) +{ + Mock.vkSetPrivateDataEXT_IgnoreBool = (char)0; + Mock.vkSetPrivateDataEXT_CallbackBool = (char)1; + Mock.vkSetPrivateDataEXT_CallbackFunctionPointer = Callback; +} + +void vkSetPrivateDataEXT_Stub(CMOCK_vkSetPrivateDataEXT_CALLBACK Callback) +{ + Mock.vkSetPrivateDataEXT_IgnoreBool = (char)0; + Mock.vkSetPrivateDataEXT_CallbackBool = (char)0; + Mock.vkSetPrivateDataEXT_CallbackFunctionPointer = Callback; +} + +void vkSetPrivateDataEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSetPrivateDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetPrivateDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSetPrivateDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkSetPrivateDataEXT_CMockIgnoreArg_objectType(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSetPrivateDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetPrivateDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSetPrivateDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_objectType = 1; +} + +void vkSetPrivateDataEXT_CMockIgnoreArg_objectHandle(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSetPrivateDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetPrivateDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSetPrivateDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_objectHandle = 1; +} + +void vkSetPrivateDataEXT_CMockIgnoreArg_privateDataSlot(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSetPrivateDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetPrivateDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSetPrivateDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_privateDataSlot = 1; +} + +void vkSetPrivateDataEXT_CMockIgnoreArg_data(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSetPrivateDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetPrivateDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSetPrivateDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_data = 1; +} + +void vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPrivateDataEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPrivateDataEXT); + cmock_call_instance = (CMOCK_vkGetPrivateDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPrivateDataEXT_CallInstance); + Mock.vkGetPrivateDataEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetPrivateDataEXT_CallInstance); + if (Mock.vkGetPrivateDataEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetPrivateDataEXT_CallbackBool && + Mock.vkGetPrivateDataEXT_CallbackFunctionPointer != NULL) + { + Mock.vkGetPrivateDataEXT_CallbackFunctionPointer(device, objectType, objectHandle, privateDataSlot, pData, Mock.vkGetPrivateDataEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetPrivateDataEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_objectType) + { + UNITY_SET_DETAILS(CMockString_vkGetPrivateDataEXT,CMockString_objectType); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_objectType), (void*)(&objectType), sizeof(VkObjectType), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_objectHandle) + { + UNITY_SET_DETAILS(CMockString_vkGetPrivateDataEXT,CMockString_objectHandle); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_objectHandle), (void*)(&objectHandle), sizeof(uint64_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_privateDataSlot) + { + UNITY_SET_DETAILS(CMockString_vkGetPrivateDataEXT,CMockString_privateDataSlot); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_privateDataSlot), (void*)(&privateDataSlot), sizeof(VkPrivateDataSlot), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pData) + { + UNITY_SET_DETAILS(CMockString_vkGetPrivateDataEXT,CMockString_pData); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pData), (void*)(pData), sizeof(uint64_t), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPrivateDataEXT_CallbackFunctionPointer != NULL) + { + Mock.vkGetPrivateDataEXT_CallbackFunctionPointer(device, objectType, objectHandle, privateDataSlot, pData, Mock.vkGetPrivateDataEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pData_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pData, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pData, (const void*)cmock_call_instance->ReturnThruPtr_pData_Val, + cmock_call_instance->ReturnThruPtr_pData_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetPrivateDataEXT(CMOCK_vkGetPrivateDataEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData); +void CMockExpectParameters_vkGetPrivateDataEXT(CMOCK_vkGetPrivateDataEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_objectType), (void*)(&objectType), + sizeof(VkObjectType[sizeof(objectType) == sizeof(VkObjectType) ? 1 : -1])); /* add VkObjectType to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_objectType = 0; + memcpy((void*)(&cmock_call_instance->Expected_objectHandle), (void*)(&objectHandle), + sizeof(uint64_t[sizeof(objectHandle) == sizeof(uint64_t) ? 1 : -1])); /* add uint64_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_objectHandle = 0; + memcpy((void*)(&cmock_call_instance->Expected_privateDataSlot), (void*)(&privateDataSlot), + sizeof(VkPrivateDataSlot[sizeof(privateDataSlot) == sizeof(VkPrivateDataSlot) ? 1 : -1])); /* add VkPrivateDataSlot to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_privateDataSlot = 0; + cmock_call_instance->Expected_pData = pData; + cmock_call_instance->IgnoreArg_pData = 0; + cmock_call_instance->ReturnThruPtr_pData_Used = 0; +} + +void vkGetPrivateDataEXT_CMockIgnore(void) +{ + Mock.vkGetPrivateDataEXT_IgnoreBool = (char)1; +} + +void vkGetPrivateDataEXT_CMockStopIgnore(void) +{ + Mock.vkGetPrivateDataEXT_IgnoreBool = (char)0; +} + +void vkGetPrivateDataEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPrivateDataEXT_CALL_INSTANCE)); + CMOCK_vkGetPrivateDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPrivateDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPrivateDataEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetPrivateDataEXT_CallInstance, cmock_guts_index); + Mock.vkGetPrivateDataEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPrivateDataEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPrivateDataEXT_CALL_INSTANCE)); + CMOCK_vkGetPrivateDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPrivateDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPrivateDataEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetPrivateDataEXT_CallInstance, cmock_guts_index); + Mock.vkGetPrivateDataEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPrivateDataEXT(cmock_call_instance, device, objectType, objectHandle, privateDataSlot, pData); +} + +void vkGetPrivateDataEXT_AddCallback(CMOCK_vkGetPrivateDataEXT_CALLBACK Callback) +{ + Mock.vkGetPrivateDataEXT_IgnoreBool = (char)0; + Mock.vkGetPrivateDataEXT_CallbackBool = (char)1; + Mock.vkGetPrivateDataEXT_CallbackFunctionPointer = Callback; +} + +void vkGetPrivateDataEXT_Stub(CMOCK_vkGetPrivateDataEXT_CALLBACK Callback) +{ + Mock.vkGetPrivateDataEXT_IgnoreBool = (char)0; + Mock.vkGetPrivateDataEXT_CallbackBool = (char)0; + Mock.vkGetPrivateDataEXT_CallbackFunctionPointer = Callback; +} + +void vkGetPrivateDataEXT_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, uint64_t const* pData, size_t cmock_size) +{ + CMOCK_vkGetPrivateDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPrivateDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPrivateDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pData_Used = 1; + cmock_call_instance->ReturnThruPtr_pData_Val = pData; + cmock_call_instance->ReturnThruPtr_pData_Size = cmock_size; +} + +void vkGetPrivateDataEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPrivateDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPrivateDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPrivateDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetPrivateDataEXT_CMockIgnoreArg_objectType(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPrivateDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPrivateDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPrivateDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_objectType = 1; +} + +void vkGetPrivateDataEXT_CMockIgnoreArg_objectHandle(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPrivateDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPrivateDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPrivateDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_objectHandle = 1; +} + +void vkGetPrivateDataEXT_CMockIgnoreArg_privateDataSlot(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPrivateDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPrivateDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPrivateDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_privateDataSlot = 1; +} + +void vkGetPrivateDataEXT_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPrivateDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPrivateDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPrivateDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pData = 1; +} + +void vkGetDescriptorSetLayoutSizeEXT(VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize* pLayoutSizeInBytes) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDescriptorSetLayoutSizeEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDescriptorSetLayoutSizeEXT); + cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutSizeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDescriptorSetLayoutSizeEXT_CallInstance); + Mock.vkGetDescriptorSetLayoutSizeEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetDescriptorSetLayoutSizeEXT_CallInstance); + if (Mock.vkGetDescriptorSetLayoutSizeEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetDescriptorSetLayoutSizeEXT_CallbackBool && + Mock.vkGetDescriptorSetLayoutSizeEXT_CallbackFunctionPointer != NULL) + { + Mock.vkGetDescriptorSetLayoutSizeEXT_CallbackFunctionPointer(device, layout, pLayoutSizeInBytes, Mock.vkGetDescriptorSetLayoutSizeEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetDescriptorSetLayoutSizeEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_layout) + { + UNITY_SET_DETAILS(CMockString_vkGetDescriptorSetLayoutSizeEXT,CMockString_layout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_layout), (void*)(&layout), sizeof(VkDescriptorSetLayout), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pLayoutSizeInBytes) + { + UNITY_SET_DETAILS(CMockString_vkGetDescriptorSetLayoutSizeEXT,CMockString_pLayoutSizeInBytes); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pLayoutSizeInBytes), (void*)(pLayoutSizeInBytes), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDescriptorSetLayoutSizeEXT_CallbackFunctionPointer != NULL) + { + Mock.vkGetDescriptorSetLayoutSizeEXT_CallbackFunctionPointer(device, layout, pLayoutSizeInBytes, Mock.vkGetDescriptorSetLayoutSizeEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pLayoutSizeInBytes_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pLayoutSizeInBytes, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pLayoutSizeInBytes, (const void*)cmock_call_instance->ReturnThruPtr_pLayoutSizeInBytes_Val, + cmock_call_instance->ReturnThruPtr_pLayoutSizeInBytes_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetDescriptorSetLayoutSizeEXT(CMOCK_vkGetDescriptorSetLayoutSizeEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize* pLayoutSizeInBytes); +void CMockExpectParameters_vkGetDescriptorSetLayoutSizeEXT(CMOCK_vkGetDescriptorSetLayoutSizeEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize* pLayoutSizeInBytes) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_layout), (void*)(&layout), + sizeof(VkDescriptorSetLayout[sizeof(layout) == sizeof(VkDescriptorSetLayout) ? 1 : -1])); /* add VkDescriptorSetLayout to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_layout = 0; + cmock_call_instance->Expected_pLayoutSizeInBytes = pLayoutSizeInBytes; + cmock_call_instance->IgnoreArg_pLayoutSizeInBytes = 0; + cmock_call_instance->ReturnThruPtr_pLayoutSizeInBytes_Used = 0; +} + +void vkGetDescriptorSetLayoutSizeEXT_CMockIgnore(void) +{ + Mock.vkGetDescriptorSetLayoutSizeEXT_IgnoreBool = (char)1; +} + +void vkGetDescriptorSetLayoutSizeEXT_CMockStopIgnore(void) +{ + Mock.vkGetDescriptorSetLayoutSizeEXT_IgnoreBool = (char)0; +} + +void vkGetDescriptorSetLayoutSizeEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDescriptorSetLayoutSizeEXT_CALL_INSTANCE)); + CMOCK_vkGetDescriptorSetLayoutSizeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutSizeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDescriptorSetLayoutSizeEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetDescriptorSetLayoutSizeEXT_CallInstance, cmock_guts_index); + Mock.vkGetDescriptorSetLayoutSizeEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDescriptorSetLayoutSizeEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize* pLayoutSizeInBytes) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDescriptorSetLayoutSizeEXT_CALL_INSTANCE)); + CMOCK_vkGetDescriptorSetLayoutSizeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutSizeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDescriptorSetLayoutSizeEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetDescriptorSetLayoutSizeEXT_CallInstance, cmock_guts_index); + Mock.vkGetDescriptorSetLayoutSizeEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDescriptorSetLayoutSizeEXT(cmock_call_instance, device, layout, pLayoutSizeInBytes); +} + +void vkGetDescriptorSetLayoutSizeEXT_AddCallback(CMOCK_vkGetDescriptorSetLayoutSizeEXT_CALLBACK Callback) +{ + Mock.vkGetDescriptorSetLayoutSizeEXT_IgnoreBool = (char)0; + Mock.vkGetDescriptorSetLayoutSizeEXT_CallbackBool = (char)1; + Mock.vkGetDescriptorSetLayoutSizeEXT_CallbackFunctionPointer = Callback; +} + +void vkGetDescriptorSetLayoutSizeEXT_Stub(CMOCK_vkGetDescriptorSetLayoutSizeEXT_CALLBACK Callback) +{ + Mock.vkGetDescriptorSetLayoutSizeEXT_IgnoreBool = (char)0; + Mock.vkGetDescriptorSetLayoutSizeEXT_CallbackBool = (char)0; + Mock.vkGetDescriptorSetLayoutSizeEXT_CallbackFunctionPointer = Callback; +} + +void vkGetDescriptorSetLayoutSizeEXT_CMockReturnMemThruPtr_pLayoutSizeInBytes(UNITY_LINE_TYPE cmock_line, VkDeviceSize const* pLayoutSizeInBytes, size_t cmock_size) +{ + CMOCK_vkGetDescriptorSetLayoutSizeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutSizeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDescriptorSetLayoutSizeEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pLayoutSizeInBytes_Used = 1; + cmock_call_instance->ReturnThruPtr_pLayoutSizeInBytes_Val = pLayoutSizeInBytes; + cmock_call_instance->ReturnThruPtr_pLayoutSizeInBytes_Size = cmock_size; +} + +void vkGetDescriptorSetLayoutSizeEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDescriptorSetLayoutSizeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutSizeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDescriptorSetLayoutSizeEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetDescriptorSetLayoutSizeEXT_CMockIgnoreArg_layout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDescriptorSetLayoutSizeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutSizeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDescriptorSetLayoutSizeEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_layout = 1; +} + +void vkGetDescriptorSetLayoutSizeEXT_CMockIgnoreArg_pLayoutSizeInBytes(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDescriptorSetLayoutSizeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutSizeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDescriptorSetLayoutSizeEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pLayoutSizeInBytes = 1; +} + +void vkGetDescriptorSetLayoutBindingOffsetEXT(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize* pOffset) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDescriptorSetLayoutBindingOffsetEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDescriptorSetLayoutBindingOffsetEXT); + cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutBindingOffsetEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_CallInstance); + Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_CallInstance); + if (Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_CallbackBool && + Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_CallbackFunctionPointer != NULL) + { + Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_CallbackFunctionPointer(device, layout, binding, pOffset, Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetDescriptorSetLayoutBindingOffsetEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_layout) + { + UNITY_SET_DETAILS(CMockString_vkGetDescriptorSetLayoutBindingOffsetEXT,CMockString_layout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_layout), (void*)(&layout), sizeof(VkDescriptorSetLayout), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_binding) + { + UNITY_SET_DETAILS(CMockString_vkGetDescriptorSetLayoutBindingOffsetEXT,CMockString_binding); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_binding, binding, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pOffset) + { + UNITY_SET_DETAILS(CMockString_vkGetDescriptorSetLayoutBindingOffsetEXT,CMockString_pOffset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pOffset), (void*)(pOffset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_CallbackFunctionPointer != NULL) + { + Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_CallbackFunctionPointer(device, layout, binding, pOffset, Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pOffset_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pOffset, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pOffset, (const void*)cmock_call_instance->ReturnThruPtr_pOffset_Val, + cmock_call_instance->ReturnThruPtr_pOffset_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetDescriptorSetLayoutBindingOffsetEXT(CMOCK_vkGetDescriptorSetLayoutBindingOffsetEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize* pOffset); +void CMockExpectParameters_vkGetDescriptorSetLayoutBindingOffsetEXT(CMOCK_vkGetDescriptorSetLayoutBindingOffsetEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize* pOffset) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_layout), (void*)(&layout), + sizeof(VkDescriptorSetLayout[sizeof(layout) == sizeof(VkDescriptorSetLayout) ? 1 : -1])); /* add VkDescriptorSetLayout to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_layout = 0; + cmock_call_instance->Expected_binding = binding; + cmock_call_instance->IgnoreArg_binding = 0; + cmock_call_instance->Expected_pOffset = pOffset; + cmock_call_instance->IgnoreArg_pOffset = 0; + cmock_call_instance->ReturnThruPtr_pOffset_Used = 0; +} + +void vkGetDescriptorSetLayoutBindingOffsetEXT_CMockIgnore(void) +{ + Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_IgnoreBool = (char)1; +} + +void vkGetDescriptorSetLayoutBindingOffsetEXT_CMockStopIgnore(void) +{ + Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_IgnoreBool = (char)0; +} + +void vkGetDescriptorSetLayoutBindingOffsetEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDescriptorSetLayoutBindingOffsetEXT_CALL_INSTANCE)); + CMOCK_vkGetDescriptorSetLayoutBindingOffsetEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutBindingOffsetEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_CallInstance, cmock_guts_index); + Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDescriptorSetLayoutBindingOffsetEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize* pOffset) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDescriptorSetLayoutBindingOffsetEXT_CALL_INSTANCE)); + CMOCK_vkGetDescriptorSetLayoutBindingOffsetEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutBindingOffsetEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_CallInstance, cmock_guts_index); + Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDescriptorSetLayoutBindingOffsetEXT(cmock_call_instance, device, layout, binding, pOffset); +} + +void vkGetDescriptorSetLayoutBindingOffsetEXT_AddCallback(CMOCK_vkGetDescriptorSetLayoutBindingOffsetEXT_CALLBACK Callback) +{ + Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_IgnoreBool = (char)0; + Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_CallbackBool = (char)1; + Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_CallbackFunctionPointer = Callback; +} + +void vkGetDescriptorSetLayoutBindingOffsetEXT_Stub(CMOCK_vkGetDescriptorSetLayoutBindingOffsetEXT_CALLBACK Callback) +{ + Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_IgnoreBool = (char)0; + Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_CallbackBool = (char)0; + Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_CallbackFunctionPointer = Callback; +} + +void vkGetDescriptorSetLayoutBindingOffsetEXT_CMockReturnMemThruPtr_pOffset(UNITY_LINE_TYPE cmock_line, VkDeviceSize const* pOffset, size_t cmock_size) +{ + CMOCK_vkGetDescriptorSetLayoutBindingOffsetEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutBindingOffsetEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pOffset_Used = 1; + cmock_call_instance->ReturnThruPtr_pOffset_Val = pOffset; + cmock_call_instance->ReturnThruPtr_pOffset_Size = cmock_size; +} + +void vkGetDescriptorSetLayoutBindingOffsetEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDescriptorSetLayoutBindingOffsetEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutBindingOffsetEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetDescriptorSetLayoutBindingOffsetEXT_CMockIgnoreArg_layout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDescriptorSetLayoutBindingOffsetEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutBindingOffsetEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_layout = 1; +} + +void vkGetDescriptorSetLayoutBindingOffsetEXT_CMockIgnoreArg_binding(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDescriptorSetLayoutBindingOffsetEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutBindingOffsetEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_binding = 1; +} + +void vkGetDescriptorSetLayoutBindingOffsetEXT_CMockIgnoreArg_pOffset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDescriptorSetLayoutBindingOffsetEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutBindingOffsetEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDescriptorSetLayoutBindingOffsetEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pOffset = 1; +} + +void vkGetDescriptorEXT(VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, void* pDescriptor) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDescriptorEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDescriptorEXT); + cmock_call_instance = (CMOCK_vkGetDescriptorEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDescriptorEXT_CallInstance); + Mock.vkGetDescriptorEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetDescriptorEXT_CallInstance); + if (Mock.vkGetDescriptorEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetDescriptorEXT_CallbackBool && + Mock.vkGetDescriptorEXT_CallbackFunctionPointer != NULL) + { + Mock.vkGetDescriptorEXT_CallbackFunctionPointer(device, pDescriptorInfo, dataSize, pDescriptor, Mock.vkGetDescriptorEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetDescriptorEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDescriptorInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetDescriptorEXT,CMockString_pDescriptorInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDescriptorInfo), (void*)(pDescriptorInfo), sizeof(const VkDescriptorGetInfoEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dataSize) + { + UNITY_SET_DETAILS(CMockString_vkGetDescriptorEXT,CMockString_dataSize); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dataSize), (void*)(&dataSize), sizeof(size_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDescriptor) + { + UNITY_SET_DETAILS(CMockString_vkGetDescriptorEXT,CMockString_pDescriptor); + if (cmock_call_instance->Expected_pDescriptor == NULL) + { UNITY_TEST_ASSERT_NULL(pDescriptor, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(cmock_call_instance->Expected_pDescriptor, pDescriptor, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkGetDescriptorEXT_CallbackFunctionPointer != NULL) + { + Mock.vkGetDescriptorEXT_CallbackFunctionPointer(device, pDescriptorInfo, dataSize, pDescriptor, Mock.vkGetDescriptorEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pDescriptor_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pDescriptor, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pDescriptor, (const void*)cmock_call_instance->ReturnThruPtr_pDescriptor_Val, + cmock_call_instance->ReturnThruPtr_pDescriptor_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetDescriptorEXT(CMOCK_vkGetDescriptorEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, void* pDescriptor); +void CMockExpectParameters_vkGetDescriptorEXT(CMOCK_vkGetDescriptorEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, void* pDescriptor) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pDescriptorInfo = pDescriptorInfo; + cmock_call_instance->IgnoreArg_pDescriptorInfo = 0; + memcpy((void*)(&cmock_call_instance->Expected_dataSize), (void*)(&dataSize), + sizeof(size_t[sizeof(dataSize) == sizeof(size_t) ? 1 : -1])); /* add size_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dataSize = 0; + cmock_call_instance->Expected_pDescriptor = pDescriptor; + cmock_call_instance->IgnoreArg_pDescriptor = 0; + cmock_call_instance->ReturnThruPtr_pDescriptor_Used = 0; +} + +void vkGetDescriptorEXT_CMockIgnore(void) +{ + Mock.vkGetDescriptorEXT_IgnoreBool = (char)1; +} + +void vkGetDescriptorEXT_CMockStopIgnore(void) +{ + Mock.vkGetDescriptorEXT_IgnoreBool = (char)0; +} + +void vkGetDescriptorEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDescriptorEXT_CALL_INSTANCE)); + CMOCK_vkGetDescriptorEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDescriptorEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetDescriptorEXT_CallInstance, cmock_guts_index); + Mock.vkGetDescriptorEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDescriptorEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, void* pDescriptor) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDescriptorEXT_CALL_INSTANCE)); + CMOCK_vkGetDescriptorEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDescriptorEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetDescriptorEXT_CallInstance, cmock_guts_index); + Mock.vkGetDescriptorEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDescriptorEXT(cmock_call_instance, device, pDescriptorInfo, dataSize, pDescriptor); +} + +void vkGetDescriptorEXT_AddCallback(CMOCK_vkGetDescriptorEXT_CALLBACK Callback) +{ + Mock.vkGetDescriptorEXT_IgnoreBool = (char)0; + Mock.vkGetDescriptorEXT_CallbackBool = (char)1; + Mock.vkGetDescriptorEXT_CallbackFunctionPointer = Callback; +} + +void vkGetDescriptorEXT_Stub(CMOCK_vkGetDescriptorEXT_CALLBACK Callback) +{ + Mock.vkGetDescriptorEXT_IgnoreBool = (char)0; + Mock.vkGetDescriptorEXT_CallbackBool = (char)0; + Mock.vkGetDescriptorEXT_CallbackFunctionPointer = Callback; +} + +void vkGetDescriptorEXT_CMockReturnMemThruPtr_pDescriptor(UNITY_LINE_TYPE cmock_line, void const* pDescriptor, size_t cmock_size) +{ + CMOCK_vkGetDescriptorEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDescriptorEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pDescriptor_Used = 1; + cmock_call_instance->ReturnThruPtr_pDescriptor_Val = pDescriptor; + cmock_call_instance->ReturnThruPtr_pDescriptor_Size = cmock_size; +} + +void vkGetDescriptorEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDescriptorEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDescriptorEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetDescriptorEXT_CMockIgnoreArg_pDescriptorInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDescriptorEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDescriptorEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDescriptorInfo = 1; +} + +void vkGetDescriptorEXT_CMockIgnoreArg_dataSize(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDescriptorEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDescriptorEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dataSize = 1; +} + +void vkGetDescriptorEXT_CMockIgnoreArg_pDescriptor(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDescriptorEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDescriptorEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDescriptor = 1; +} + +void vkCmdBindDescriptorBuffersEXT(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT* pBindingInfos) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBindDescriptorBuffersEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBindDescriptorBuffersEXT); + cmock_call_instance = (CMOCK_vkCmdBindDescriptorBuffersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBindDescriptorBuffersEXT_CallInstance); + Mock.vkCmdBindDescriptorBuffersEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBindDescriptorBuffersEXT_CallInstance); + if (Mock.vkCmdBindDescriptorBuffersEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBindDescriptorBuffersEXT_CallbackBool && + Mock.vkCmdBindDescriptorBuffersEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBindDescriptorBuffersEXT_CallbackFunctionPointer(commandBuffer, bufferCount, pBindingInfos, Mock.vkCmdBindDescriptorBuffersEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindDescriptorBuffersEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_bufferCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindDescriptorBuffersEXT,CMockString_bufferCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_bufferCount, bufferCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pBindingInfos) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindDescriptorBuffersEXT,CMockString_pBindingInfos); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pBindingInfos), (void*)(pBindingInfos), sizeof(const VkDescriptorBufferBindingInfoEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdBindDescriptorBuffersEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBindDescriptorBuffersEXT_CallbackFunctionPointer(commandBuffer, bufferCount, pBindingInfos, Mock.vkCmdBindDescriptorBuffersEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBindDescriptorBuffersEXT(CMOCK_vkCmdBindDescriptorBuffersEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT* pBindingInfos); +void CMockExpectParameters_vkCmdBindDescriptorBuffersEXT(CMOCK_vkCmdBindDescriptorBuffersEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT* pBindingInfos) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_bufferCount = bufferCount; + cmock_call_instance->IgnoreArg_bufferCount = 0; + cmock_call_instance->Expected_pBindingInfos = pBindingInfos; + cmock_call_instance->IgnoreArg_pBindingInfos = 0; +} + +void vkCmdBindDescriptorBuffersEXT_CMockIgnore(void) +{ + Mock.vkCmdBindDescriptorBuffersEXT_IgnoreBool = (char)1; +} + +void vkCmdBindDescriptorBuffersEXT_CMockStopIgnore(void) +{ + Mock.vkCmdBindDescriptorBuffersEXT_IgnoreBool = (char)0; +} + +void vkCmdBindDescriptorBuffersEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBindDescriptorBuffersEXT_CALL_INSTANCE)); + CMOCK_vkCmdBindDescriptorBuffersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindDescriptorBuffersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBindDescriptorBuffersEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBindDescriptorBuffersEXT_CallInstance, cmock_guts_index); + Mock.vkCmdBindDescriptorBuffersEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBindDescriptorBuffersEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT* pBindingInfos) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBindDescriptorBuffersEXT_CALL_INSTANCE)); + CMOCK_vkCmdBindDescriptorBuffersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindDescriptorBuffersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBindDescriptorBuffersEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBindDescriptorBuffersEXT_CallInstance, cmock_guts_index); + Mock.vkCmdBindDescriptorBuffersEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBindDescriptorBuffersEXT(cmock_call_instance, commandBuffer, bufferCount, pBindingInfos); +} + +void vkCmdBindDescriptorBuffersEXT_AddCallback(CMOCK_vkCmdBindDescriptorBuffersEXT_CALLBACK Callback) +{ + Mock.vkCmdBindDescriptorBuffersEXT_IgnoreBool = (char)0; + Mock.vkCmdBindDescriptorBuffersEXT_CallbackBool = (char)1; + Mock.vkCmdBindDescriptorBuffersEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdBindDescriptorBuffersEXT_Stub(CMOCK_vkCmdBindDescriptorBuffersEXT_CALLBACK Callback) +{ + Mock.vkCmdBindDescriptorBuffersEXT_IgnoreBool = (char)0; + Mock.vkCmdBindDescriptorBuffersEXT_CallbackBool = (char)0; + Mock.vkCmdBindDescriptorBuffersEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdBindDescriptorBuffersEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindDescriptorBuffersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindDescriptorBuffersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindDescriptorBuffersEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBindDescriptorBuffersEXT_CMockIgnoreArg_bufferCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindDescriptorBuffersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindDescriptorBuffersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindDescriptorBuffersEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_bufferCount = 1; +} + +void vkCmdBindDescriptorBuffersEXT_CMockIgnoreArg_pBindingInfos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindDescriptorBuffersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindDescriptorBuffersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindDescriptorBuffersEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pBindingInfos = 1; +} + +void vkCmdSetDescriptorBufferOffsetsEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetDescriptorBufferOffsetsEXT); + cmock_call_instance = (CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetDescriptorBufferOffsetsEXT_CallInstance); + Mock.vkCmdSetDescriptorBufferOffsetsEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetDescriptorBufferOffsetsEXT_CallInstance); + if (Mock.vkCmdSetDescriptorBufferOffsetsEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetDescriptorBufferOffsetsEXT_CallbackBool && + Mock.vkCmdSetDescriptorBufferOffsetsEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDescriptorBufferOffsetsEXT_CallbackFunctionPointer(commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets, Mock.vkCmdSetDescriptorBufferOffsetsEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDescriptorBufferOffsetsEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pipelineBindPoint) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDescriptorBufferOffsetsEXT,CMockString_pipelineBindPoint); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_pipelineBindPoint), (void*)(&pipelineBindPoint), sizeof(VkPipelineBindPoint), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_layout) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDescriptorBufferOffsetsEXT,CMockString_layout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_layout), (void*)(&layout), sizeof(VkPipelineLayout), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstSet) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDescriptorBufferOffsetsEXT,CMockString_firstSet); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstSet, firstSet, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_setCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDescriptorBufferOffsetsEXT,CMockString_setCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_setCount, setCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pBufferIndices) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDescriptorBufferOffsetsEXT,CMockString_pBufferIndices); + if (cmock_call_instance->Expected_pBufferIndices == NULL) + { UNITY_TEST_ASSERT_NULL(pBufferIndices, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pBufferIndices, pBufferIndices, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pOffsets) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDescriptorBufferOffsetsEXT,CMockString_pOffsets); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pOffsets), (void*)(pOffsets), sizeof(const VkDeviceSize), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetDescriptorBufferOffsetsEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDescriptorBufferOffsetsEXT_CallbackFunctionPointer(commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets, Mock.vkCmdSetDescriptorBufferOffsetsEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetDescriptorBufferOffsetsEXT(CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets); +void CMockExpectParameters_vkCmdSetDescriptorBufferOffsetsEXT(CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_pipelineBindPoint), (void*)(&pipelineBindPoint), + sizeof(VkPipelineBindPoint[sizeof(pipelineBindPoint) == sizeof(VkPipelineBindPoint) ? 1 : -1])); /* add VkPipelineBindPoint to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_pipelineBindPoint = 0; + memcpy((void*)(&cmock_call_instance->Expected_layout), (void*)(&layout), + sizeof(VkPipelineLayout[sizeof(layout) == sizeof(VkPipelineLayout) ? 1 : -1])); /* add VkPipelineLayout to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_layout = 0; + cmock_call_instance->Expected_firstSet = firstSet; + cmock_call_instance->IgnoreArg_firstSet = 0; + cmock_call_instance->Expected_setCount = setCount; + cmock_call_instance->IgnoreArg_setCount = 0; + cmock_call_instance->Expected_pBufferIndices = pBufferIndices; + cmock_call_instance->IgnoreArg_pBufferIndices = 0; + cmock_call_instance->Expected_pOffsets = pOffsets; + cmock_call_instance->IgnoreArg_pOffsets = 0; +} + +void vkCmdSetDescriptorBufferOffsetsEXT_CMockIgnore(void) +{ + Mock.vkCmdSetDescriptorBufferOffsetsEXT_IgnoreBool = (char)1; +} + +void vkCmdSetDescriptorBufferOffsetsEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetDescriptorBufferOffsetsEXT_IgnoreBool = (char)0; +} + +void vkCmdSetDescriptorBufferOffsetsEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDescriptorBufferOffsetsEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDescriptorBufferOffsetsEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetDescriptorBufferOffsetsEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetDescriptorBufferOffsetsEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDescriptorBufferOffsetsEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDescriptorBufferOffsetsEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetDescriptorBufferOffsetsEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetDescriptorBufferOffsetsEXT(cmock_call_instance, commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets); +} + +void vkCmdSetDescriptorBufferOffsetsEXT_AddCallback(CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALLBACK Callback) +{ + Mock.vkCmdSetDescriptorBufferOffsetsEXT_IgnoreBool = (char)0; + Mock.vkCmdSetDescriptorBufferOffsetsEXT_CallbackBool = (char)1; + Mock.vkCmdSetDescriptorBufferOffsetsEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDescriptorBufferOffsetsEXT_Stub(CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALLBACK Callback) +{ + Mock.vkCmdSetDescriptorBufferOffsetsEXT_IgnoreBool = (char)0; + Mock.vkCmdSetDescriptorBufferOffsetsEXT_CallbackBool = (char)0; + Mock.vkCmdSetDescriptorBufferOffsetsEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDescriptorBufferOffsetsEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDescriptorBufferOffsetsEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetDescriptorBufferOffsetsEXT_CMockIgnoreArg_pipelineBindPoint(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDescriptorBufferOffsetsEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pipelineBindPoint = 1; +} + +void vkCmdSetDescriptorBufferOffsetsEXT_CMockIgnoreArg_layout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDescriptorBufferOffsetsEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_layout = 1; +} + +void vkCmdSetDescriptorBufferOffsetsEXT_CMockIgnoreArg_firstSet(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDescriptorBufferOffsetsEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstSet = 1; +} + +void vkCmdSetDescriptorBufferOffsetsEXT_CMockIgnoreArg_setCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDescriptorBufferOffsetsEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_setCount = 1; +} + +void vkCmdSetDescriptorBufferOffsetsEXT_CMockIgnoreArg_pBufferIndices(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDescriptorBufferOffsetsEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pBufferIndices = 1; +} + +void vkCmdSetDescriptorBufferOffsetsEXT_CMockIgnoreArg_pOffsets(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDescriptorBufferOffsetsEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pOffsets = 1; +} + +void vkCmdBindDescriptorBufferEmbeddedSamplersEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBindDescriptorBufferEmbeddedSamplersEXT); + cmock_call_instance = (CMOCK_vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CallInstance); + Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CallInstance); + if (Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CallbackBool && + Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CallbackFunctionPointer(commandBuffer, pipelineBindPoint, layout, set, Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindDescriptorBufferEmbeddedSamplersEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pipelineBindPoint) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindDescriptorBufferEmbeddedSamplersEXT,CMockString_pipelineBindPoint); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_pipelineBindPoint), (void*)(&pipelineBindPoint), sizeof(VkPipelineBindPoint), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_layout) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindDescriptorBufferEmbeddedSamplersEXT,CMockString_layout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_layout), (void*)(&layout), sizeof(VkPipelineLayout), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_set) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindDescriptorBufferEmbeddedSamplersEXT,CMockString_set); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_set, set, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CallbackFunctionPointer(commandBuffer, pipelineBindPoint, layout, set, Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(CMOCK_vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set); +void CMockExpectParameters_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(CMOCK_vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_pipelineBindPoint), (void*)(&pipelineBindPoint), + sizeof(VkPipelineBindPoint[sizeof(pipelineBindPoint) == sizeof(VkPipelineBindPoint) ? 1 : -1])); /* add VkPipelineBindPoint to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_pipelineBindPoint = 0; + memcpy((void*)(&cmock_call_instance->Expected_layout), (void*)(&layout), + sizeof(VkPipelineLayout[sizeof(layout) == sizeof(VkPipelineLayout) ? 1 : -1])); /* add VkPipelineLayout to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_layout = 0; + cmock_call_instance->Expected_set = set; + cmock_call_instance->IgnoreArg_set = 0; +} + +void vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CMockIgnore(void) +{ + Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_IgnoreBool = (char)1; +} + +void vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CMockStopIgnore(void) +{ + Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_IgnoreBool = (char)0; +} + +void vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CALL_INSTANCE)); + CMOCK_vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CallInstance, cmock_guts_index); + Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CALL_INSTANCE)); + CMOCK_vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CallInstance, cmock_guts_index); + Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(cmock_call_instance, commandBuffer, pipelineBindPoint, layout, set); +} + +void vkCmdBindDescriptorBufferEmbeddedSamplersEXT_AddCallback(CMOCK_vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CALLBACK Callback) +{ + Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_IgnoreBool = (char)0; + Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CallbackBool = (char)1; + Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdBindDescriptorBufferEmbeddedSamplersEXT_Stub(CMOCK_vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CALLBACK Callback) +{ + Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_IgnoreBool = (char)0; + Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CallbackBool = (char)0; + Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CMockIgnoreArg_pipelineBindPoint(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pipelineBindPoint = 1; +} + +void vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CMockIgnoreArg_layout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_layout = 1; +} + +void vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CMockIgnoreArg_set(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_set = 1; +} + +VkResult vkGetBufferOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT* pInfo, void* pData) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetBufferOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetBufferOpaqueCaptureDescriptorDataEXT); + cmock_call_instance = (CMOCK_vkGetBufferOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_CallInstance); + Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_CallInstance); + if (Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_FinalReturn; + memcpy((void*)(&Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_CallbackBool && + Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer(device, pInfo, pData, Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetBufferOpaqueCaptureDescriptorDataEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetBufferOpaqueCaptureDescriptorDataEXT,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkBufferCaptureDescriptorDataInfoEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pData) + { + UNITY_SET_DETAILS(CMockString_vkGetBufferOpaqueCaptureDescriptorDataEXT,CMockString_pData); + if (cmock_call_instance->Expected_pData == NULL) + { UNITY_TEST_ASSERT_NULL(pData, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(cmock_call_instance->Expected_pData, pData, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer(device, pInfo, pData, Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pData_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pData, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pData, (const void*)cmock_call_instance->ReturnThruPtr_pData_Val, + cmock_call_instance->ReturnThruPtr_pData_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetBufferOpaqueCaptureDescriptorDataEXT(CMOCK_vkGetBufferOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT* pInfo, void* pData); +void CMockExpectParameters_vkGetBufferOpaqueCaptureDescriptorDataEXT(CMOCK_vkGetBufferOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT* pInfo, void* pData) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; + cmock_call_instance->Expected_pData = pData; + cmock_call_instance->IgnoreArg_pData = 0; + cmock_call_instance->ReturnThruPtr_pData_Used = 0; +} + +void vkGetBufferOpaqueCaptureDescriptorDataEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetBufferOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE)); + CMOCK_vkGetBufferOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_CallInstance, cmock_guts_index); + Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)1; +} + +void vkGetBufferOpaqueCaptureDescriptorDataEXT_CMockStopIgnore(void) +{ + if(Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_IgnoreBool) + Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_CallInstance); + Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)0; +} + +void vkGetBufferOpaqueCaptureDescriptorDataEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetBufferOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE)); + CMOCK_vkGetBufferOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_CallInstance, cmock_guts_index); + Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetBufferOpaqueCaptureDescriptorDataEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT* pInfo, void* pData, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetBufferOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE)); + CMOCK_vkGetBufferOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_CallInstance, cmock_guts_index); + Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetBufferOpaqueCaptureDescriptorDataEXT(cmock_call_instance, device, pInfo, pData); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetBufferOpaqueCaptureDescriptorDataEXT_AddCallback(CMOCK_vkGetBufferOpaqueCaptureDescriptorDataEXT_CALLBACK Callback) +{ + Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)0; + Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_CallbackBool = (char)1; + Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer = Callback; +} + +void vkGetBufferOpaqueCaptureDescriptorDataEXT_Stub(CMOCK_vkGetBufferOpaqueCaptureDescriptorDataEXT_CALLBACK Callback) +{ + Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)0; + Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_CallbackBool = (char)0; + Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer = Callback; +} + +void vkGetBufferOpaqueCaptureDescriptorDataEXT_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, void const* pData, size_t cmock_size) +{ + CMOCK_vkGetBufferOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pData_Used = 1; + cmock_call_instance->ReturnThruPtr_pData_Val = pData; + cmock_call_instance->ReturnThruPtr_pData_Size = cmock_size; +} + +void vkGetBufferOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetBufferOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetBufferOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetBufferOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +void vkGetBufferOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetBufferOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetBufferOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetBufferOpaqueCaptureDescriptorDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pData = 1; +} + +VkResult vkGetImageOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageCaptureDescriptorDataInfoEXT* pInfo, void* pData) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetImageOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetImageOpaqueCaptureDescriptorDataEXT); + cmock_call_instance = (CMOCK_vkGetImageOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_CallInstance); + Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_CallInstance); + if (Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_FinalReturn; + memcpy((void*)(&Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_CallbackBool && + Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer(device, pInfo, pData, Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetImageOpaqueCaptureDescriptorDataEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetImageOpaqueCaptureDescriptorDataEXT,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkImageCaptureDescriptorDataInfoEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pData) + { + UNITY_SET_DETAILS(CMockString_vkGetImageOpaqueCaptureDescriptorDataEXT,CMockString_pData); + if (cmock_call_instance->Expected_pData == NULL) + { UNITY_TEST_ASSERT_NULL(pData, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(cmock_call_instance->Expected_pData, pData, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer(device, pInfo, pData, Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pData_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pData, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pData, (const void*)cmock_call_instance->ReturnThruPtr_pData_Val, + cmock_call_instance->ReturnThruPtr_pData_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetImageOpaqueCaptureDescriptorDataEXT(CMOCK_vkGetImageOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkImageCaptureDescriptorDataInfoEXT* pInfo, void* pData); +void CMockExpectParameters_vkGetImageOpaqueCaptureDescriptorDataEXT(CMOCK_vkGetImageOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkImageCaptureDescriptorDataInfoEXT* pInfo, void* pData) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; + cmock_call_instance->Expected_pData = pData; + cmock_call_instance->IgnoreArg_pData = 0; + cmock_call_instance->ReturnThruPtr_pData_Used = 0; +} + +void vkGetImageOpaqueCaptureDescriptorDataEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE)); + CMOCK_vkGetImageOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_CallInstance, cmock_guts_index); + Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)1; +} + +void vkGetImageOpaqueCaptureDescriptorDataEXT_CMockStopIgnore(void) +{ + if(Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_IgnoreBool) + Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_CallInstance); + Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)0; +} + +void vkGetImageOpaqueCaptureDescriptorDataEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE)); + CMOCK_vkGetImageOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_CallInstance, cmock_guts_index); + Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetImageOpaqueCaptureDescriptorDataEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkImageCaptureDescriptorDataInfoEXT* pInfo, void* pData, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE)); + CMOCK_vkGetImageOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_CallInstance, cmock_guts_index); + Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetImageOpaqueCaptureDescriptorDataEXT(cmock_call_instance, device, pInfo, pData); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetImageOpaqueCaptureDescriptorDataEXT_AddCallback(CMOCK_vkGetImageOpaqueCaptureDescriptorDataEXT_CALLBACK Callback) +{ + Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)0; + Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_CallbackBool = (char)1; + Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer = Callback; +} + +void vkGetImageOpaqueCaptureDescriptorDataEXT_Stub(CMOCK_vkGetImageOpaqueCaptureDescriptorDataEXT_CALLBACK Callback) +{ + Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)0; + Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_CallbackBool = (char)0; + Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer = Callback; +} + +void vkGetImageOpaqueCaptureDescriptorDataEXT_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, void const* pData, size_t cmock_size) +{ + CMOCK_vkGetImageOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pData_Used = 1; + cmock_call_instance->ReturnThruPtr_pData_Val = pData; + cmock_call_instance->ReturnThruPtr_pData_Size = cmock_size; +} + +void vkGetImageOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetImageOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +void vkGetImageOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageOpaqueCaptureDescriptorDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pData = 1; +} + +VkResult vkGetImageViewOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetImageViewOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetImageViewOpaqueCaptureDescriptorDataEXT); + cmock_call_instance = (CMOCK_vkGetImageViewOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallInstance); + Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallInstance); + if (Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_FinalReturn; + memcpy((void*)(&Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallbackBool && + Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer(device, pInfo, pData, Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetImageViewOpaqueCaptureDescriptorDataEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetImageViewOpaqueCaptureDescriptorDataEXT,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkImageViewCaptureDescriptorDataInfoEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pData) + { + UNITY_SET_DETAILS(CMockString_vkGetImageViewOpaqueCaptureDescriptorDataEXT,CMockString_pData); + if (cmock_call_instance->Expected_pData == NULL) + { UNITY_TEST_ASSERT_NULL(pData, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(cmock_call_instance->Expected_pData, pData, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer(device, pInfo, pData, Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pData_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pData, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pData, (const void*)cmock_call_instance->ReturnThruPtr_pData_Val, + cmock_call_instance->ReturnThruPtr_pData_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetImageViewOpaqueCaptureDescriptorDataEXT(CMOCK_vkGetImageViewOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData); +void CMockExpectParameters_vkGetImageViewOpaqueCaptureDescriptorDataEXT(CMOCK_vkGetImageViewOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; + cmock_call_instance->Expected_pData = pData; + cmock_call_instance->IgnoreArg_pData = 0; + cmock_call_instance->ReturnThruPtr_pData_Used = 0; +} + +void vkGetImageViewOpaqueCaptureDescriptorDataEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageViewOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE)); + CMOCK_vkGetImageViewOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageViewOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallInstance, cmock_guts_index); + Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)1; +} + +void vkGetImageViewOpaqueCaptureDescriptorDataEXT_CMockStopIgnore(void) +{ + if(Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_IgnoreBool) + Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallInstance); + Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)0; +} + +void vkGetImageViewOpaqueCaptureDescriptorDataEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageViewOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE)); + CMOCK_vkGetImageViewOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageViewOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallInstance, cmock_guts_index); + Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetImageViewOpaqueCaptureDescriptorDataEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageViewOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE)); + CMOCK_vkGetImageViewOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageViewOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallInstance, cmock_guts_index); + Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetImageViewOpaqueCaptureDescriptorDataEXT(cmock_call_instance, device, pInfo, pData); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetImageViewOpaqueCaptureDescriptorDataEXT_AddCallback(CMOCK_vkGetImageViewOpaqueCaptureDescriptorDataEXT_CALLBACK Callback) +{ + Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)0; + Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallbackBool = (char)1; + Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer = Callback; +} + +void vkGetImageViewOpaqueCaptureDescriptorDataEXT_Stub(CMOCK_vkGetImageViewOpaqueCaptureDescriptorDataEXT_CALLBACK Callback) +{ + Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)0; + Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallbackBool = (char)0; + Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer = Callback; +} + +void vkGetImageViewOpaqueCaptureDescriptorDataEXT_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, void const* pData, size_t cmock_size) +{ + CMOCK_vkGetImageViewOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageViewOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pData_Used = 1; + cmock_call_instance->ReturnThruPtr_pData_Val = pData; + cmock_call_instance->ReturnThruPtr_pData_Size = cmock_size; +} + +void vkGetImageViewOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageViewOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageViewOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetImageViewOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageViewOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageViewOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +void vkGetImageViewOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageViewOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageViewOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageViewOpaqueCaptureDescriptorDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pData = 1; +} + +VkResult vkGetSamplerOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, void* pData) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetSamplerOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetSamplerOpaqueCaptureDescriptorDataEXT); + cmock_call_instance = (CMOCK_vkGetSamplerOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallInstance); + Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallInstance); + if (Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_FinalReturn; + memcpy((void*)(&Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallbackBool && + Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer(device, pInfo, pData, Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetSamplerOpaqueCaptureDescriptorDataEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetSamplerOpaqueCaptureDescriptorDataEXT,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkSamplerCaptureDescriptorDataInfoEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pData) + { + UNITY_SET_DETAILS(CMockString_vkGetSamplerOpaqueCaptureDescriptorDataEXT,CMockString_pData); + if (cmock_call_instance->Expected_pData == NULL) + { UNITY_TEST_ASSERT_NULL(pData, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(cmock_call_instance->Expected_pData, pData, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer(device, pInfo, pData, Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pData_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pData, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pData, (const void*)cmock_call_instance->ReturnThruPtr_pData_Val, + cmock_call_instance->ReturnThruPtr_pData_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetSamplerOpaqueCaptureDescriptorDataEXT(CMOCK_vkGetSamplerOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, void* pData); +void CMockExpectParameters_vkGetSamplerOpaqueCaptureDescriptorDataEXT(CMOCK_vkGetSamplerOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, void* pData) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; + cmock_call_instance->Expected_pData = pData; + cmock_call_instance->IgnoreArg_pData = 0; + cmock_call_instance->ReturnThruPtr_pData_Used = 0; +} + +void vkGetSamplerOpaqueCaptureDescriptorDataEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetSamplerOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE)); + CMOCK_vkGetSamplerOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSamplerOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallInstance, cmock_guts_index); + Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)1; +} + +void vkGetSamplerOpaqueCaptureDescriptorDataEXT_CMockStopIgnore(void) +{ + if(Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_IgnoreBool) + Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallInstance); + Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)0; +} + +void vkGetSamplerOpaqueCaptureDescriptorDataEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetSamplerOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE)); + CMOCK_vkGetSamplerOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSamplerOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallInstance, cmock_guts_index); + Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetSamplerOpaqueCaptureDescriptorDataEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, void* pData, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetSamplerOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE)); + CMOCK_vkGetSamplerOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSamplerOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallInstance, cmock_guts_index); + Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetSamplerOpaqueCaptureDescriptorDataEXT(cmock_call_instance, device, pInfo, pData); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetSamplerOpaqueCaptureDescriptorDataEXT_AddCallback(CMOCK_vkGetSamplerOpaqueCaptureDescriptorDataEXT_CALLBACK Callback) +{ + Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)0; + Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallbackBool = (char)1; + Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer = Callback; +} + +void vkGetSamplerOpaqueCaptureDescriptorDataEXT_Stub(CMOCK_vkGetSamplerOpaqueCaptureDescriptorDataEXT_CALLBACK Callback) +{ + Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)0; + Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallbackBool = (char)0; + Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer = Callback; +} + +void vkGetSamplerOpaqueCaptureDescriptorDataEXT_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, void const* pData, size_t cmock_size) +{ + CMOCK_vkGetSamplerOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSamplerOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pData_Used = 1; + cmock_call_instance->ReturnThruPtr_pData_Val = pData; + cmock_call_instance->ReturnThruPtr_pData_Size = cmock_size; +} + +void vkGetSamplerOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetSamplerOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSamplerOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetSamplerOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetSamplerOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSamplerOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +void vkGetSamplerOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetSamplerOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetSamplerOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetSamplerOpaqueCaptureDescriptorDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pData = 1; +} + +VkResult vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT); + cmock_call_instance = (CMOCK_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallInstance); + Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallInstance); + if (Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_FinalReturn; + memcpy((void*)(&Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallbackBool && + Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer(device, pInfo, pData, Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkAccelerationStructureCaptureDescriptorDataInfoEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pData) + { + UNITY_SET_DETAILS(CMockString_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT,CMockString_pData); + if (cmock_call_instance->Expected_pData == NULL) + { UNITY_TEST_ASSERT_NULL(pData, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(cmock_call_instance->Expected_pData, pData, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer(device, pInfo, pData, Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pData_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pData, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pData, (const void*)cmock_call_instance->ReturnThruPtr_pData_Val, + cmock_call_instance->ReturnThruPtr_pData_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(CMOCK_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData); +void CMockExpectParameters_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(CMOCK_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; + cmock_call_instance->Expected_pData = pData; + cmock_call_instance->IgnoreArg_pData = 0; + cmock_call_instance->ReturnThruPtr_pData_Used = 0; +} + +void vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE)); + CMOCK_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallInstance, cmock_guts_index); + Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)1; +} + +void vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CMockStopIgnore(void) +{ + if(Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_IgnoreBool) + Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallInstance); + Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)0; +} + +void vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE)); + CMOCK_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallInstance, cmock_guts_index); + Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE)); + CMOCK_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallInstance, cmock_guts_index); + Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(cmock_call_instance, device, pInfo, pData); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_AddCallback(CMOCK_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CALLBACK Callback) +{ + Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)0; + Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallbackBool = (char)1; + Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer = Callback; +} + +void vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_Stub(CMOCK_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CALLBACK Callback) +{ + Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_IgnoreBool = (char)0; + Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallbackBool = (char)0; + Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallbackFunctionPointer = Callback; +} + +void vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, void const* pData, size_t cmock_size) +{ + CMOCK_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pData_Used = 1; + cmock_call_instance->ReturnThruPtr_pData_Val = pData; + cmock_call_instance->ReturnThruPtr_pData_Size = cmock_size; +} + +void vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +void vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pData = 1; +} + +void vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetFragmentShadingRateEnumNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetFragmentShadingRateEnumNV); + cmock_call_instance = (CMOCK_vkCmdSetFragmentShadingRateEnumNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetFragmentShadingRateEnumNV_CallInstance); + Mock.vkCmdSetFragmentShadingRateEnumNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetFragmentShadingRateEnumNV_CallInstance); + if (Mock.vkCmdSetFragmentShadingRateEnumNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetFragmentShadingRateEnumNV_CallbackBool && + Mock.vkCmdSetFragmentShadingRateEnumNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetFragmentShadingRateEnumNV_CallbackFunctionPointer(commandBuffer, shadingRate, combinerOps, Mock.vkCmdSetFragmentShadingRateEnumNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetFragmentShadingRateEnumNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_shadingRate) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetFragmentShadingRateEnumNV,CMockString_shadingRate); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_shadingRate), (void*)(&shadingRate), sizeof(VkFragmentShadingRateNV), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_combinerOps) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetFragmentShadingRateEnumNV,CMockString_combinerOps); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_combinerOps), (void*)(combinerOps), sizeof(const VkFragmentShadingRateCombinerOpKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetFragmentShadingRateEnumNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetFragmentShadingRateEnumNV_CallbackFunctionPointer(commandBuffer, shadingRate, combinerOps, Mock.vkCmdSetFragmentShadingRateEnumNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetFragmentShadingRateEnumNV(CMOCK_vkCmdSetFragmentShadingRateEnumNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR* combinerOps); +void CMockExpectParameters_vkCmdSetFragmentShadingRateEnumNV(CMOCK_vkCmdSetFragmentShadingRateEnumNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR* combinerOps) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_shadingRate), (void*)(&shadingRate), + sizeof(VkFragmentShadingRateNV[sizeof(shadingRate) == sizeof(VkFragmentShadingRateNV) ? 1 : -1])); /* add VkFragmentShadingRateNV to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_shadingRate = 0; + cmock_call_instance->Expected_combinerOps = combinerOps; + cmock_call_instance->IgnoreArg_combinerOps = 0; +} + +void vkCmdSetFragmentShadingRateEnumNV_CMockIgnore(void) +{ + Mock.vkCmdSetFragmentShadingRateEnumNV_IgnoreBool = (char)1; +} + +void vkCmdSetFragmentShadingRateEnumNV_CMockStopIgnore(void) +{ + Mock.vkCmdSetFragmentShadingRateEnumNV_IgnoreBool = (char)0; +} + +void vkCmdSetFragmentShadingRateEnumNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetFragmentShadingRateEnumNV_CALL_INSTANCE)); + CMOCK_vkCmdSetFragmentShadingRateEnumNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetFragmentShadingRateEnumNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetFragmentShadingRateEnumNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetFragmentShadingRateEnumNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetFragmentShadingRateEnumNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetFragmentShadingRateEnumNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR* combinerOps) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetFragmentShadingRateEnumNV_CALL_INSTANCE)); + CMOCK_vkCmdSetFragmentShadingRateEnumNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetFragmentShadingRateEnumNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetFragmentShadingRateEnumNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetFragmentShadingRateEnumNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetFragmentShadingRateEnumNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetFragmentShadingRateEnumNV(cmock_call_instance, commandBuffer, shadingRate, combinerOps); +} + +void vkCmdSetFragmentShadingRateEnumNV_AddCallback(CMOCK_vkCmdSetFragmentShadingRateEnumNV_CALLBACK Callback) +{ + Mock.vkCmdSetFragmentShadingRateEnumNV_IgnoreBool = (char)0; + Mock.vkCmdSetFragmentShadingRateEnumNV_CallbackBool = (char)1; + Mock.vkCmdSetFragmentShadingRateEnumNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetFragmentShadingRateEnumNV_Stub(CMOCK_vkCmdSetFragmentShadingRateEnumNV_CALLBACK Callback) +{ + Mock.vkCmdSetFragmentShadingRateEnumNV_IgnoreBool = (char)0; + Mock.vkCmdSetFragmentShadingRateEnumNV_CallbackBool = (char)0; + Mock.vkCmdSetFragmentShadingRateEnumNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetFragmentShadingRateEnumNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetFragmentShadingRateEnumNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetFragmentShadingRateEnumNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetFragmentShadingRateEnumNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetFragmentShadingRateEnumNV_CMockIgnoreArg_shadingRate(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetFragmentShadingRateEnumNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetFragmentShadingRateEnumNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetFragmentShadingRateEnumNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_shadingRate = 1; +} + +void vkCmdSetFragmentShadingRateEnumNV_CMockIgnoreArg_combinerOps(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetFragmentShadingRateEnumNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetFragmentShadingRateEnumNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetFragmentShadingRateEnumNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_combinerOps = 1; +} + +void vkGetImageSubresourceLayout2EXT(VkDevice device, VkImage image, const VkImageSubresource2EXT* pSubresource, VkSubresourceLayout2EXT* pLayout) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetImageSubresourceLayout2EXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetImageSubresourceLayout2EXT); + cmock_call_instance = (CMOCK_vkGetImageSubresourceLayout2EXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetImageSubresourceLayout2EXT_CallInstance); + Mock.vkGetImageSubresourceLayout2EXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetImageSubresourceLayout2EXT_CallInstance); + if (Mock.vkGetImageSubresourceLayout2EXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetImageSubresourceLayout2EXT_CallbackBool && + Mock.vkGetImageSubresourceLayout2EXT_CallbackFunctionPointer != NULL) + { + Mock.vkGetImageSubresourceLayout2EXT_CallbackFunctionPointer(device, image, pSubresource, pLayout, Mock.vkGetImageSubresourceLayout2EXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetImageSubresourceLayout2EXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_image) + { + UNITY_SET_DETAILS(CMockString_vkGetImageSubresourceLayout2EXT,CMockString_image); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_image), (void*)(&image), sizeof(VkImage), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSubresource) + { + UNITY_SET_DETAILS(CMockString_vkGetImageSubresourceLayout2EXT,CMockString_pSubresource); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSubresource), (void*)(pSubresource), sizeof(const VkImageSubresource2EXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pLayout) + { + UNITY_SET_DETAILS(CMockString_vkGetImageSubresourceLayout2EXT,CMockString_pLayout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pLayout), (void*)(pLayout), sizeof(VkSubresourceLayout2EXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetImageSubresourceLayout2EXT_CallbackFunctionPointer != NULL) + { + Mock.vkGetImageSubresourceLayout2EXT_CallbackFunctionPointer(device, image, pSubresource, pLayout, Mock.vkGetImageSubresourceLayout2EXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pLayout_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pLayout, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pLayout, (const void*)cmock_call_instance->ReturnThruPtr_pLayout_Val, + cmock_call_instance->ReturnThruPtr_pLayout_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetImageSubresourceLayout2EXT(CMOCK_vkGetImageSubresourceLayout2EXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkImage image, const VkImageSubresource2EXT* pSubresource, VkSubresourceLayout2EXT* pLayout); +void CMockExpectParameters_vkGetImageSubresourceLayout2EXT(CMOCK_vkGetImageSubresourceLayout2EXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkImage image, const VkImageSubresource2EXT* pSubresource, VkSubresourceLayout2EXT* pLayout) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_image), (void*)(&image), + sizeof(VkImage[sizeof(image) == sizeof(VkImage) ? 1 : -1])); /* add VkImage to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_image = 0; + cmock_call_instance->Expected_pSubresource = pSubresource; + cmock_call_instance->IgnoreArg_pSubresource = 0; + cmock_call_instance->Expected_pLayout = pLayout; + cmock_call_instance->IgnoreArg_pLayout = 0; + cmock_call_instance->ReturnThruPtr_pLayout_Used = 0; +} + +void vkGetImageSubresourceLayout2EXT_CMockIgnore(void) +{ + Mock.vkGetImageSubresourceLayout2EXT_IgnoreBool = (char)1; +} + +void vkGetImageSubresourceLayout2EXT_CMockStopIgnore(void) +{ + Mock.vkGetImageSubresourceLayout2EXT_IgnoreBool = (char)0; +} + +void vkGetImageSubresourceLayout2EXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageSubresourceLayout2EXT_CALL_INSTANCE)); + CMOCK_vkGetImageSubresourceLayout2EXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSubresourceLayout2EXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageSubresourceLayout2EXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageSubresourceLayout2EXT_CallInstance, cmock_guts_index); + Mock.vkGetImageSubresourceLayout2EXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetImageSubresourceLayout2EXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkImage image, const VkImageSubresource2EXT* pSubresource, VkSubresourceLayout2EXT* pLayout) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetImageSubresourceLayout2EXT_CALL_INSTANCE)); + CMOCK_vkGetImageSubresourceLayout2EXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSubresourceLayout2EXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetImageSubresourceLayout2EXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetImageSubresourceLayout2EXT_CallInstance, cmock_guts_index); + Mock.vkGetImageSubresourceLayout2EXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetImageSubresourceLayout2EXT(cmock_call_instance, device, image, pSubresource, pLayout); +} + +void vkGetImageSubresourceLayout2EXT_AddCallback(CMOCK_vkGetImageSubresourceLayout2EXT_CALLBACK Callback) +{ + Mock.vkGetImageSubresourceLayout2EXT_IgnoreBool = (char)0; + Mock.vkGetImageSubresourceLayout2EXT_CallbackBool = (char)1; + Mock.vkGetImageSubresourceLayout2EXT_CallbackFunctionPointer = Callback; +} + +void vkGetImageSubresourceLayout2EXT_Stub(CMOCK_vkGetImageSubresourceLayout2EXT_CALLBACK Callback) +{ + Mock.vkGetImageSubresourceLayout2EXT_IgnoreBool = (char)0; + Mock.vkGetImageSubresourceLayout2EXT_CallbackBool = (char)0; + Mock.vkGetImageSubresourceLayout2EXT_CallbackFunctionPointer = Callback; +} + +void vkGetImageSubresourceLayout2EXT_CMockReturnMemThruPtr_pLayout(UNITY_LINE_TYPE cmock_line, VkSubresourceLayout2EXT const* pLayout, size_t cmock_size) +{ + CMOCK_vkGetImageSubresourceLayout2EXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSubresourceLayout2EXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageSubresourceLayout2EXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pLayout_Used = 1; + cmock_call_instance->ReturnThruPtr_pLayout_Val = pLayout; + cmock_call_instance->ReturnThruPtr_pLayout_Size = cmock_size; +} + +void vkGetImageSubresourceLayout2EXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageSubresourceLayout2EXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSubresourceLayout2EXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageSubresourceLayout2EXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetImageSubresourceLayout2EXT_CMockIgnoreArg_image(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageSubresourceLayout2EXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSubresourceLayout2EXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageSubresourceLayout2EXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_image = 1; +} + +void vkGetImageSubresourceLayout2EXT_CMockIgnoreArg_pSubresource(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageSubresourceLayout2EXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSubresourceLayout2EXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageSubresourceLayout2EXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSubresource = 1; +} + +void vkGetImageSubresourceLayout2EXT_CMockIgnoreArg_pLayout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetImageSubresourceLayout2EXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetImageSubresourceLayout2EXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetImageSubresourceLayout2EXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pLayout = 1; +} + +VkResult vkGetDeviceFaultInfoEXT(VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDeviceFaultInfoEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDeviceFaultInfoEXT); + cmock_call_instance = (CMOCK_vkGetDeviceFaultInfoEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDeviceFaultInfoEXT_CallInstance); + Mock.vkGetDeviceFaultInfoEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeviceFaultInfoEXT_CallInstance); + if (Mock.vkGetDeviceFaultInfoEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetDeviceFaultInfoEXT_FinalReturn; + memcpy((void*)(&Mock.vkGetDeviceFaultInfoEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetDeviceFaultInfoEXT_CallbackBool && + Mock.vkGetDeviceFaultInfoEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetDeviceFaultInfoEXT_CallbackFunctionPointer(device, pFaultCounts, pFaultInfo, Mock.vkGetDeviceFaultInfoEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceFaultInfoEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pFaultCounts) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceFaultInfoEXT,CMockString_pFaultCounts); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pFaultCounts), (void*)(pFaultCounts), sizeof(VkDeviceFaultCountsEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pFaultInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceFaultInfoEXT,CMockString_pFaultInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pFaultInfo), (void*)(pFaultInfo), sizeof(VkDeviceFaultInfoEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDeviceFaultInfoEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetDeviceFaultInfoEXT_CallbackFunctionPointer(device, pFaultCounts, pFaultInfo, Mock.vkGetDeviceFaultInfoEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pFaultCounts_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pFaultCounts, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pFaultCounts, (const void*)cmock_call_instance->ReturnThruPtr_pFaultCounts_Val, + cmock_call_instance->ReturnThruPtr_pFaultCounts_Size); + } + if (cmock_call_instance->ReturnThruPtr_pFaultInfo_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pFaultInfo, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pFaultInfo, (const void*)cmock_call_instance->ReturnThruPtr_pFaultInfo_Val, + cmock_call_instance->ReturnThruPtr_pFaultInfo_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetDeviceFaultInfoEXT(CMOCK_vkGetDeviceFaultInfoEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo); +void CMockExpectParameters_vkGetDeviceFaultInfoEXT(CMOCK_vkGetDeviceFaultInfoEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pFaultCounts = pFaultCounts; + cmock_call_instance->IgnoreArg_pFaultCounts = 0; + cmock_call_instance->ReturnThruPtr_pFaultCounts_Used = 0; + cmock_call_instance->Expected_pFaultInfo = pFaultInfo; + cmock_call_instance->IgnoreArg_pFaultInfo = 0; + cmock_call_instance->ReturnThruPtr_pFaultInfo_Used = 0; +} + +void vkGetDeviceFaultInfoEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceFaultInfoEXT_CALL_INSTANCE)); + CMOCK_vkGetDeviceFaultInfoEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceFaultInfoEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceFaultInfoEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceFaultInfoEXT_CallInstance, cmock_guts_index); + Mock.vkGetDeviceFaultInfoEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetDeviceFaultInfoEXT_IgnoreBool = (char)1; +} + +void vkGetDeviceFaultInfoEXT_CMockStopIgnore(void) +{ + if(Mock.vkGetDeviceFaultInfoEXT_IgnoreBool) + Mock.vkGetDeviceFaultInfoEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeviceFaultInfoEXT_CallInstance); + Mock.vkGetDeviceFaultInfoEXT_IgnoreBool = (char)0; +} + +void vkGetDeviceFaultInfoEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceFaultInfoEXT_CALL_INSTANCE)); + CMOCK_vkGetDeviceFaultInfoEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceFaultInfoEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceFaultInfoEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceFaultInfoEXT_CallInstance, cmock_guts_index); + Mock.vkGetDeviceFaultInfoEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDeviceFaultInfoEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceFaultInfoEXT_CALL_INSTANCE)); + CMOCK_vkGetDeviceFaultInfoEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceFaultInfoEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceFaultInfoEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceFaultInfoEXT_CallInstance, cmock_guts_index); + Mock.vkGetDeviceFaultInfoEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDeviceFaultInfoEXT(cmock_call_instance, device, pFaultCounts, pFaultInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetDeviceFaultInfoEXT_AddCallback(CMOCK_vkGetDeviceFaultInfoEXT_CALLBACK Callback) +{ + Mock.vkGetDeviceFaultInfoEXT_IgnoreBool = (char)0; + Mock.vkGetDeviceFaultInfoEXT_CallbackBool = (char)1; + Mock.vkGetDeviceFaultInfoEXT_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceFaultInfoEXT_Stub(CMOCK_vkGetDeviceFaultInfoEXT_CALLBACK Callback) +{ + Mock.vkGetDeviceFaultInfoEXT_IgnoreBool = (char)0; + Mock.vkGetDeviceFaultInfoEXT_CallbackBool = (char)0; + Mock.vkGetDeviceFaultInfoEXT_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceFaultInfoEXT_CMockReturnMemThruPtr_pFaultCounts(UNITY_LINE_TYPE cmock_line, VkDeviceFaultCountsEXT const* pFaultCounts, size_t cmock_size) +{ + CMOCK_vkGetDeviceFaultInfoEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceFaultInfoEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceFaultInfoEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pFaultCounts_Used = 1; + cmock_call_instance->ReturnThruPtr_pFaultCounts_Val = pFaultCounts; + cmock_call_instance->ReturnThruPtr_pFaultCounts_Size = cmock_size; +} + +void vkGetDeviceFaultInfoEXT_CMockReturnMemThruPtr_pFaultInfo(UNITY_LINE_TYPE cmock_line, VkDeviceFaultInfoEXT const* pFaultInfo, size_t cmock_size) +{ + CMOCK_vkGetDeviceFaultInfoEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceFaultInfoEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceFaultInfoEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pFaultInfo_Used = 1; + cmock_call_instance->ReturnThruPtr_pFaultInfo_Val = pFaultInfo; + cmock_call_instance->ReturnThruPtr_pFaultInfo_Size = cmock_size; +} + +void vkGetDeviceFaultInfoEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceFaultInfoEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceFaultInfoEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceFaultInfoEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetDeviceFaultInfoEXT_CMockIgnoreArg_pFaultCounts(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceFaultInfoEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceFaultInfoEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceFaultInfoEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pFaultCounts = 1; +} + +void vkGetDeviceFaultInfoEXT_CMockIgnoreArg_pFaultInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceFaultInfoEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceFaultInfoEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceFaultInfoEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pFaultInfo = 1; +} + +void vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetVertexInputEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetVertexInputEXT); + cmock_call_instance = (CMOCK_vkCmdSetVertexInputEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetVertexInputEXT_CallInstance); + Mock.vkCmdSetVertexInputEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetVertexInputEXT_CallInstance); + if (Mock.vkCmdSetVertexInputEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetVertexInputEXT_CallbackBool && + Mock.vkCmdSetVertexInputEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetVertexInputEXT_CallbackFunctionPointer(commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions, Mock.vkCmdSetVertexInputEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetVertexInputEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_vertexBindingDescriptionCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetVertexInputEXT,CMockString_vertexBindingDescriptionCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_vertexBindingDescriptionCount, vertexBindingDescriptionCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pVertexBindingDescriptions) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetVertexInputEXT,CMockString_pVertexBindingDescriptions); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pVertexBindingDescriptions), (void*)(pVertexBindingDescriptions), sizeof(const VkVertexInputBindingDescription2EXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_vertexAttributeDescriptionCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetVertexInputEXT,CMockString_vertexAttributeDescriptionCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_vertexAttributeDescriptionCount, vertexAttributeDescriptionCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pVertexAttributeDescriptions) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetVertexInputEXT,CMockString_pVertexAttributeDescriptions); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pVertexAttributeDescriptions), (void*)(pVertexAttributeDescriptions), sizeof(const VkVertexInputAttributeDescription2EXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetVertexInputEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetVertexInputEXT_CallbackFunctionPointer(commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions, Mock.vkCmdSetVertexInputEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetVertexInputEXT(CMOCK_vkCmdSetVertexInputEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions); +void CMockExpectParameters_vkCmdSetVertexInputEXT(CMOCK_vkCmdSetVertexInputEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_vertexBindingDescriptionCount = vertexBindingDescriptionCount; + cmock_call_instance->IgnoreArg_vertexBindingDescriptionCount = 0; + cmock_call_instance->Expected_pVertexBindingDescriptions = pVertexBindingDescriptions; + cmock_call_instance->IgnoreArg_pVertexBindingDescriptions = 0; + cmock_call_instance->Expected_vertexAttributeDescriptionCount = vertexAttributeDescriptionCount; + cmock_call_instance->IgnoreArg_vertexAttributeDescriptionCount = 0; + cmock_call_instance->Expected_pVertexAttributeDescriptions = pVertexAttributeDescriptions; + cmock_call_instance->IgnoreArg_pVertexAttributeDescriptions = 0; +} + +void vkCmdSetVertexInputEXT_CMockIgnore(void) +{ + Mock.vkCmdSetVertexInputEXT_IgnoreBool = (char)1; +} + +void vkCmdSetVertexInputEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetVertexInputEXT_IgnoreBool = (char)0; +} + +void vkCmdSetVertexInputEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetVertexInputEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetVertexInputEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetVertexInputEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetVertexInputEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetVertexInputEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetVertexInputEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetVertexInputEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetVertexInputEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetVertexInputEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetVertexInputEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetVertexInputEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetVertexInputEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetVertexInputEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetVertexInputEXT(cmock_call_instance, commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions); +} + +void vkCmdSetVertexInputEXT_AddCallback(CMOCK_vkCmdSetVertexInputEXT_CALLBACK Callback) +{ + Mock.vkCmdSetVertexInputEXT_IgnoreBool = (char)0; + Mock.vkCmdSetVertexInputEXT_CallbackBool = (char)1; + Mock.vkCmdSetVertexInputEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetVertexInputEXT_Stub(CMOCK_vkCmdSetVertexInputEXT_CALLBACK Callback) +{ + Mock.vkCmdSetVertexInputEXT_IgnoreBool = (char)0; + Mock.vkCmdSetVertexInputEXT_CallbackBool = (char)0; + Mock.vkCmdSetVertexInputEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetVertexInputEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetVertexInputEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetVertexInputEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetVertexInputEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetVertexInputEXT_CMockIgnoreArg_vertexBindingDescriptionCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetVertexInputEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetVertexInputEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetVertexInputEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_vertexBindingDescriptionCount = 1; +} + +void vkCmdSetVertexInputEXT_CMockIgnoreArg_pVertexBindingDescriptions(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetVertexInputEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetVertexInputEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetVertexInputEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pVertexBindingDescriptions = 1; +} + +void vkCmdSetVertexInputEXT_CMockIgnoreArg_vertexAttributeDescriptionCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetVertexInputEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetVertexInputEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetVertexInputEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_vertexAttributeDescriptionCount = 1; +} + +void vkCmdSetVertexInputEXT_CMockIgnoreArg_pVertexAttributeDescriptions(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetVertexInputEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetVertexInputEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetVertexInputEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pVertexAttributeDescriptions = 1; +} + +VkResult vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI); + cmock_call_instance = (CMOCK_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallInstance); + Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallInstance); + if (Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_FinalReturn; + memcpy((void*)(&Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallbackBool && + Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallbackFunctionPointer(device, renderpass, pMaxWorkgroupSize, Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_renderpass) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,CMockString_renderpass); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_renderpass), (void*)(&renderpass), sizeof(VkRenderPass), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMaxWorkgroupSize) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,CMockString_pMaxWorkgroupSize); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMaxWorkgroupSize), (void*)(pMaxWorkgroupSize), sizeof(VkExtent2D), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallbackFunctionPointer(device, renderpass, pMaxWorkgroupSize, Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pMaxWorkgroupSize_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pMaxWorkgroupSize, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pMaxWorkgroupSize, (const void*)cmock_call_instance->ReturnThruPtr_pMaxWorkgroupSize_Val, + cmock_call_instance->ReturnThruPtr_pMaxWorkgroupSize_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(CMOCK_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize); +void CMockExpectParameters_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(CMOCK_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_renderpass), (void*)(&renderpass), + sizeof(VkRenderPass[sizeof(renderpass) == sizeof(VkRenderPass) ? 1 : -1])); /* add VkRenderPass to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_renderpass = 0; + cmock_call_instance->Expected_pMaxWorkgroupSize = pMaxWorkgroupSize; + cmock_call_instance->IgnoreArg_pMaxWorkgroupSize = 0; + cmock_call_instance->ReturnThruPtr_pMaxWorkgroupSize_Used = 0; +} + +void vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CALL_INSTANCE)); + CMOCK_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallInstance, cmock_guts_index); + Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_IgnoreBool = (char)1; +} + +void vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CMockStopIgnore(void) +{ + if(Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_IgnoreBool) + Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallInstance); + Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_IgnoreBool = (char)0; +} + +void vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CALL_INSTANCE)); + CMOCK_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallInstance, cmock_guts_index); + Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CALL_INSTANCE)); + CMOCK_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallInstance, cmock_guts_index); + Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(cmock_call_instance, device, renderpass, pMaxWorkgroupSize); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_AddCallback(CMOCK_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CALLBACK Callback) +{ + Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_IgnoreBool = (char)0; + Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallbackBool = (char)1; + Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_Stub(CMOCK_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CALLBACK Callback) +{ + Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_IgnoreBool = (char)0; + Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallbackBool = (char)0; + Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CMockReturnMemThruPtr_pMaxWorkgroupSize(UNITY_LINE_TYPE cmock_line, VkExtent2D const* pMaxWorkgroupSize, size_t cmock_size) +{ + CMOCK_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pMaxWorkgroupSize_Used = 1; + cmock_call_instance->ReturnThruPtr_pMaxWorkgroupSize_Val = pMaxWorkgroupSize; + cmock_call_instance->ReturnThruPtr_pMaxWorkgroupSize_Size = cmock_size; +} + +void vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CMockIgnoreArg_renderpass(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_renderpass = 1; +} + +void vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CMockIgnoreArg_pMaxWorkgroupSize(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMaxWorkgroupSize = 1; +} + +void vkCmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSubpassShadingHUAWEI_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSubpassShadingHUAWEI); + cmock_call_instance = (CMOCK_vkCmdSubpassShadingHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSubpassShadingHUAWEI_CallInstance); + Mock.vkCmdSubpassShadingHUAWEI_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSubpassShadingHUAWEI_CallInstance); + if (Mock.vkCmdSubpassShadingHUAWEI_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSubpassShadingHUAWEI_CallbackBool && + Mock.vkCmdSubpassShadingHUAWEI_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSubpassShadingHUAWEI_CallbackFunctionPointer(commandBuffer, Mock.vkCmdSubpassShadingHUAWEI_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSubpassShadingHUAWEI,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSubpassShadingHUAWEI_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSubpassShadingHUAWEI_CallbackFunctionPointer(commandBuffer, Mock.vkCmdSubpassShadingHUAWEI_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSubpassShadingHUAWEI(CMOCK_vkCmdSubpassShadingHUAWEI_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer); +void CMockExpectParameters_vkCmdSubpassShadingHUAWEI(CMOCK_vkCmdSubpassShadingHUAWEI_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; +} + +void vkCmdSubpassShadingHUAWEI_CMockIgnore(void) +{ + Mock.vkCmdSubpassShadingHUAWEI_IgnoreBool = (char)1; +} + +void vkCmdSubpassShadingHUAWEI_CMockStopIgnore(void) +{ + Mock.vkCmdSubpassShadingHUAWEI_IgnoreBool = (char)0; +} + +void vkCmdSubpassShadingHUAWEI_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSubpassShadingHUAWEI_CALL_INSTANCE)); + CMOCK_vkCmdSubpassShadingHUAWEI_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSubpassShadingHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSubpassShadingHUAWEI_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSubpassShadingHUAWEI_CallInstance, cmock_guts_index); + Mock.vkCmdSubpassShadingHUAWEI_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSubpassShadingHUAWEI_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSubpassShadingHUAWEI_CALL_INSTANCE)); + CMOCK_vkCmdSubpassShadingHUAWEI_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSubpassShadingHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSubpassShadingHUAWEI_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSubpassShadingHUAWEI_CallInstance, cmock_guts_index); + Mock.vkCmdSubpassShadingHUAWEI_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSubpassShadingHUAWEI(cmock_call_instance, commandBuffer); +} + +void vkCmdSubpassShadingHUAWEI_AddCallback(CMOCK_vkCmdSubpassShadingHUAWEI_CALLBACK Callback) +{ + Mock.vkCmdSubpassShadingHUAWEI_IgnoreBool = (char)0; + Mock.vkCmdSubpassShadingHUAWEI_CallbackBool = (char)1; + Mock.vkCmdSubpassShadingHUAWEI_CallbackFunctionPointer = Callback; +} + +void vkCmdSubpassShadingHUAWEI_Stub(CMOCK_vkCmdSubpassShadingHUAWEI_CALLBACK Callback) +{ + Mock.vkCmdSubpassShadingHUAWEI_IgnoreBool = (char)0; + Mock.vkCmdSubpassShadingHUAWEI_CallbackBool = (char)0; + Mock.vkCmdSubpassShadingHUAWEI_CallbackFunctionPointer = Callback; +} + +void vkCmdSubpassShadingHUAWEI_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSubpassShadingHUAWEI_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSubpassShadingHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSubpassShadingHUAWEI_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBindInvocationMaskHUAWEI_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBindInvocationMaskHUAWEI); + cmock_call_instance = (CMOCK_vkCmdBindInvocationMaskHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBindInvocationMaskHUAWEI_CallInstance); + Mock.vkCmdBindInvocationMaskHUAWEI_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBindInvocationMaskHUAWEI_CallInstance); + if (Mock.vkCmdBindInvocationMaskHUAWEI_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBindInvocationMaskHUAWEI_CallbackBool && + Mock.vkCmdBindInvocationMaskHUAWEI_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBindInvocationMaskHUAWEI_CallbackFunctionPointer(commandBuffer, imageView, imageLayout, Mock.vkCmdBindInvocationMaskHUAWEI_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindInvocationMaskHUAWEI,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_imageView) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindInvocationMaskHUAWEI,CMockString_imageView); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_imageView), (void*)(&imageView), sizeof(VkImageView), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_imageLayout) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindInvocationMaskHUAWEI,CMockString_imageLayout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_imageLayout), (void*)(&imageLayout), sizeof(VkImageLayout), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdBindInvocationMaskHUAWEI_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBindInvocationMaskHUAWEI_CallbackFunctionPointer(commandBuffer, imageView, imageLayout, Mock.vkCmdBindInvocationMaskHUAWEI_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBindInvocationMaskHUAWEI(CMOCK_vkCmdBindInvocationMaskHUAWEI_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout); +void CMockExpectParameters_vkCmdBindInvocationMaskHUAWEI(CMOCK_vkCmdBindInvocationMaskHUAWEI_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_imageView), (void*)(&imageView), + sizeof(VkImageView[sizeof(imageView) == sizeof(VkImageView) ? 1 : -1])); /* add VkImageView to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_imageView = 0; + memcpy((void*)(&cmock_call_instance->Expected_imageLayout), (void*)(&imageLayout), + sizeof(VkImageLayout[sizeof(imageLayout) == sizeof(VkImageLayout) ? 1 : -1])); /* add VkImageLayout to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_imageLayout = 0; +} + +void vkCmdBindInvocationMaskHUAWEI_CMockIgnore(void) +{ + Mock.vkCmdBindInvocationMaskHUAWEI_IgnoreBool = (char)1; +} + +void vkCmdBindInvocationMaskHUAWEI_CMockStopIgnore(void) +{ + Mock.vkCmdBindInvocationMaskHUAWEI_IgnoreBool = (char)0; +} + +void vkCmdBindInvocationMaskHUAWEI_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBindInvocationMaskHUAWEI_CALL_INSTANCE)); + CMOCK_vkCmdBindInvocationMaskHUAWEI_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindInvocationMaskHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBindInvocationMaskHUAWEI_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBindInvocationMaskHUAWEI_CallInstance, cmock_guts_index); + Mock.vkCmdBindInvocationMaskHUAWEI_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBindInvocationMaskHUAWEI_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBindInvocationMaskHUAWEI_CALL_INSTANCE)); + CMOCK_vkCmdBindInvocationMaskHUAWEI_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindInvocationMaskHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBindInvocationMaskHUAWEI_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBindInvocationMaskHUAWEI_CallInstance, cmock_guts_index); + Mock.vkCmdBindInvocationMaskHUAWEI_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBindInvocationMaskHUAWEI(cmock_call_instance, commandBuffer, imageView, imageLayout); +} + +void vkCmdBindInvocationMaskHUAWEI_AddCallback(CMOCK_vkCmdBindInvocationMaskHUAWEI_CALLBACK Callback) +{ + Mock.vkCmdBindInvocationMaskHUAWEI_IgnoreBool = (char)0; + Mock.vkCmdBindInvocationMaskHUAWEI_CallbackBool = (char)1; + Mock.vkCmdBindInvocationMaskHUAWEI_CallbackFunctionPointer = Callback; +} + +void vkCmdBindInvocationMaskHUAWEI_Stub(CMOCK_vkCmdBindInvocationMaskHUAWEI_CALLBACK Callback) +{ + Mock.vkCmdBindInvocationMaskHUAWEI_IgnoreBool = (char)0; + Mock.vkCmdBindInvocationMaskHUAWEI_CallbackBool = (char)0; + Mock.vkCmdBindInvocationMaskHUAWEI_CallbackFunctionPointer = Callback; +} + +void vkCmdBindInvocationMaskHUAWEI_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindInvocationMaskHUAWEI_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindInvocationMaskHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindInvocationMaskHUAWEI_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBindInvocationMaskHUAWEI_CMockIgnoreArg_imageView(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindInvocationMaskHUAWEI_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindInvocationMaskHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindInvocationMaskHUAWEI_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_imageView = 1; +} + +void vkCmdBindInvocationMaskHUAWEI_CMockIgnoreArg_imageLayout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindInvocationMaskHUAWEI_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindInvocationMaskHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindInvocationMaskHUAWEI_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_imageLayout = 1; +} + +VkResult vkGetMemoryRemoteAddressNV(VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetMemoryRemoteAddressNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetMemoryRemoteAddressNV); + cmock_call_instance = (CMOCK_vkGetMemoryRemoteAddressNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetMemoryRemoteAddressNV_CallInstance); + Mock.vkGetMemoryRemoteAddressNV_CallInstance = CMock_Guts_MemNext(Mock.vkGetMemoryRemoteAddressNV_CallInstance); + if (Mock.vkGetMemoryRemoteAddressNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetMemoryRemoteAddressNV_FinalReturn; + memcpy((void*)(&Mock.vkGetMemoryRemoteAddressNV_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetMemoryRemoteAddressNV_CallbackBool && + Mock.vkGetMemoryRemoteAddressNV_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetMemoryRemoteAddressNV_CallbackFunctionPointer(device, pMemoryGetRemoteAddressInfo, pAddress, Mock.vkGetMemoryRemoteAddressNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetMemoryRemoteAddressNV,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMemoryGetRemoteAddressInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetMemoryRemoteAddressNV,CMockString_pMemoryGetRemoteAddressInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMemoryGetRemoteAddressInfo), (void*)(pMemoryGetRemoteAddressInfo), sizeof(const VkMemoryGetRemoteAddressInfoNV), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAddress) + { + UNITY_SET_DETAILS(CMockString_vkGetMemoryRemoteAddressNV,CMockString_pAddress); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAddress), (void*)(pAddress), sizeof(VkRemoteAddressNV), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetMemoryRemoteAddressNV_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetMemoryRemoteAddressNV_CallbackFunctionPointer(device, pMemoryGetRemoteAddressInfo, pAddress, Mock.vkGetMemoryRemoteAddressNV_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pAddress_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pAddress, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pAddress, (const void*)cmock_call_instance->ReturnThruPtr_pAddress_Val, + cmock_call_instance->ReturnThruPtr_pAddress_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetMemoryRemoteAddressNV(CMOCK_vkGetMemoryRemoteAddressNV_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress); +void CMockExpectParameters_vkGetMemoryRemoteAddressNV(CMOCK_vkGetMemoryRemoteAddressNV_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pMemoryGetRemoteAddressInfo = pMemoryGetRemoteAddressInfo; + cmock_call_instance->IgnoreArg_pMemoryGetRemoteAddressInfo = 0; + cmock_call_instance->Expected_pAddress = pAddress; + cmock_call_instance->IgnoreArg_pAddress = 0; + cmock_call_instance->ReturnThruPtr_pAddress_Used = 0; +} + +void vkGetMemoryRemoteAddressNV_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetMemoryRemoteAddressNV_CALL_INSTANCE)); + CMOCK_vkGetMemoryRemoteAddressNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMemoryRemoteAddressNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetMemoryRemoteAddressNV_CallInstance = CMock_Guts_MemChain(Mock.vkGetMemoryRemoteAddressNV_CallInstance, cmock_guts_index); + Mock.vkGetMemoryRemoteAddressNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetMemoryRemoteAddressNV_IgnoreBool = (char)1; +} + +void vkGetMemoryRemoteAddressNV_CMockStopIgnore(void) +{ + if(Mock.vkGetMemoryRemoteAddressNV_IgnoreBool) + Mock.vkGetMemoryRemoteAddressNV_CallInstance = CMock_Guts_MemNext(Mock.vkGetMemoryRemoteAddressNV_CallInstance); + Mock.vkGetMemoryRemoteAddressNV_IgnoreBool = (char)0; +} + +void vkGetMemoryRemoteAddressNV_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetMemoryRemoteAddressNV_CALL_INSTANCE)); + CMOCK_vkGetMemoryRemoteAddressNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMemoryRemoteAddressNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetMemoryRemoteAddressNV_CallInstance = CMock_Guts_MemChain(Mock.vkGetMemoryRemoteAddressNV_CallInstance, cmock_guts_index); + Mock.vkGetMemoryRemoteAddressNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetMemoryRemoteAddressNV_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetMemoryRemoteAddressNV_CALL_INSTANCE)); + CMOCK_vkGetMemoryRemoteAddressNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMemoryRemoteAddressNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetMemoryRemoteAddressNV_CallInstance = CMock_Guts_MemChain(Mock.vkGetMemoryRemoteAddressNV_CallInstance, cmock_guts_index); + Mock.vkGetMemoryRemoteAddressNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetMemoryRemoteAddressNV(cmock_call_instance, device, pMemoryGetRemoteAddressInfo, pAddress); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetMemoryRemoteAddressNV_AddCallback(CMOCK_vkGetMemoryRemoteAddressNV_CALLBACK Callback) +{ + Mock.vkGetMemoryRemoteAddressNV_IgnoreBool = (char)0; + Mock.vkGetMemoryRemoteAddressNV_CallbackBool = (char)1; + Mock.vkGetMemoryRemoteAddressNV_CallbackFunctionPointer = Callback; +} + +void vkGetMemoryRemoteAddressNV_Stub(CMOCK_vkGetMemoryRemoteAddressNV_CALLBACK Callback) +{ + Mock.vkGetMemoryRemoteAddressNV_IgnoreBool = (char)0; + Mock.vkGetMemoryRemoteAddressNV_CallbackBool = (char)0; + Mock.vkGetMemoryRemoteAddressNV_CallbackFunctionPointer = Callback; +} + +void vkGetMemoryRemoteAddressNV_CMockReturnMemThruPtr_pAddress(UNITY_LINE_TYPE cmock_line, VkRemoteAddressNV const* pAddress, size_t cmock_size) +{ + CMOCK_vkGetMemoryRemoteAddressNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMemoryRemoteAddressNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetMemoryRemoteAddressNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pAddress_Used = 1; + cmock_call_instance->ReturnThruPtr_pAddress_Val = pAddress; + cmock_call_instance->ReturnThruPtr_pAddress_Size = cmock_size; +} + +void vkGetMemoryRemoteAddressNV_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetMemoryRemoteAddressNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMemoryRemoteAddressNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetMemoryRemoteAddressNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetMemoryRemoteAddressNV_CMockIgnoreArg_pMemoryGetRemoteAddressInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetMemoryRemoteAddressNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMemoryRemoteAddressNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetMemoryRemoteAddressNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMemoryGetRemoteAddressInfo = 1; +} + +void vkGetMemoryRemoteAddressNV_CMockIgnoreArg_pAddress(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetMemoryRemoteAddressNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMemoryRemoteAddressNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetMemoryRemoteAddressNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAddress = 1; +} + +VkResult vkGetPipelinePropertiesEXT(VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPipelinePropertiesEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPipelinePropertiesEXT); + cmock_call_instance = (CMOCK_vkGetPipelinePropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPipelinePropertiesEXT_CallInstance); + Mock.vkGetPipelinePropertiesEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetPipelinePropertiesEXT_CallInstance); + if (Mock.vkGetPipelinePropertiesEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPipelinePropertiesEXT_FinalReturn; + memcpy((void*)(&Mock.vkGetPipelinePropertiesEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPipelinePropertiesEXT_CallbackBool && + Mock.vkGetPipelinePropertiesEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPipelinePropertiesEXT_CallbackFunctionPointer(device, pPipelineInfo, pPipelineProperties, Mock.vkGetPipelinePropertiesEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetPipelinePropertiesEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPipelineInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetPipelinePropertiesEXT,CMockString_pPipelineInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pPipelineInfo), (void*)(pPipelineInfo), sizeof(const VkPipelineInfoEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPipelineProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPipelinePropertiesEXT,CMockString_pPipelineProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pPipelineProperties), (void*)(pPipelineProperties), sizeof(VkBaseOutStructure), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPipelinePropertiesEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPipelinePropertiesEXT_CallbackFunctionPointer(device, pPipelineInfo, pPipelineProperties, Mock.vkGetPipelinePropertiesEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPipelineProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPipelineProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPipelineProperties, (const void*)cmock_call_instance->ReturnThruPtr_pPipelineProperties_Val, + cmock_call_instance->ReturnThruPtr_pPipelineProperties_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPipelinePropertiesEXT(CMOCK_vkGetPipelinePropertiesEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties); +void CMockExpectParameters_vkGetPipelinePropertiesEXT(CMOCK_vkGetPipelinePropertiesEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pPipelineInfo = pPipelineInfo; + cmock_call_instance->IgnoreArg_pPipelineInfo = 0; + cmock_call_instance->Expected_pPipelineProperties = pPipelineProperties; + cmock_call_instance->IgnoreArg_pPipelineProperties = 0; + cmock_call_instance->ReturnThruPtr_pPipelineProperties_Used = 0; +} + +void vkGetPipelinePropertiesEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPipelinePropertiesEXT_CALL_INSTANCE)); + CMOCK_vkGetPipelinePropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelinePropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPipelinePropertiesEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetPipelinePropertiesEXT_CallInstance, cmock_guts_index); + Mock.vkGetPipelinePropertiesEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPipelinePropertiesEXT_IgnoreBool = (char)1; +} + +void vkGetPipelinePropertiesEXT_CMockStopIgnore(void) +{ + if(Mock.vkGetPipelinePropertiesEXT_IgnoreBool) + Mock.vkGetPipelinePropertiesEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetPipelinePropertiesEXT_CallInstance); + Mock.vkGetPipelinePropertiesEXT_IgnoreBool = (char)0; +} + +void vkGetPipelinePropertiesEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPipelinePropertiesEXT_CALL_INSTANCE)); + CMOCK_vkGetPipelinePropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelinePropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPipelinePropertiesEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetPipelinePropertiesEXT_CallInstance, cmock_guts_index); + Mock.vkGetPipelinePropertiesEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPipelinePropertiesEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPipelinePropertiesEXT_CALL_INSTANCE)); + CMOCK_vkGetPipelinePropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelinePropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPipelinePropertiesEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetPipelinePropertiesEXT_CallInstance, cmock_guts_index); + Mock.vkGetPipelinePropertiesEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPipelinePropertiesEXT(cmock_call_instance, device, pPipelineInfo, pPipelineProperties); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPipelinePropertiesEXT_AddCallback(CMOCK_vkGetPipelinePropertiesEXT_CALLBACK Callback) +{ + Mock.vkGetPipelinePropertiesEXT_IgnoreBool = (char)0; + Mock.vkGetPipelinePropertiesEXT_CallbackBool = (char)1; + Mock.vkGetPipelinePropertiesEXT_CallbackFunctionPointer = Callback; +} + +void vkGetPipelinePropertiesEXT_Stub(CMOCK_vkGetPipelinePropertiesEXT_CALLBACK Callback) +{ + Mock.vkGetPipelinePropertiesEXT_IgnoreBool = (char)0; + Mock.vkGetPipelinePropertiesEXT_CallbackBool = (char)0; + Mock.vkGetPipelinePropertiesEXT_CallbackFunctionPointer = Callback; +} + +void vkGetPipelinePropertiesEXT_CMockReturnMemThruPtr_pPipelineProperties(UNITY_LINE_TYPE cmock_line, VkBaseOutStructure const* pPipelineProperties, size_t cmock_size) +{ + CMOCK_vkGetPipelinePropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelinePropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPipelinePropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPipelineProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pPipelineProperties_Val = pPipelineProperties; + cmock_call_instance->ReturnThruPtr_pPipelineProperties_Size = cmock_size; +} + +void vkGetPipelinePropertiesEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPipelinePropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelinePropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPipelinePropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetPipelinePropertiesEXT_CMockIgnoreArg_pPipelineInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPipelinePropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelinePropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPipelinePropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPipelineInfo = 1; +} + +void vkGetPipelinePropertiesEXT_CMockIgnoreArg_pPipelineProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPipelinePropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPipelinePropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPipelinePropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPipelineProperties = 1; +} + +void vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetPatchControlPointsEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetPatchControlPointsEXT); + cmock_call_instance = (CMOCK_vkCmdSetPatchControlPointsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetPatchControlPointsEXT_CallInstance); + Mock.vkCmdSetPatchControlPointsEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetPatchControlPointsEXT_CallInstance); + if (Mock.vkCmdSetPatchControlPointsEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetPatchControlPointsEXT_CallbackBool && + Mock.vkCmdSetPatchControlPointsEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetPatchControlPointsEXT_CallbackFunctionPointer(commandBuffer, patchControlPoints, Mock.vkCmdSetPatchControlPointsEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetPatchControlPointsEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_patchControlPoints) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetPatchControlPointsEXT,CMockString_patchControlPoints); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_patchControlPoints, patchControlPoints, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetPatchControlPointsEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetPatchControlPointsEXT_CallbackFunctionPointer(commandBuffer, patchControlPoints, Mock.vkCmdSetPatchControlPointsEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetPatchControlPointsEXT(CMOCK_vkCmdSetPatchControlPointsEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t patchControlPoints); +void CMockExpectParameters_vkCmdSetPatchControlPointsEXT(CMOCK_vkCmdSetPatchControlPointsEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t patchControlPoints) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_patchControlPoints = patchControlPoints; + cmock_call_instance->IgnoreArg_patchControlPoints = 0; +} + +void vkCmdSetPatchControlPointsEXT_CMockIgnore(void) +{ + Mock.vkCmdSetPatchControlPointsEXT_IgnoreBool = (char)1; +} + +void vkCmdSetPatchControlPointsEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetPatchControlPointsEXT_IgnoreBool = (char)0; +} + +void vkCmdSetPatchControlPointsEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetPatchControlPointsEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetPatchControlPointsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPatchControlPointsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetPatchControlPointsEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetPatchControlPointsEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetPatchControlPointsEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetPatchControlPointsEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t patchControlPoints) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetPatchControlPointsEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetPatchControlPointsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPatchControlPointsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetPatchControlPointsEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetPatchControlPointsEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetPatchControlPointsEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetPatchControlPointsEXT(cmock_call_instance, commandBuffer, patchControlPoints); +} + +void vkCmdSetPatchControlPointsEXT_AddCallback(CMOCK_vkCmdSetPatchControlPointsEXT_CALLBACK Callback) +{ + Mock.vkCmdSetPatchControlPointsEXT_IgnoreBool = (char)0; + Mock.vkCmdSetPatchControlPointsEXT_CallbackBool = (char)1; + Mock.vkCmdSetPatchControlPointsEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetPatchControlPointsEXT_Stub(CMOCK_vkCmdSetPatchControlPointsEXT_CALLBACK Callback) +{ + Mock.vkCmdSetPatchControlPointsEXT_IgnoreBool = (char)0; + Mock.vkCmdSetPatchControlPointsEXT_CallbackBool = (char)0; + Mock.vkCmdSetPatchControlPointsEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetPatchControlPointsEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetPatchControlPointsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPatchControlPointsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetPatchControlPointsEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetPatchControlPointsEXT_CMockIgnoreArg_patchControlPoints(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetPatchControlPointsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPatchControlPointsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetPatchControlPointsEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_patchControlPoints = 1; +} + +void vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetRasterizerDiscardEnableEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetRasterizerDiscardEnableEXT); + cmock_call_instance = (CMOCK_vkCmdSetRasterizerDiscardEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetRasterizerDiscardEnableEXT_CallInstance); + Mock.vkCmdSetRasterizerDiscardEnableEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetRasterizerDiscardEnableEXT_CallInstance); + if (Mock.vkCmdSetRasterizerDiscardEnableEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetRasterizerDiscardEnableEXT_CallbackBool && + Mock.vkCmdSetRasterizerDiscardEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetRasterizerDiscardEnableEXT_CallbackFunctionPointer(commandBuffer, rasterizerDiscardEnable, Mock.vkCmdSetRasterizerDiscardEnableEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetRasterizerDiscardEnableEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_rasterizerDiscardEnable) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetRasterizerDiscardEnableEXT,CMockString_rasterizerDiscardEnable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_rasterizerDiscardEnable), (void*)(&rasterizerDiscardEnable), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetRasterizerDiscardEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetRasterizerDiscardEnableEXT_CallbackFunctionPointer(commandBuffer, rasterizerDiscardEnable, Mock.vkCmdSetRasterizerDiscardEnableEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetRasterizerDiscardEnableEXT(CMOCK_vkCmdSetRasterizerDiscardEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); +void CMockExpectParameters_vkCmdSetRasterizerDiscardEnableEXT(CMOCK_vkCmdSetRasterizerDiscardEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_rasterizerDiscardEnable), (void*)(&rasterizerDiscardEnable), + sizeof(VkBool32[sizeof(rasterizerDiscardEnable) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_rasterizerDiscardEnable = 0; +} + +void vkCmdSetRasterizerDiscardEnableEXT_CMockIgnore(void) +{ + Mock.vkCmdSetRasterizerDiscardEnableEXT_IgnoreBool = (char)1; +} + +void vkCmdSetRasterizerDiscardEnableEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetRasterizerDiscardEnableEXT_IgnoreBool = (char)0; +} + +void vkCmdSetRasterizerDiscardEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetRasterizerDiscardEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetRasterizerDiscardEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetRasterizerDiscardEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetRasterizerDiscardEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetRasterizerDiscardEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetRasterizerDiscardEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetRasterizerDiscardEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetRasterizerDiscardEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetRasterizerDiscardEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetRasterizerDiscardEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetRasterizerDiscardEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetRasterizerDiscardEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetRasterizerDiscardEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetRasterizerDiscardEnableEXT(cmock_call_instance, commandBuffer, rasterizerDiscardEnable); +} + +void vkCmdSetRasterizerDiscardEnableEXT_AddCallback(CMOCK_vkCmdSetRasterizerDiscardEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetRasterizerDiscardEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetRasterizerDiscardEnableEXT_CallbackBool = (char)1; + Mock.vkCmdSetRasterizerDiscardEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetRasterizerDiscardEnableEXT_Stub(CMOCK_vkCmdSetRasterizerDiscardEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetRasterizerDiscardEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetRasterizerDiscardEnableEXT_CallbackBool = (char)0; + Mock.vkCmdSetRasterizerDiscardEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetRasterizerDiscardEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetRasterizerDiscardEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetRasterizerDiscardEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetRasterizerDiscardEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetRasterizerDiscardEnableEXT_CMockIgnoreArg_rasterizerDiscardEnable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetRasterizerDiscardEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetRasterizerDiscardEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetRasterizerDiscardEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_rasterizerDiscardEnable = 1; +} + +void vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetDepthBiasEnableEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetDepthBiasEnableEXT); + cmock_call_instance = (CMOCK_vkCmdSetDepthBiasEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetDepthBiasEnableEXT_CallInstance); + Mock.vkCmdSetDepthBiasEnableEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetDepthBiasEnableEXT_CallInstance); + if (Mock.vkCmdSetDepthBiasEnableEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetDepthBiasEnableEXT_CallbackBool && + Mock.vkCmdSetDepthBiasEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDepthBiasEnableEXT_CallbackFunctionPointer(commandBuffer, depthBiasEnable, Mock.vkCmdSetDepthBiasEnableEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthBiasEnableEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_depthBiasEnable) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthBiasEnableEXT,CMockString_depthBiasEnable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_depthBiasEnable), (void*)(&depthBiasEnable), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetDepthBiasEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDepthBiasEnableEXT_CallbackFunctionPointer(commandBuffer, depthBiasEnable, Mock.vkCmdSetDepthBiasEnableEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetDepthBiasEnableEXT(CMOCK_vkCmdSetDepthBiasEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable); +void CMockExpectParameters_vkCmdSetDepthBiasEnableEXT(CMOCK_vkCmdSetDepthBiasEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_depthBiasEnable), (void*)(&depthBiasEnable), + sizeof(VkBool32[sizeof(depthBiasEnable) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_depthBiasEnable = 0; +} + +void vkCmdSetDepthBiasEnableEXT_CMockIgnore(void) +{ + Mock.vkCmdSetDepthBiasEnableEXT_IgnoreBool = (char)1; +} + +void vkCmdSetDepthBiasEnableEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetDepthBiasEnableEXT_IgnoreBool = (char)0; +} + +void vkCmdSetDepthBiasEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDepthBiasEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetDepthBiasEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthBiasEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDepthBiasEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDepthBiasEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetDepthBiasEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetDepthBiasEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDepthBiasEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetDepthBiasEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthBiasEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDepthBiasEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDepthBiasEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetDepthBiasEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetDepthBiasEnableEXT(cmock_call_instance, commandBuffer, depthBiasEnable); +} + +void vkCmdSetDepthBiasEnableEXT_AddCallback(CMOCK_vkCmdSetDepthBiasEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetDepthBiasEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetDepthBiasEnableEXT_CallbackBool = (char)1; + Mock.vkCmdSetDepthBiasEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDepthBiasEnableEXT_Stub(CMOCK_vkCmdSetDepthBiasEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetDepthBiasEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetDepthBiasEnableEXT_CallbackBool = (char)0; + Mock.vkCmdSetDepthBiasEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDepthBiasEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthBiasEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthBiasEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthBiasEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetDepthBiasEnableEXT_CMockIgnoreArg_depthBiasEnable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthBiasEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthBiasEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthBiasEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_depthBiasEnable = 1; +} + +void vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetLogicOpEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetLogicOpEXT); + cmock_call_instance = (CMOCK_vkCmdSetLogicOpEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetLogicOpEXT_CallInstance); + Mock.vkCmdSetLogicOpEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetLogicOpEXT_CallInstance); + if (Mock.vkCmdSetLogicOpEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetLogicOpEXT_CallbackBool && + Mock.vkCmdSetLogicOpEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetLogicOpEXT_CallbackFunctionPointer(commandBuffer, logicOp, Mock.vkCmdSetLogicOpEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetLogicOpEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_logicOp) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetLogicOpEXT,CMockString_logicOp); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_logicOp), (void*)(&logicOp), sizeof(VkLogicOp), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetLogicOpEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetLogicOpEXT_CallbackFunctionPointer(commandBuffer, logicOp, Mock.vkCmdSetLogicOpEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetLogicOpEXT(CMOCK_vkCmdSetLogicOpEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkLogicOp logicOp); +void CMockExpectParameters_vkCmdSetLogicOpEXT(CMOCK_vkCmdSetLogicOpEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkLogicOp logicOp) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_logicOp), (void*)(&logicOp), + sizeof(VkLogicOp[sizeof(logicOp) == sizeof(VkLogicOp) ? 1 : -1])); /* add VkLogicOp to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_logicOp = 0; +} + +void vkCmdSetLogicOpEXT_CMockIgnore(void) +{ + Mock.vkCmdSetLogicOpEXT_IgnoreBool = (char)1; +} + +void vkCmdSetLogicOpEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetLogicOpEXT_IgnoreBool = (char)0; +} + +void vkCmdSetLogicOpEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetLogicOpEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetLogicOpEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetLogicOpEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetLogicOpEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetLogicOpEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetLogicOpEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetLogicOpEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkLogicOp logicOp) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetLogicOpEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetLogicOpEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetLogicOpEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetLogicOpEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetLogicOpEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetLogicOpEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetLogicOpEXT(cmock_call_instance, commandBuffer, logicOp); +} + +void vkCmdSetLogicOpEXT_AddCallback(CMOCK_vkCmdSetLogicOpEXT_CALLBACK Callback) +{ + Mock.vkCmdSetLogicOpEXT_IgnoreBool = (char)0; + Mock.vkCmdSetLogicOpEXT_CallbackBool = (char)1; + Mock.vkCmdSetLogicOpEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetLogicOpEXT_Stub(CMOCK_vkCmdSetLogicOpEXT_CALLBACK Callback) +{ + Mock.vkCmdSetLogicOpEXT_IgnoreBool = (char)0; + Mock.vkCmdSetLogicOpEXT_CallbackBool = (char)0; + Mock.vkCmdSetLogicOpEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetLogicOpEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetLogicOpEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetLogicOpEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetLogicOpEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetLogicOpEXT_CMockIgnoreArg_logicOp(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetLogicOpEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetLogicOpEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetLogicOpEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_logicOp = 1; +} + +void vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetPrimitiveRestartEnableEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetPrimitiveRestartEnableEXT); + cmock_call_instance = (CMOCK_vkCmdSetPrimitiveRestartEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetPrimitiveRestartEnableEXT_CallInstance); + Mock.vkCmdSetPrimitiveRestartEnableEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetPrimitiveRestartEnableEXT_CallInstance); + if (Mock.vkCmdSetPrimitiveRestartEnableEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetPrimitiveRestartEnableEXT_CallbackBool && + Mock.vkCmdSetPrimitiveRestartEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetPrimitiveRestartEnableEXT_CallbackFunctionPointer(commandBuffer, primitiveRestartEnable, Mock.vkCmdSetPrimitiveRestartEnableEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetPrimitiveRestartEnableEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_primitiveRestartEnable) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetPrimitiveRestartEnableEXT,CMockString_primitiveRestartEnable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_primitiveRestartEnable), (void*)(&primitiveRestartEnable), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetPrimitiveRestartEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetPrimitiveRestartEnableEXT_CallbackFunctionPointer(commandBuffer, primitiveRestartEnable, Mock.vkCmdSetPrimitiveRestartEnableEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetPrimitiveRestartEnableEXT(CMOCK_vkCmdSetPrimitiveRestartEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); +void CMockExpectParameters_vkCmdSetPrimitiveRestartEnableEXT(CMOCK_vkCmdSetPrimitiveRestartEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_primitiveRestartEnable), (void*)(&primitiveRestartEnable), + sizeof(VkBool32[sizeof(primitiveRestartEnable) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_primitiveRestartEnable = 0; +} + +void vkCmdSetPrimitiveRestartEnableEXT_CMockIgnore(void) +{ + Mock.vkCmdSetPrimitiveRestartEnableEXT_IgnoreBool = (char)1; +} + +void vkCmdSetPrimitiveRestartEnableEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetPrimitiveRestartEnableEXT_IgnoreBool = (char)0; +} + +void vkCmdSetPrimitiveRestartEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetPrimitiveRestartEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetPrimitiveRestartEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPrimitiveRestartEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetPrimitiveRestartEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetPrimitiveRestartEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetPrimitiveRestartEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetPrimitiveRestartEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetPrimitiveRestartEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetPrimitiveRestartEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPrimitiveRestartEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetPrimitiveRestartEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetPrimitiveRestartEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetPrimitiveRestartEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetPrimitiveRestartEnableEXT(cmock_call_instance, commandBuffer, primitiveRestartEnable); +} + +void vkCmdSetPrimitiveRestartEnableEXT_AddCallback(CMOCK_vkCmdSetPrimitiveRestartEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetPrimitiveRestartEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetPrimitiveRestartEnableEXT_CallbackBool = (char)1; + Mock.vkCmdSetPrimitiveRestartEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetPrimitiveRestartEnableEXT_Stub(CMOCK_vkCmdSetPrimitiveRestartEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetPrimitiveRestartEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetPrimitiveRestartEnableEXT_CallbackBool = (char)0; + Mock.vkCmdSetPrimitiveRestartEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetPrimitiveRestartEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetPrimitiveRestartEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPrimitiveRestartEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetPrimitiveRestartEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetPrimitiveRestartEnableEXT_CMockIgnoreArg_primitiveRestartEnable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetPrimitiveRestartEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPrimitiveRestartEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetPrimitiveRestartEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_primitiveRestartEnable = 1; +} + +void vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetColorWriteEnableEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetColorWriteEnableEXT); + cmock_call_instance = (CMOCK_vkCmdSetColorWriteEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetColorWriteEnableEXT_CallInstance); + Mock.vkCmdSetColorWriteEnableEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetColorWriteEnableEXT_CallInstance); + if (Mock.vkCmdSetColorWriteEnableEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetColorWriteEnableEXT_CallbackBool && + Mock.vkCmdSetColorWriteEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetColorWriteEnableEXT_CallbackFunctionPointer(commandBuffer, attachmentCount, pColorWriteEnables, Mock.vkCmdSetColorWriteEnableEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetColorWriteEnableEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_attachmentCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetColorWriteEnableEXT,CMockString_attachmentCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_attachmentCount, attachmentCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pColorWriteEnables) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetColorWriteEnableEXT,CMockString_pColorWriteEnables); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pColorWriteEnables), (void*)(pColorWriteEnables), sizeof(const VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetColorWriteEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetColorWriteEnableEXT_CallbackFunctionPointer(commandBuffer, attachmentCount, pColorWriteEnables, Mock.vkCmdSetColorWriteEnableEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetColorWriteEnableEXT(CMOCK_vkCmdSetColorWriteEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables); +void CMockExpectParameters_vkCmdSetColorWriteEnableEXT(CMOCK_vkCmdSetColorWriteEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_attachmentCount = attachmentCount; + cmock_call_instance->IgnoreArg_attachmentCount = 0; + cmock_call_instance->Expected_pColorWriteEnables = pColorWriteEnables; + cmock_call_instance->IgnoreArg_pColorWriteEnables = 0; +} + +void vkCmdSetColorWriteEnableEXT_CMockIgnore(void) +{ + Mock.vkCmdSetColorWriteEnableEXT_IgnoreBool = (char)1; +} + +void vkCmdSetColorWriteEnableEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetColorWriteEnableEXT_IgnoreBool = (char)0; +} + +void vkCmdSetColorWriteEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetColorWriteEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetColorWriteEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetColorWriteEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetColorWriteEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetColorWriteEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetColorWriteEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetColorWriteEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetColorWriteEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetColorWriteEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetColorWriteEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetColorWriteEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetColorWriteEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetColorWriteEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetColorWriteEnableEXT(cmock_call_instance, commandBuffer, attachmentCount, pColorWriteEnables); +} + +void vkCmdSetColorWriteEnableEXT_AddCallback(CMOCK_vkCmdSetColorWriteEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetColorWriteEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetColorWriteEnableEXT_CallbackBool = (char)1; + Mock.vkCmdSetColorWriteEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetColorWriteEnableEXT_Stub(CMOCK_vkCmdSetColorWriteEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetColorWriteEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetColorWriteEnableEXT_CallbackBool = (char)0; + Mock.vkCmdSetColorWriteEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetColorWriteEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetColorWriteEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetColorWriteEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetColorWriteEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetColorWriteEnableEXT_CMockIgnoreArg_attachmentCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetColorWriteEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetColorWriteEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetColorWriteEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_attachmentCount = 1; +} + +void vkCmdSetColorWriteEnableEXT_CMockIgnoreArg_pColorWriteEnables(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetColorWriteEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetColorWriteEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetColorWriteEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pColorWriteEnables = 1; +} + +void vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDrawMultiEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDrawMultiEXT); + cmock_call_instance = (CMOCK_vkCmdDrawMultiEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDrawMultiEXT_CallInstance); + Mock.vkCmdDrawMultiEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDrawMultiEXT_CallInstance); + if (Mock.vkCmdDrawMultiEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDrawMultiEXT_CallbackBool && + Mock.vkCmdDrawMultiEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawMultiEXT_CallbackFunctionPointer(commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride, Mock.vkCmdDrawMultiEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMultiEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_drawCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMultiEXT,CMockString_drawCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_drawCount, drawCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pVertexInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMultiEXT,CMockString_pVertexInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pVertexInfo), (void*)(pVertexInfo), sizeof(const VkMultiDrawInfoEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_instanceCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMultiEXT,CMockString_instanceCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_instanceCount, instanceCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstInstance) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMultiEXT,CMockString_firstInstance); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstInstance, firstInstance, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_stride) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMultiEXT,CMockString_stride); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_stride, stride, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdDrawMultiEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawMultiEXT_CallbackFunctionPointer(commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride, Mock.vkCmdDrawMultiEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDrawMultiEXT(CMOCK_vkCmdDrawMultiEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride); +void CMockExpectParameters_vkCmdDrawMultiEXT(CMOCK_vkCmdDrawMultiEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_drawCount = drawCount; + cmock_call_instance->IgnoreArg_drawCount = 0; + cmock_call_instance->Expected_pVertexInfo = pVertexInfo; + cmock_call_instance->IgnoreArg_pVertexInfo = 0; + cmock_call_instance->Expected_instanceCount = instanceCount; + cmock_call_instance->IgnoreArg_instanceCount = 0; + cmock_call_instance->Expected_firstInstance = firstInstance; + cmock_call_instance->IgnoreArg_firstInstance = 0; + cmock_call_instance->Expected_stride = stride; + cmock_call_instance->IgnoreArg_stride = 0; +} + +void vkCmdDrawMultiEXT_CMockIgnore(void) +{ + Mock.vkCmdDrawMultiEXT_IgnoreBool = (char)1; +} + +void vkCmdDrawMultiEXT_CMockStopIgnore(void) +{ + Mock.vkCmdDrawMultiEXT_IgnoreBool = (char)0; +} + +void vkCmdDrawMultiEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawMultiEXT_CALL_INSTANCE)); + CMOCK_vkCmdDrawMultiEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMultiEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawMultiEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawMultiEXT_CallInstance, cmock_guts_index); + Mock.vkCmdDrawMultiEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDrawMultiEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawMultiEXT_CALL_INSTANCE)); + CMOCK_vkCmdDrawMultiEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMultiEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawMultiEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawMultiEXT_CallInstance, cmock_guts_index); + Mock.vkCmdDrawMultiEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDrawMultiEXT(cmock_call_instance, commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride); +} + +void vkCmdDrawMultiEXT_AddCallback(CMOCK_vkCmdDrawMultiEXT_CALLBACK Callback) +{ + Mock.vkCmdDrawMultiEXT_IgnoreBool = (char)0; + Mock.vkCmdDrawMultiEXT_CallbackBool = (char)1; + Mock.vkCmdDrawMultiEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawMultiEXT_Stub(CMOCK_vkCmdDrawMultiEXT_CALLBACK Callback) +{ + Mock.vkCmdDrawMultiEXT_IgnoreBool = (char)0; + Mock.vkCmdDrawMultiEXT_CallbackBool = (char)0; + Mock.vkCmdDrawMultiEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawMultiEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMultiEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMultiEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMultiEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDrawMultiEXT_CMockIgnoreArg_drawCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMultiEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMultiEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMultiEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_drawCount = 1; +} + +void vkCmdDrawMultiEXT_CMockIgnoreArg_pVertexInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMultiEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMultiEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMultiEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pVertexInfo = 1; +} + +void vkCmdDrawMultiEXT_CMockIgnoreArg_instanceCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMultiEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMultiEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMultiEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_instanceCount = 1; +} + +void vkCmdDrawMultiEXT_CMockIgnoreArg_firstInstance(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMultiEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMultiEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMultiEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstInstance = 1; +} + +void vkCmdDrawMultiEXT_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMultiEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMultiEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMultiEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stride = 1; +} + +void vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDrawMultiIndexedEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDrawMultiIndexedEXT); + cmock_call_instance = (CMOCK_vkCmdDrawMultiIndexedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDrawMultiIndexedEXT_CallInstance); + Mock.vkCmdDrawMultiIndexedEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDrawMultiIndexedEXT_CallInstance); + if (Mock.vkCmdDrawMultiIndexedEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDrawMultiIndexedEXT_CallbackBool && + Mock.vkCmdDrawMultiIndexedEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawMultiIndexedEXT_CallbackFunctionPointer(commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset, Mock.vkCmdDrawMultiIndexedEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMultiIndexedEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_drawCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMultiIndexedEXT,CMockString_drawCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_drawCount, drawCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pIndexInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMultiIndexedEXT,CMockString_pIndexInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pIndexInfo), (void*)(pIndexInfo), sizeof(const VkMultiDrawIndexedInfoEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_instanceCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMultiIndexedEXT,CMockString_instanceCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_instanceCount, instanceCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstInstance) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMultiIndexedEXT,CMockString_firstInstance); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstInstance, firstInstance, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_stride) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMultiIndexedEXT,CMockString_stride); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_stride, stride, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pVertexOffset) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMultiIndexedEXT,CMockString_pVertexOffset); + if (cmock_call_instance->Expected_pVertexOffset == NULL) + { UNITY_TEST_ASSERT_NULL(pVertexOffset, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_INT_ARRAY(cmock_call_instance->Expected_pVertexOffset, pVertexOffset, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkCmdDrawMultiIndexedEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawMultiIndexedEXT_CallbackFunctionPointer(commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset, Mock.vkCmdDrawMultiIndexedEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDrawMultiIndexedEXT(CMOCK_vkCmdDrawMultiIndexedEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset); +void CMockExpectParameters_vkCmdDrawMultiIndexedEXT(CMOCK_vkCmdDrawMultiIndexedEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_drawCount = drawCount; + cmock_call_instance->IgnoreArg_drawCount = 0; + cmock_call_instance->Expected_pIndexInfo = pIndexInfo; + cmock_call_instance->IgnoreArg_pIndexInfo = 0; + cmock_call_instance->Expected_instanceCount = instanceCount; + cmock_call_instance->IgnoreArg_instanceCount = 0; + cmock_call_instance->Expected_firstInstance = firstInstance; + cmock_call_instance->IgnoreArg_firstInstance = 0; + cmock_call_instance->Expected_stride = stride; + cmock_call_instance->IgnoreArg_stride = 0; + cmock_call_instance->Expected_pVertexOffset = pVertexOffset; + cmock_call_instance->IgnoreArg_pVertexOffset = 0; +} + +void vkCmdDrawMultiIndexedEXT_CMockIgnore(void) +{ + Mock.vkCmdDrawMultiIndexedEXT_IgnoreBool = (char)1; +} + +void vkCmdDrawMultiIndexedEXT_CMockStopIgnore(void) +{ + Mock.vkCmdDrawMultiIndexedEXT_IgnoreBool = (char)0; +} + +void vkCmdDrawMultiIndexedEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawMultiIndexedEXT_CALL_INSTANCE)); + CMOCK_vkCmdDrawMultiIndexedEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMultiIndexedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawMultiIndexedEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawMultiIndexedEXT_CallInstance, cmock_guts_index); + Mock.vkCmdDrawMultiIndexedEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDrawMultiIndexedEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawMultiIndexedEXT_CALL_INSTANCE)); + CMOCK_vkCmdDrawMultiIndexedEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMultiIndexedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawMultiIndexedEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawMultiIndexedEXT_CallInstance, cmock_guts_index); + Mock.vkCmdDrawMultiIndexedEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDrawMultiIndexedEXT(cmock_call_instance, commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset); +} + +void vkCmdDrawMultiIndexedEXT_AddCallback(CMOCK_vkCmdDrawMultiIndexedEXT_CALLBACK Callback) +{ + Mock.vkCmdDrawMultiIndexedEXT_IgnoreBool = (char)0; + Mock.vkCmdDrawMultiIndexedEXT_CallbackBool = (char)1; + Mock.vkCmdDrawMultiIndexedEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawMultiIndexedEXT_Stub(CMOCK_vkCmdDrawMultiIndexedEXT_CALLBACK Callback) +{ + Mock.vkCmdDrawMultiIndexedEXT_IgnoreBool = (char)0; + Mock.vkCmdDrawMultiIndexedEXT_CallbackBool = (char)0; + Mock.vkCmdDrawMultiIndexedEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawMultiIndexedEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMultiIndexedEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMultiIndexedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMultiIndexedEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDrawMultiIndexedEXT_CMockIgnoreArg_drawCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMultiIndexedEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMultiIndexedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMultiIndexedEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_drawCount = 1; +} + +void vkCmdDrawMultiIndexedEXT_CMockIgnoreArg_pIndexInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMultiIndexedEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMultiIndexedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMultiIndexedEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pIndexInfo = 1; +} + +void vkCmdDrawMultiIndexedEXT_CMockIgnoreArg_instanceCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMultiIndexedEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMultiIndexedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMultiIndexedEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_instanceCount = 1; +} + +void vkCmdDrawMultiIndexedEXT_CMockIgnoreArg_firstInstance(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMultiIndexedEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMultiIndexedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMultiIndexedEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstInstance = 1; +} + +void vkCmdDrawMultiIndexedEXT_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMultiIndexedEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMultiIndexedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMultiIndexedEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stride = 1; +} + +void vkCmdDrawMultiIndexedEXT_CMockIgnoreArg_pVertexOffset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMultiIndexedEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMultiIndexedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMultiIndexedEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pVertexOffset = 1; +} + +VkResult vkCreateMicromapEXT(VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateMicromapEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateMicromapEXT); + cmock_call_instance = (CMOCK_vkCreateMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateMicromapEXT_CallInstance); + Mock.vkCreateMicromapEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCreateMicromapEXT_CallInstance); + if (Mock.vkCreateMicromapEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateMicromapEXT_FinalReturn; + memcpy((void*)(&Mock.vkCreateMicromapEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateMicromapEXT_CallbackBool && + Mock.vkCreateMicromapEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateMicromapEXT_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pMicromap, Mock.vkCreateMicromapEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateMicromapEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateMicromapEXT,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkMicromapCreateInfoEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateMicromapEXT,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMicromap) + { + UNITY_SET_DETAILS(CMockString_vkCreateMicromapEXT,CMockString_pMicromap); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMicromap), (void*)(pMicromap), sizeof(VkMicromapEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateMicromapEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateMicromapEXT_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pMicromap, Mock.vkCreateMicromapEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pMicromap_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pMicromap, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pMicromap, (const void*)cmock_call_instance->ReturnThruPtr_pMicromap_Val, + cmock_call_instance->ReturnThruPtr_pMicromap_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateMicromapEXT(CMOCK_vkCreateMicromapEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap); +void CMockExpectParameters_vkCreateMicromapEXT(CMOCK_vkCreateMicromapEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pMicromap = pMicromap; + cmock_call_instance->IgnoreArg_pMicromap = 0; + cmock_call_instance->ReturnThruPtr_pMicromap_Used = 0; +} + +void vkCreateMicromapEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateMicromapEXT_CALL_INSTANCE)); + CMOCK_vkCreateMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateMicromapEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCreateMicromapEXT_CallInstance, cmock_guts_index); + Mock.vkCreateMicromapEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateMicromapEXT_IgnoreBool = (char)1; +} + +void vkCreateMicromapEXT_CMockStopIgnore(void) +{ + if(Mock.vkCreateMicromapEXT_IgnoreBool) + Mock.vkCreateMicromapEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCreateMicromapEXT_CallInstance); + Mock.vkCreateMicromapEXT_IgnoreBool = (char)0; +} + +void vkCreateMicromapEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateMicromapEXT_CALL_INSTANCE)); + CMOCK_vkCreateMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateMicromapEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCreateMicromapEXT_CallInstance, cmock_guts_index); + Mock.vkCreateMicromapEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateMicromapEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateMicromapEXT_CALL_INSTANCE)); + CMOCK_vkCreateMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateMicromapEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCreateMicromapEXT_CallInstance, cmock_guts_index); + Mock.vkCreateMicromapEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateMicromapEXT(cmock_call_instance, device, pCreateInfo, pAllocator, pMicromap); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateMicromapEXT_AddCallback(CMOCK_vkCreateMicromapEXT_CALLBACK Callback) +{ + Mock.vkCreateMicromapEXT_IgnoreBool = (char)0; + Mock.vkCreateMicromapEXT_CallbackBool = (char)1; + Mock.vkCreateMicromapEXT_CallbackFunctionPointer = Callback; +} + +void vkCreateMicromapEXT_Stub(CMOCK_vkCreateMicromapEXT_CALLBACK Callback) +{ + Mock.vkCreateMicromapEXT_IgnoreBool = (char)0; + Mock.vkCreateMicromapEXT_CallbackBool = (char)0; + Mock.vkCreateMicromapEXT_CallbackFunctionPointer = Callback; +} + +void vkCreateMicromapEXT_CMockReturnMemThruPtr_pMicromap(UNITY_LINE_TYPE cmock_line, VkMicromapEXT const* pMicromap, size_t cmock_size) +{ + CMOCK_vkCreateMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateMicromapEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pMicromap_Used = 1; + cmock_call_instance->ReturnThruPtr_pMicromap_Val = pMicromap; + cmock_call_instance->ReturnThruPtr_pMicromap_Size = cmock_size; +} + +void vkCreateMicromapEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateMicromapEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateMicromapEXT_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateMicromapEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateMicromapEXT_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateMicromapEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateMicromapEXT_CMockIgnoreArg_pMicromap(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateMicromapEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMicromap = 1; +} + +void vkDestroyMicromapEXT(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyMicromapEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyMicromapEXT); + cmock_call_instance = (CMOCK_vkDestroyMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyMicromapEXT_CallInstance); + Mock.vkDestroyMicromapEXT_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyMicromapEXT_CallInstance); + if (Mock.vkDestroyMicromapEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyMicromapEXT_CallbackBool && + Mock.vkDestroyMicromapEXT_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyMicromapEXT_CallbackFunctionPointer(device, micromap, pAllocator, Mock.vkDestroyMicromapEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyMicromapEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_micromap) + { + UNITY_SET_DETAILS(CMockString_vkDestroyMicromapEXT,CMockString_micromap); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_micromap), (void*)(µmap), sizeof(VkMicromapEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyMicromapEXT,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyMicromapEXT_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyMicromapEXT_CallbackFunctionPointer(device, micromap, pAllocator, Mock.vkDestroyMicromapEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyMicromapEXT(CMOCK_vkDestroyMicromapEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyMicromapEXT(CMOCK_vkDestroyMicromapEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_micromap), (void*)(µmap), + sizeof(VkMicromapEXT[sizeof(micromap) == sizeof(VkMicromapEXT) ? 1 : -1])); /* add VkMicromapEXT to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_micromap = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyMicromapEXT_CMockIgnore(void) +{ + Mock.vkDestroyMicromapEXT_IgnoreBool = (char)1; +} + +void vkDestroyMicromapEXT_CMockStopIgnore(void) +{ + Mock.vkDestroyMicromapEXT_IgnoreBool = (char)0; +} + +void vkDestroyMicromapEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyMicromapEXT_CALL_INSTANCE)); + CMOCK_vkDestroyMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyMicromapEXT_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyMicromapEXT_CallInstance, cmock_guts_index); + Mock.vkDestroyMicromapEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyMicromapEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyMicromapEXT_CALL_INSTANCE)); + CMOCK_vkDestroyMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyMicromapEXT_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyMicromapEXT_CallInstance, cmock_guts_index); + Mock.vkDestroyMicromapEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyMicromapEXT(cmock_call_instance, device, micromap, pAllocator); +} + +void vkDestroyMicromapEXT_AddCallback(CMOCK_vkDestroyMicromapEXT_CALLBACK Callback) +{ + Mock.vkDestroyMicromapEXT_IgnoreBool = (char)0; + Mock.vkDestroyMicromapEXT_CallbackBool = (char)1; + Mock.vkDestroyMicromapEXT_CallbackFunctionPointer = Callback; +} + +void vkDestroyMicromapEXT_Stub(CMOCK_vkDestroyMicromapEXT_CALLBACK Callback) +{ + Mock.vkDestroyMicromapEXT_IgnoreBool = (char)0; + Mock.vkDestroyMicromapEXT_CallbackBool = (char)0; + Mock.vkDestroyMicromapEXT_CallbackFunctionPointer = Callback; +} + +void vkDestroyMicromapEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyMicromapEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyMicromapEXT_CMockIgnoreArg_micromap(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyMicromapEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_micromap = 1; +} + +void vkDestroyMicromapEXT_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyMicromapEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCmdBuildMicromapsEXT(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBuildMicromapsEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBuildMicromapsEXT); + cmock_call_instance = (CMOCK_vkCmdBuildMicromapsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBuildMicromapsEXT_CallInstance); + Mock.vkCmdBuildMicromapsEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBuildMicromapsEXT_CallInstance); + if (Mock.vkCmdBuildMicromapsEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBuildMicromapsEXT_CallbackBool && + Mock.vkCmdBuildMicromapsEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBuildMicromapsEXT_CallbackFunctionPointer(commandBuffer, infoCount, pInfos, Mock.vkCmdBuildMicromapsEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBuildMicromapsEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_infoCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdBuildMicromapsEXT,CMockString_infoCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_infoCount, infoCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfos) + { + UNITY_SET_DETAILS(CMockString_vkCmdBuildMicromapsEXT,CMockString_pInfos); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfos), (void*)(pInfos), sizeof(const VkMicromapBuildInfoEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdBuildMicromapsEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBuildMicromapsEXT_CallbackFunctionPointer(commandBuffer, infoCount, pInfos, Mock.vkCmdBuildMicromapsEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBuildMicromapsEXT(CMOCK_vkCmdBuildMicromapsEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos); +void CMockExpectParameters_vkCmdBuildMicromapsEXT(CMOCK_vkCmdBuildMicromapsEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_infoCount = infoCount; + cmock_call_instance->IgnoreArg_infoCount = 0; + cmock_call_instance->Expected_pInfos = pInfos; + cmock_call_instance->IgnoreArg_pInfos = 0; +} + +void vkCmdBuildMicromapsEXT_CMockIgnore(void) +{ + Mock.vkCmdBuildMicromapsEXT_IgnoreBool = (char)1; +} + +void vkCmdBuildMicromapsEXT_CMockStopIgnore(void) +{ + Mock.vkCmdBuildMicromapsEXT_IgnoreBool = (char)0; +} + +void vkCmdBuildMicromapsEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBuildMicromapsEXT_CALL_INSTANCE)); + CMOCK_vkCmdBuildMicromapsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBuildMicromapsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBuildMicromapsEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBuildMicromapsEXT_CallInstance, cmock_guts_index); + Mock.vkCmdBuildMicromapsEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBuildMicromapsEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBuildMicromapsEXT_CALL_INSTANCE)); + CMOCK_vkCmdBuildMicromapsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBuildMicromapsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBuildMicromapsEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBuildMicromapsEXT_CallInstance, cmock_guts_index); + Mock.vkCmdBuildMicromapsEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBuildMicromapsEXT(cmock_call_instance, commandBuffer, infoCount, pInfos); +} + +void vkCmdBuildMicromapsEXT_AddCallback(CMOCK_vkCmdBuildMicromapsEXT_CALLBACK Callback) +{ + Mock.vkCmdBuildMicromapsEXT_IgnoreBool = (char)0; + Mock.vkCmdBuildMicromapsEXT_CallbackBool = (char)1; + Mock.vkCmdBuildMicromapsEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdBuildMicromapsEXT_Stub(CMOCK_vkCmdBuildMicromapsEXT_CALLBACK Callback) +{ + Mock.vkCmdBuildMicromapsEXT_IgnoreBool = (char)0; + Mock.vkCmdBuildMicromapsEXT_CallbackBool = (char)0; + Mock.vkCmdBuildMicromapsEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdBuildMicromapsEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBuildMicromapsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBuildMicromapsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBuildMicromapsEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBuildMicromapsEXT_CMockIgnoreArg_infoCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBuildMicromapsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBuildMicromapsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBuildMicromapsEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_infoCount = 1; +} + +void vkCmdBuildMicromapsEXT_CMockIgnoreArg_pInfos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBuildMicromapsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBuildMicromapsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBuildMicromapsEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfos = 1; +} + +VkResult vkBuildMicromapsEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkBuildMicromapsEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkBuildMicromapsEXT); + cmock_call_instance = (CMOCK_vkBuildMicromapsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkBuildMicromapsEXT_CallInstance); + Mock.vkBuildMicromapsEXT_CallInstance = CMock_Guts_MemNext(Mock.vkBuildMicromapsEXT_CallInstance); + if (Mock.vkBuildMicromapsEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkBuildMicromapsEXT_FinalReturn; + memcpy((void*)(&Mock.vkBuildMicromapsEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkBuildMicromapsEXT_CallbackBool && + Mock.vkBuildMicromapsEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkBuildMicromapsEXT_CallbackFunctionPointer(device, deferredOperation, infoCount, pInfos, Mock.vkBuildMicromapsEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkBuildMicromapsEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_deferredOperation) + { + UNITY_SET_DETAILS(CMockString_vkBuildMicromapsEXT,CMockString_deferredOperation); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_deferredOperation), (void*)(&deferredOperation), sizeof(VkDeferredOperationKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_infoCount) + { + UNITY_SET_DETAILS(CMockString_vkBuildMicromapsEXT,CMockString_infoCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_infoCount, infoCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfos) + { + UNITY_SET_DETAILS(CMockString_vkBuildMicromapsEXT,CMockString_pInfos); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfos), (void*)(pInfos), sizeof(const VkMicromapBuildInfoEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkBuildMicromapsEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkBuildMicromapsEXT_CallbackFunctionPointer(device, deferredOperation, infoCount, pInfos, Mock.vkBuildMicromapsEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkBuildMicromapsEXT(CMOCK_vkBuildMicromapsEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos); +void CMockExpectParameters_vkBuildMicromapsEXT(CMOCK_vkBuildMicromapsEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_deferredOperation), (void*)(&deferredOperation), + sizeof(VkDeferredOperationKHR[sizeof(deferredOperation) == sizeof(VkDeferredOperationKHR) ? 1 : -1])); /* add VkDeferredOperationKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_deferredOperation = 0; + cmock_call_instance->Expected_infoCount = infoCount; + cmock_call_instance->IgnoreArg_infoCount = 0; + cmock_call_instance->Expected_pInfos = pInfos; + cmock_call_instance->IgnoreArg_pInfos = 0; +} + +void vkBuildMicromapsEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBuildMicromapsEXT_CALL_INSTANCE)); + CMOCK_vkBuildMicromapsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBuildMicromapsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBuildMicromapsEXT_CallInstance = CMock_Guts_MemChain(Mock.vkBuildMicromapsEXT_CallInstance, cmock_guts_index); + Mock.vkBuildMicromapsEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkBuildMicromapsEXT_IgnoreBool = (char)1; +} + +void vkBuildMicromapsEXT_CMockStopIgnore(void) +{ + if(Mock.vkBuildMicromapsEXT_IgnoreBool) + Mock.vkBuildMicromapsEXT_CallInstance = CMock_Guts_MemNext(Mock.vkBuildMicromapsEXT_CallInstance); + Mock.vkBuildMicromapsEXT_IgnoreBool = (char)0; +} + +void vkBuildMicromapsEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBuildMicromapsEXT_CALL_INSTANCE)); + CMOCK_vkBuildMicromapsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBuildMicromapsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBuildMicromapsEXT_CallInstance = CMock_Guts_MemChain(Mock.vkBuildMicromapsEXT_CallInstance, cmock_guts_index); + Mock.vkBuildMicromapsEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkBuildMicromapsEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBuildMicromapsEXT_CALL_INSTANCE)); + CMOCK_vkBuildMicromapsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBuildMicromapsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBuildMicromapsEXT_CallInstance = CMock_Guts_MemChain(Mock.vkBuildMicromapsEXT_CallInstance, cmock_guts_index); + Mock.vkBuildMicromapsEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkBuildMicromapsEXT(cmock_call_instance, device, deferredOperation, infoCount, pInfos); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkBuildMicromapsEXT_AddCallback(CMOCK_vkBuildMicromapsEXT_CALLBACK Callback) +{ + Mock.vkBuildMicromapsEXT_IgnoreBool = (char)0; + Mock.vkBuildMicromapsEXT_CallbackBool = (char)1; + Mock.vkBuildMicromapsEXT_CallbackFunctionPointer = Callback; +} + +void vkBuildMicromapsEXT_Stub(CMOCK_vkBuildMicromapsEXT_CALLBACK Callback) +{ + Mock.vkBuildMicromapsEXT_IgnoreBool = (char)0; + Mock.vkBuildMicromapsEXT_CallbackBool = (char)0; + Mock.vkBuildMicromapsEXT_CallbackFunctionPointer = Callback; +} + +void vkBuildMicromapsEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBuildMicromapsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBuildMicromapsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBuildMicromapsEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkBuildMicromapsEXT_CMockIgnoreArg_deferredOperation(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBuildMicromapsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBuildMicromapsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBuildMicromapsEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_deferredOperation = 1; +} + +void vkBuildMicromapsEXT_CMockIgnoreArg_infoCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBuildMicromapsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBuildMicromapsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBuildMicromapsEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_infoCount = 1; +} + +void vkBuildMicromapsEXT_CMockIgnoreArg_pInfos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBuildMicromapsEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBuildMicromapsEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBuildMicromapsEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfos = 1; +} + +VkResult vkCopyMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCopyMicromapEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCopyMicromapEXT); + cmock_call_instance = (CMOCK_vkCopyMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCopyMicromapEXT_CallInstance); + Mock.vkCopyMicromapEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCopyMicromapEXT_CallInstance); + if (Mock.vkCopyMicromapEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCopyMicromapEXT_FinalReturn; + memcpy((void*)(&Mock.vkCopyMicromapEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCopyMicromapEXT_CallbackBool && + Mock.vkCopyMicromapEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCopyMicromapEXT_CallbackFunctionPointer(device, deferredOperation, pInfo, Mock.vkCopyMicromapEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCopyMicromapEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_deferredOperation) + { + UNITY_SET_DETAILS(CMockString_vkCopyMicromapEXT,CMockString_deferredOperation); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_deferredOperation), (void*)(&deferredOperation), sizeof(VkDeferredOperationKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkCopyMicromapEXT,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkCopyMicromapInfoEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCopyMicromapEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCopyMicromapEXT_CallbackFunctionPointer(device, deferredOperation, pInfo, Mock.vkCopyMicromapEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCopyMicromapEXT(CMOCK_vkCopyMicromapEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo); +void CMockExpectParameters_vkCopyMicromapEXT(CMOCK_vkCopyMicromapEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_deferredOperation), (void*)(&deferredOperation), + sizeof(VkDeferredOperationKHR[sizeof(deferredOperation) == sizeof(VkDeferredOperationKHR) ? 1 : -1])); /* add VkDeferredOperationKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_deferredOperation = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; +} + +void vkCopyMicromapEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCopyMicromapEXT_CALL_INSTANCE)); + CMOCK_vkCopyMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCopyMicromapEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCopyMicromapEXT_CallInstance, cmock_guts_index); + Mock.vkCopyMicromapEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCopyMicromapEXT_IgnoreBool = (char)1; +} + +void vkCopyMicromapEXT_CMockStopIgnore(void) +{ + if(Mock.vkCopyMicromapEXT_IgnoreBool) + Mock.vkCopyMicromapEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCopyMicromapEXT_CallInstance); + Mock.vkCopyMicromapEXT_IgnoreBool = (char)0; +} + +void vkCopyMicromapEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCopyMicromapEXT_CALL_INSTANCE)); + CMOCK_vkCopyMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCopyMicromapEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCopyMicromapEXT_CallInstance, cmock_guts_index); + Mock.vkCopyMicromapEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCopyMicromapEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCopyMicromapEXT_CALL_INSTANCE)); + CMOCK_vkCopyMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCopyMicromapEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCopyMicromapEXT_CallInstance, cmock_guts_index); + Mock.vkCopyMicromapEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCopyMicromapEXT(cmock_call_instance, device, deferredOperation, pInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCopyMicromapEXT_AddCallback(CMOCK_vkCopyMicromapEXT_CALLBACK Callback) +{ + Mock.vkCopyMicromapEXT_IgnoreBool = (char)0; + Mock.vkCopyMicromapEXT_CallbackBool = (char)1; + Mock.vkCopyMicromapEXT_CallbackFunctionPointer = Callback; +} + +void vkCopyMicromapEXT_Stub(CMOCK_vkCopyMicromapEXT_CALLBACK Callback) +{ + Mock.vkCopyMicromapEXT_IgnoreBool = (char)0; + Mock.vkCopyMicromapEXT_CallbackBool = (char)0; + Mock.vkCopyMicromapEXT_CallbackFunctionPointer = Callback; +} + +void vkCopyMicromapEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCopyMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCopyMicromapEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCopyMicromapEXT_CMockIgnoreArg_deferredOperation(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCopyMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCopyMicromapEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_deferredOperation = 1; +} + +void vkCopyMicromapEXT_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCopyMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCopyMicromapEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +VkResult vkCopyMicromapToMemoryEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCopyMicromapToMemoryEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCopyMicromapToMemoryEXT); + cmock_call_instance = (CMOCK_vkCopyMicromapToMemoryEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCopyMicromapToMemoryEXT_CallInstance); + Mock.vkCopyMicromapToMemoryEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCopyMicromapToMemoryEXT_CallInstance); + if (Mock.vkCopyMicromapToMemoryEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCopyMicromapToMemoryEXT_FinalReturn; + memcpy((void*)(&Mock.vkCopyMicromapToMemoryEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCopyMicromapToMemoryEXT_CallbackBool && + Mock.vkCopyMicromapToMemoryEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCopyMicromapToMemoryEXT_CallbackFunctionPointer(device, deferredOperation, pInfo, Mock.vkCopyMicromapToMemoryEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCopyMicromapToMemoryEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_deferredOperation) + { + UNITY_SET_DETAILS(CMockString_vkCopyMicromapToMemoryEXT,CMockString_deferredOperation); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_deferredOperation), (void*)(&deferredOperation), sizeof(VkDeferredOperationKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkCopyMicromapToMemoryEXT,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkCopyMicromapToMemoryInfoEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCopyMicromapToMemoryEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCopyMicromapToMemoryEXT_CallbackFunctionPointer(device, deferredOperation, pInfo, Mock.vkCopyMicromapToMemoryEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCopyMicromapToMemoryEXT(CMOCK_vkCopyMicromapToMemoryEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo); +void CMockExpectParameters_vkCopyMicromapToMemoryEXT(CMOCK_vkCopyMicromapToMemoryEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_deferredOperation), (void*)(&deferredOperation), + sizeof(VkDeferredOperationKHR[sizeof(deferredOperation) == sizeof(VkDeferredOperationKHR) ? 1 : -1])); /* add VkDeferredOperationKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_deferredOperation = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; +} + +void vkCopyMicromapToMemoryEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCopyMicromapToMemoryEXT_CALL_INSTANCE)); + CMOCK_vkCopyMicromapToMemoryEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyMicromapToMemoryEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCopyMicromapToMemoryEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCopyMicromapToMemoryEXT_CallInstance, cmock_guts_index); + Mock.vkCopyMicromapToMemoryEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCopyMicromapToMemoryEXT_IgnoreBool = (char)1; +} + +void vkCopyMicromapToMemoryEXT_CMockStopIgnore(void) +{ + if(Mock.vkCopyMicromapToMemoryEXT_IgnoreBool) + Mock.vkCopyMicromapToMemoryEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCopyMicromapToMemoryEXT_CallInstance); + Mock.vkCopyMicromapToMemoryEXT_IgnoreBool = (char)0; +} + +void vkCopyMicromapToMemoryEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCopyMicromapToMemoryEXT_CALL_INSTANCE)); + CMOCK_vkCopyMicromapToMemoryEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyMicromapToMemoryEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCopyMicromapToMemoryEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCopyMicromapToMemoryEXT_CallInstance, cmock_guts_index); + Mock.vkCopyMicromapToMemoryEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCopyMicromapToMemoryEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCopyMicromapToMemoryEXT_CALL_INSTANCE)); + CMOCK_vkCopyMicromapToMemoryEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyMicromapToMemoryEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCopyMicromapToMemoryEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCopyMicromapToMemoryEXT_CallInstance, cmock_guts_index); + Mock.vkCopyMicromapToMemoryEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCopyMicromapToMemoryEXT(cmock_call_instance, device, deferredOperation, pInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCopyMicromapToMemoryEXT_AddCallback(CMOCK_vkCopyMicromapToMemoryEXT_CALLBACK Callback) +{ + Mock.vkCopyMicromapToMemoryEXT_IgnoreBool = (char)0; + Mock.vkCopyMicromapToMemoryEXT_CallbackBool = (char)1; + Mock.vkCopyMicromapToMemoryEXT_CallbackFunctionPointer = Callback; +} + +void vkCopyMicromapToMemoryEXT_Stub(CMOCK_vkCopyMicromapToMemoryEXT_CALLBACK Callback) +{ + Mock.vkCopyMicromapToMemoryEXT_IgnoreBool = (char)0; + Mock.vkCopyMicromapToMemoryEXT_CallbackBool = (char)0; + Mock.vkCopyMicromapToMemoryEXT_CallbackFunctionPointer = Callback; +} + +void vkCopyMicromapToMemoryEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCopyMicromapToMemoryEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyMicromapToMemoryEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCopyMicromapToMemoryEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCopyMicromapToMemoryEXT_CMockIgnoreArg_deferredOperation(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCopyMicromapToMemoryEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyMicromapToMemoryEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCopyMicromapToMemoryEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_deferredOperation = 1; +} + +void vkCopyMicromapToMemoryEXT_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCopyMicromapToMemoryEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyMicromapToMemoryEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCopyMicromapToMemoryEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +VkResult vkCopyMemoryToMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCopyMemoryToMicromapEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCopyMemoryToMicromapEXT); + cmock_call_instance = (CMOCK_vkCopyMemoryToMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCopyMemoryToMicromapEXT_CallInstance); + Mock.vkCopyMemoryToMicromapEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCopyMemoryToMicromapEXT_CallInstance); + if (Mock.vkCopyMemoryToMicromapEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCopyMemoryToMicromapEXT_FinalReturn; + memcpy((void*)(&Mock.vkCopyMemoryToMicromapEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCopyMemoryToMicromapEXT_CallbackBool && + Mock.vkCopyMemoryToMicromapEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCopyMemoryToMicromapEXT_CallbackFunctionPointer(device, deferredOperation, pInfo, Mock.vkCopyMemoryToMicromapEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCopyMemoryToMicromapEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_deferredOperation) + { + UNITY_SET_DETAILS(CMockString_vkCopyMemoryToMicromapEXT,CMockString_deferredOperation); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_deferredOperation), (void*)(&deferredOperation), sizeof(VkDeferredOperationKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkCopyMemoryToMicromapEXT,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkCopyMemoryToMicromapInfoEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCopyMemoryToMicromapEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCopyMemoryToMicromapEXT_CallbackFunctionPointer(device, deferredOperation, pInfo, Mock.vkCopyMemoryToMicromapEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCopyMemoryToMicromapEXT(CMOCK_vkCopyMemoryToMicromapEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo); +void CMockExpectParameters_vkCopyMemoryToMicromapEXT(CMOCK_vkCopyMemoryToMicromapEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_deferredOperation), (void*)(&deferredOperation), + sizeof(VkDeferredOperationKHR[sizeof(deferredOperation) == sizeof(VkDeferredOperationKHR) ? 1 : -1])); /* add VkDeferredOperationKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_deferredOperation = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; +} + +void vkCopyMemoryToMicromapEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCopyMemoryToMicromapEXT_CALL_INSTANCE)); + CMOCK_vkCopyMemoryToMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyMemoryToMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCopyMemoryToMicromapEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCopyMemoryToMicromapEXT_CallInstance, cmock_guts_index); + Mock.vkCopyMemoryToMicromapEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCopyMemoryToMicromapEXT_IgnoreBool = (char)1; +} + +void vkCopyMemoryToMicromapEXT_CMockStopIgnore(void) +{ + if(Mock.vkCopyMemoryToMicromapEXT_IgnoreBool) + Mock.vkCopyMemoryToMicromapEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCopyMemoryToMicromapEXT_CallInstance); + Mock.vkCopyMemoryToMicromapEXT_IgnoreBool = (char)0; +} + +void vkCopyMemoryToMicromapEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCopyMemoryToMicromapEXT_CALL_INSTANCE)); + CMOCK_vkCopyMemoryToMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyMemoryToMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCopyMemoryToMicromapEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCopyMemoryToMicromapEXT_CallInstance, cmock_guts_index); + Mock.vkCopyMemoryToMicromapEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCopyMemoryToMicromapEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCopyMemoryToMicromapEXT_CALL_INSTANCE)); + CMOCK_vkCopyMemoryToMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyMemoryToMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCopyMemoryToMicromapEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCopyMemoryToMicromapEXT_CallInstance, cmock_guts_index); + Mock.vkCopyMemoryToMicromapEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCopyMemoryToMicromapEXT(cmock_call_instance, device, deferredOperation, pInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCopyMemoryToMicromapEXT_AddCallback(CMOCK_vkCopyMemoryToMicromapEXT_CALLBACK Callback) +{ + Mock.vkCopyMemoryToMicromapEXT_IgnoreBool = (char)0; + Mock.vkCopyMemoryToMicromapEXT_CallbackBool = (char)1; + Mock.vkCopyMemoryToMicromapEXT_CallbackFunctionPointer = Callback; +} + +void vkCopyMemoryToMicromapEXT_Stub(CMOCK_vkCopyMemoryToMicromapEXT_CALLBACK Callback) +{ + Mock.vkCopyMemoryToMicromapEXT_IgnoreBool = (char)0; + Mock.vkCopyMemoryToMicromapEXT_CallbackBool = (char)0; + Mock.vkCopyMemoryToMicromapEXT_CallbackFunctionPointer = Callback; +} + +void vkCopyMemoryToMicromapEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCopyMemoryToMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyMemoryToMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCopyMemoryToMicromapEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCopyMemoryToMicromapEXT_CMockIgnoreArg_deferredOperation(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCopyMemoryToMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyMemoryToMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCopyMemoryToMicromapEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_deferredOperation = 1; +} + +void vkCopyMemoryToMicromapEXT_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCopyMemoryToMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyMemoryToMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCopyMemoryToMicromapEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +VkResult vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, size_t dataSize, void* pData, size_t stride) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkWriteMicromapsPropertiesEXT); + cmock_call_instance = (CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkWriteMicromapsPropertiesEXT_CallInstance); + Mock.vkWriteMicromapsPropertiesEXT_CallInstance = CMock_Guts_MemNext(Mock.vkWriteMicromapsPropertiesEXT_CallInstance); + if (Mock.vkWriteMicromapsPropertiesEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkWriteMicromapsPropertiesEXT_FinalReturn; + memcpy((void*)(&Mock.vkWriteMicromapsPropertiesEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkWriteMicromapsPropertiesEXT_CallbackBool && + Mock.vkWriteMicromapsPropertiesEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkWriteMicromapsPropertiesEXT_CallbackFunctionPointer(device, micromapCount, pMicromaps, queryType, dataSize, pData, stride, Mock.vkWriteMicromapsPropertiesEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkWriteMicromapsPropertiesEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_micromapCount) + { + UNITY_SET_DETAILS(CMockString_vkWriteMicromapsPropertiesEXT,CMockString_micromapCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_micromapCount, micromapCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMicromaps) + { + UNITY_SET_DETAILS(CMockString_vkWriteMicromapsPropertiesEXT,CMockString_pMicromaps); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMicromaps), (void*)(pMicromaps), sizeof(const VkMicromapEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queryType) + { + UNITY_SET_DETAILS(CMockString_vkWriteMicromapsPropertiesEXT,CMockString_queryType); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queryType), (void*)(&queryType), sizeof(VkQueryType), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dataSize) + { + UNITY_SET_DETAILS(CMockString_vkWriteMicromapsPropertiesEXT,CMockString_dataSize); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dataSize), (void*)(&dataSize), sizeof(size_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pData) + { + UNITY_SET_DETAILS(CMockString_vkWriteMicromapsPropertiesEXT,CMockString_pData); + if (cmock_call_instance->Expected_pData == NULL) + { UNITY_TEST_ASSERT_NULL(pData, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(cmock_call_instance->Expected_pData, pData, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_stride) + { + UNITY_SET_DETAILS(CMockString_vkWriteMicromapsPropertiesEXT,CMockString_stride); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_stride), (void*)(&stride), sizeof(size_t), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkWriteMicromapsPropertiesEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkWriteMicromapsPropertiesEXT_CallbackFunctionPointer(device, micromapCount, pMicromaps, queryType, dataSize, pData, stride, Mock.vkWriteMicromapsPropertiesEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pData_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pData, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pData, (const void*)cmock_call_instance->ReturnThruPtr_pData_Val, + cmock_call_instance->ReturnThruPtr_pData_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkWriteMicromapsPropertiesEXT(CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, size_t dataSize, void* pData, size_t stride); +void CMockExpectParameters_vkWriteMicromapsPropertiesEXT(CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, size_t dataSize, void* pData, size_t stride) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_micromapCount = micromapCount; + cmock_call_instance->IgnoreArg_micromapCount = 0; + cmock_call_instance->Expected_pMicromaps = pMicromaps; + cmock_call_instance->IgnoreArg_pMicromaps = 0; + memcpy((void*)(&cmock_call_instance->Expected_queryType), (void*)(&queryType), + sizeof(VkQueryType[sizeof(queryType) == sizeof(VkQueryType) ? 1 : -1])); /* add VkQueryType to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queryType = 0; + memcpy((void*)(&cmock_call_instance->Expected_dataSize), (void*)(&dataSize), + sizeof(size_t[sizeof(dataSize) == sizeof(size_t) ? 1 : -1])); /* add size_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dataSize = 0; + cmock_call_instance->Expected_pData = pData; + cmock_call_instance->IgnoreArg_pData = 0; + cmock_call_instance->ReturnThruPtr_pData_Used = 0; + memcpy((void*)(&cmock_call_instance->Expected_stride), (void*)(&stride), + sizeof(size_t[sizeof(stride) == sizeof(size_t) ? 1 : -1])); /* add size_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_stride = 0; +} + +void vkWriteMicromapsPropertiesEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE)); + CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkWriteMicromapsPropertiesEXT_CallInstance = CMock_Guts_MemChain(Mock.vkWriteMicromapsPropertiesEXT_CallInstance, cmock_guts_index); + Mock.vkWriteMicromapsPropertiesEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkWriteMicromapsPropertiesEXT_IgnoreBool = (char)1; +} + +void vkWriteMicromapsPropertiesEXT_CMockStopIgnore(void) +{ + if(Mock.vkWriteMicromapsPropertiesEXT_IgnoreBool) + Mock.vkWriteMicromapsPropertiesEXT_CallInstance = CMock_Guts_MemNext(Mock.vkWriteMicromapsPropertiesEXT_CallInstance); + Mock.vkWriteMicromapsPropertiesEXT_IgnoreBool = (char)0; +} + +void vkWriteMicromapsPropertiesEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE)); + CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkWriteMicromapsPropertiesEXT_CallInstance = CMock_Guts_MemChain(Mock.vkWriteMicromapsPropertiesEXT_CallInstance, cmock_guts_index); + Mock.vkWriteMicromapsPropertiesEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkWriteMicromapsPropertiesEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, size_t dataSize, void* pData, size_t stride, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE)); + CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkWriteMicromapsPropertiesEXT_CallInstance = CMock_Guts_MemChain(Mock.vkWriteMicromapsPropertiesEXT_CallInstance, cmock_guts_index); + Mock.vkWriteMicromapsPropertiesEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkWriteMicromapsPropertiesEXT(cmock_call_instance, device, micromapCount, pMicromaps, queryType, dataSize, pData, stride); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkWriteMicromapsPropertiesEXT_AddCallback(CMOCK_vkWriteMicromapsPropertiesEXT_CALLBACK Callback) +{ + Mock.vkWriteMicromapsPropertiesEXT_IgnoreBool = (char)0; + Mock.vkWriteMicromapsPropertiesEXT_CallbackBool = (char)1; + Mock.vkWriteMicromapsPropertiesEXT_CallbackFunctionPointer = Callback; +} + +void vkWriteMicromapsPropertiesEXT_Stub(CMOCK_vkWriteMicromapsPropertiesEXT_CALLBACK Callback) +{ + Mock.vkWriteMicromapsPropertiesEXT_IgnoreBool = (char)0; + Mock.vkWriteMicromapsPropertiesEXT_CallbackBool = (char)0; + Mock.vkWriteMicromapsPropertiesEXT_CallbackFunctionPointer = Callback; +} + +void vkWriteMicromapsPropertiesEXT_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, void const* pData, size_t cmock_size) +{ + CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWriteMicromapsPropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pData_Used = 1; + cmock_call_instance->ReturnThruPtr_pData_Val = pData; + cmock_call_instance->ReturnThruPtr_pData_Size = cmock_size; +} + +void vkWriteMicromapsPropertiesEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWriteMicromapsPropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkWriteMicromapsPropertiesEXT_CMockIgnoreArg_micromapCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWriteMicromapsPropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_micromapCount = 1; +} + +void vkWriteMicromapsPropertiesEXT_CMockIgnoreArg_pMicromaps(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWriteMicromapsPropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMicromaps = 1; +} + +void vkWriteMicromapsPropertiesEXT_CMockIgnoreArg_queryType(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWriteMicromapsPropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queryType = 1; +} + +void vkWriteMicromapsPropertiesEXT_CMockIgnoreArg_dataSize(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWriteMicromapsPropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dataSize = 1; +} + +void vkWriteMicromapsPropertiesEXT_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWriteMicromapsPropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pData = 1; +} + +void vkWriteMicromapsPropertiesEXT_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWriteMicromapsPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWriteMicromapsPropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stride = 1; +} + +void vkCmdCopyMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdCopyMicromapEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdCopyMicromapEXT); + cmock_call_instance = (CMOCK_vkCmdCopyMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdCopyMicromapEXT_CallInstance); + Mock.vkCmdCopyMicromapEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdCopyMicromapEXT_CallInstance); + if (Mock.vkCmdCopyMicromapEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdCopyMicromapEXT_CallbackBool && + Mock.vkCmdCopyMicromapEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyMicromapEXT_CallbackFunctionPointer(commandBuffer, pInfo, Mock.vkCmdCopyMicromapEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyMicromapEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyMicromapEXT,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkCopyMicromapInfoEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdCopyMicromapEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyMicromapEXT_CallbackFunctionPointer(commandBuffer, pInfo, Mock.vkCmdCopyMicromapEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdCopyMicromapEXT(CMOCK_vkCmdCopyMicromapEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo); +void CMockExpectParameters_vkCmdCopyMicromapEXT(CMOCK_vkCmdCopyMicromapEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; +} + +void vkCmdCopyMicromapEXT_CMockIgnore(void) +{ + Mock.vkCmdCopyMicromapEXT_IgnoreBool = (char)1; +} + +void vkCmdCopyMicromapEXT_CMockStopIgnore(void) +{ + Mock.vkCmdCopyMicromapEXT_IgnoreBool = (char)0; +} + +void vkCmdCopyMicromapEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyMicromapEXT_CALL_INSTANCE)); + CMOCK_vkCmdCopyMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyMicromapEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyMicromapEXT_CallInstance, cmock_guts_index); + Mock.vkCmdCopyMicromapEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdCopyMicromapEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyMicromapEXT_CALL_INSTANCE)); + CMOCK_vkCmdCopyMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyMicromapEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyMicromapEXT_CallInstance, cmock_guts_index); + Mock.vkCmdCopyMicromapEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdCopyMicromapEXT(cmock_call_instance, commandBuffer, pInfo); +} + +void vkCmdCopyMicromapEXT_AddCallback(CMOCK_vkCmdCopyMicromapEXT_CALLBACK Callback) +{ + Mock.vkCmdCopyMicromapEXT_IgnoreBool = (char)0; + Mock.vkCmdCopyMicromapEXT_CallbackBool = (char)1; + Mock.vkCmdCopyMicromapEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyMicromapEXT_Stub(CMOCK_vkCmdCopyMicromapEXT_CALLBACK Callback) +{ + Mock.vkCmdCopyMicromapEXT_IgnoreBool = (char)0; + Mock.vkCmdCopyMicromapEXT_CallbackBool = (char)0; + Mock.vkCmdCopyMicromapEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyMicromapEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyMicromapEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdCopyMicromapEXT_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyMicromapEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +void vkCmdCopyMicromapToMemoryEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdCopyMicromapToMemoryEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdCopyMicromapToMemoryEXT); + cmock_call_instance = (CMOCK_vkCmdCopyMicromapToMemoryEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdCopyMicromapToMemoryEXT_CallInstance); + Mock.vkCmdCopyMicromapToMemoryEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdCopyMicromapToMemoryEXT_CallInstance); + if (Mock.vkCmdCopyMicromapToMemoryEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdCopyMicromapToMemoryEXT_CallbackBool && + Mock.vkCmdCopyMicromapToMemoryEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyMicromapToMemoryEXT_CallbackFunctionPointer(commandBuffer, pInfo, Mock.vkCmdCopyMicromapToMemoryEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyMicromapToMemoryEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyMicromapToMemoryEXT,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkCopyMicromapToMemoryInfoEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdCopyMicromapToMemoryEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyMicromapToMemoryEXT_CallbackFunctionPointer(commandBuffer, pInfo, Mock.vkCmdCopyMicromapToMemoryEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdCopyMicromapToMemoryEXT(CMOCK_vkCmdCopyMicromapToMemoryEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo); +void CMockExpectParameters_vkCmdCopyMicromapToMemoryEXT(CMOCK_vkCmdCopyMicromapToMemoryEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; +} + +void vkCmdCopyMicromapToMemoryEXT_CMockIgnore(void) +{ + Mock.vkCmdCopyMicromapToMemoryEXT_IgnoreBool = (char)1; +} + +void vkCmdCopyMicromapToMemoryEXT_CMockStopIgnore(void) +{ + Mock.vkCmdCopyMicromapToMemoryEXT_IgnoreBool = (char)0; +} + +void vkCmdCopyMicromapToMemoryEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyMicromapToMemoryEXT_CALL_INSTANCE)); + CMOCK_vkCmdCopyMicromapToMemoryEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMicromapToMemoryEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyMicromapToMemoryEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyMicromapToMemoryEXT_CallInstance, cmock_guts_index); + Mock.vkCmdCopyMicromapToMemoryEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdCopyMicromapToMemoryEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyMicromapToMemoryEXT_CALL_INSTANCE)); + CMOCK_vkCmdCopyMicromapToMemoryEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMicromapToMemoryEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyMicromapToMemoryEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyMicromapToMemoryEXT_CallInstance, cmock_guts_index); + Mock.vkCmdCopyMicromapToMemoryEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdCopyMicromapToMemoryEXT(cmock_call_instance, commandBuffer, pInfo); +} + +void vkCmdCopyMicromapToMemoryEXT_AddCallback(CMOCK_vkCmdCopyMicromapToMemoryEXT_CALLBACK Callback) +{ + Mock.vkCmdCopyMicromapToMemoryEXT_IgnoreBool = (char)0; + Mock.vkCmdCopyMicromapToMemoryEXT_CallbackBool = (char)1; + Mock.vkCmdCopyMicromapToMemoryEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyMicromapToMemoryEXT_Stub(CMOCK_vkCmdCopyMicromapToMemoryEXT_CALLBACK Callback) +{ + Mock.vkCmdCopyMicromapToMemoryEXT_IgnoreBool = (char)0; + Mock.vkCmdCopyMicromapToMemoryEXT_CallbackBool = (char)0; + Mock.vkCmdCopyMicromapToMemoryEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyMicromapToMemoryEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyMicromapToMemoryEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMicromapToMemoryEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyMicromapToMemoryEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdCopyMicromapToMemoryEXT_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyMicromapToMemoryEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMicromapToMemoryEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyMicromapToMemoryEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +void vkCmdCopyMemoryToMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdCopyMemoryToMicromapEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdCopyMemoryToMicromapEXT); + cmock_call_instance = (CMOCK_vkCmdCopyMemoryToMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdCopyMemoryToMicromapEXT_CallInstance); + Mock.vkCmdCopyMemoryToMicromapEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdCopyMemoryToMicromapEXT_CallInstance); + if (Mock.vkCmdCopyMemoryToMicromapEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdCopyMemoryToMicromapEXT_CallbackBool && + Mock.vkCmdCopyMemoryToMicromapEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyMemoryToMicromapEXT_CallbackFunctionPointer(commandBuffer, pInfo, Mock.vkCmdCopyMemoryToMicromapEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyMemoryToMicromapEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyMemoryToMicromapEXT,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkCopyMemoryToMicromapInfoEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdCopyMemoryToMicromapEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyMemoryToMicromapEXT_CallbackFunctionPointer(commandBuffer, pInfo, Mock.vkCmdCopyMemoryToMicromapEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdCopyMemoryToMicromapEXT(CMOCK_vkCmdCopyMemoryToMicromapEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo); +void CMockExpectParameters_vkCmdCopyMemoryToMicromapEXT(CMOCK_vkCmdCopyMemoryToMicromapEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; +} + +void vkCmdCopyMemoryToMicromapEXT_CMockIgnore(void) +{ + Mock.vkCmdCopyMemoryToMicromapEXT_IgnoreBool = (char)1; +} + +void vkCmdCopyMemoryToMicromapEXT_CMockStopIgnore(void) +{ + Mock.vkCmdCopyMemoryToMicromapEXT_IgnoreBool = (char)0; +} + +void vkCmdCopyMemoryToMicromapEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyMemoryToMicromapEXT_CALL_INSTANCE)); + CMOCK_vkCmdCopyMemoryToMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMemoryToMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyMemoryToMicromapEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyMemoryToMicromapEXT_CallInstance, cmock_guts_index); + Mock.vkCmdCopyMemoryToMicromapEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdCopyMemoryToMicromapEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyMemoryToMicromapEXT_CALL_INSTANCE)); + CMOCK_vkCmdCopyMemoryToMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMemoryToMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyMemoryToMicromapEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyMemoryToMicromapEXT_CallInstance, cmock_guts_index); + Mock.vkCmdCopyMemoryToMicromapEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdCopyMemoryToMicromapEXT(cmock_call_instance, commandBuffer, pInfo); +} + +void vkCmdCopyMemoryToMicromapEXT_AddCallback(CMOCK_vkCmdCopyMemoryToMicromapEXT_CALLBACK Callback) +{ + Mock.vkCmdCopyMemoryToMicromapEXT_IgnoreBool = (char)0; + Mock.vkCmdCopyMemoryToMicromapEXT_CallbackBool = (char)1; + Mock.vkCmdCopyMemoryToMicromapEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyMemoryToMicromapEXT_Stub(CMOCK_vkCmdCopyMemoryToMicromapEXT_CALLBACK Callback) +{ + Mock.vkCmdCopyMemoryToMicromapEXT_IgnoreBool = (char)0; + Mock.vkCmdCopyMemoryToMicromapEXT_CallbackBool = (char)0; + Mock.vkCmdCopyMemoryToMicromapEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyMemoryToMicromapEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyMemoryToMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMemoryToMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyMemoryToMicromapEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdCopyMemoryToMicromapEXT_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyMemoryToMicromapEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMemoryToMicromapEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyMemoryToMicromapEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +void vkCmdWriteMicromapsPropertiesEXT(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdWriteMicromapsPropertiesEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdWriteMicromapsPropertiesEXT); + cmock_call_instance = (CMOCK_vkCmdWriteMicromapsPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdWriteMicromapsPropertiesEXT_CallInstance); + Mock.vkCmdWriteMicromapsPropertiesEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdWriteMicromapsPropertiesEXT_CallInstance); + if (Mock.vkCmdWriteMicromapsPropertiesEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdWriteMicromapsPropertiesEXT_CallbackBool && + Mock.vkCmdWriteMicromapsPropertiesEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdWriteMicromapsPropertiesEXT_CallbackFunctionPointer(commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery, Mock.vkCmdWriteMicromapsPropertiesEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteMicromapsPropertiesEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_micromapCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteMicromapsPropertiesEXT,CMockString_micromapCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_micromapCount, micromapCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMicromaps) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteMicromapsPropertiesEXT,CMockString_pMicromaps); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMicromaps), (void*)(pMicromaps), sizeof(const VkMicromapEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queryType) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteMicromapsPropertiesEXT,CMockString_queryType); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queryType), (void*)(&queryType), sizeof(VkQueryType), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queryPool) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteMicromapsPropertiesEXT,CMockString_queryPool); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), sizeof(VkQueryPool), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstQuery) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteMicromapsPropertiesEXT,CMockString_firstQuery); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstQuery, firstQuery, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdWriteMicromapsPropertiesEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdWriteMicromapsPropertiesEXT_CallbackFunctionPointer(commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery, Mock.vkCmdWriteMicromapsPropertiesEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdWriteMicromapsPropertiesEXT(CMOCK_vkCmdWriteMicromapsPropertiesEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); +void CMockExpectParameters_vkCmdWriteMicromapsPropertiesEXT(CMOCK_vkCmdWriteMicromapsPropertiesEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_micromapCount = micromapCount; + cmock_call_instance->IgnoreArg_micromapCount = 0; + cmock_call_instance->Expected_pMicromaps = pMicromaps; + cmock_call_instance->IgnoreArg_pMicromaps = 0; + memcpy((void*)(&cmock_call_instance->Expected_queryType), (void*)(&queryType), + sizeof(VkQueryType[sizeof(queryType) == sizeof(VkQueryType) ? 1 : -1])); /* add VkQueryType to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queryType = 0; + memcpy((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), + sizeof(VkQueryPool[sizeof(queryPool) == sizeof(VkQueryPool) ? 1 : -1])); /* add VkQueryPool to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queryPool = 0; + cmock_call_instance->Expected_firstQuery = firstQuery; + cmock_call_instance->IgnoreArg_firstQuery = 0; +} + +void vkCmdWriteMicromapsPropertiesEXT_CMockIgnore(void) +{ + Mock.vkCmdWriteMicromapsPropertiesEXT_IgnoreBool = (char)1; +} + +void vkCmdWriteMicromapsPropertiesEXT_CMockStopIgnore(void) +{ + Mock.vkCmdWriteMicromapsPropertiesEXT_IgnoreBool = (char)0; +} + +void vkCmdWriteMicromapsPropertiesEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdWriteMicromapsPropertiesEXT_CALL_INSTANCE)); + CMOCK_vkCmdWriteMicromapsPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteMicromapsPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdWriteMicromapsPropertiesEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdWriteMicromapsPropertiesEXT_CallInstance, cmock_guts_index); + Mock.vkCmdWriteMicromapsPropertiesEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdWriteMicromapsPropertiesEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdWriteMicromapsPropertiesEXT_CALL_INSTANCE)); + CMOCK_vkCmdWriteMicromapsPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteMicromapsPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdWriteMicromapsPropertiesEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdWriteMicromapsPropertiesEXT_CallInstance, cmock_guts_index); + Mock.vkCmdWriteMicromapsPropertiesEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdWriteMicromapsPropertiesEXT(cmock_call_instance, commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery); +} + +void vkCmdWriteMicromapsPropertiesEXT_AddCallback(CMOCK_vkCmdWriteMicromapsPropertiesEXT_CALLBACK Callback) +{ + Mock.vkCmdWriteMicromapsPropertiesEXT_IgnoreBool = (char)0; + Mock.vkCmdWriteMicromapsPropertiesEXT_CallbackBool = (char)1; + Mock.vkCmdWriteMicromapsPropertiesEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdWriteMicromapsPropertiesEXT_Stub(CMOCK_vkCmdWriteMicromapsPropertiesEXT_CALLBACK Callback) +{ + Mock.vkCmdWriteMicromapsPropertiesEXT_IgnoreBool = (char)0; + Mock.vkCmdWriteMicromapsPropertiesEXT_CallbackBool = (char)0; + Mock.vkCmdWriteMicromapsPropertiesEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdWriteMicromapsPropertiesEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteMicromapsPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteMicromapsPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteMicromapsPropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdWriteMicromapsPropertiesEXT_CMockIgnoreArg_micromapCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteMicromapsPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteMicromapsPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteMicromapsPropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_micromapCount = 1; +} + +void vkCmdWriteMicromapsPropertiesEXT_CMockIgnoreArg_pMicromaps(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteMicromapsPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteMicromapsPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteMicromapsPropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMicromaps = 1; +} + +void vkCmdWriteMicromapsPropertiesEXT_CMockIgnoreArg_queryType(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteMicromapsPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteMicromapsPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteMicromapsPropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queryType = 1; +} + +void vkCmdWriteMicromapsPropertiesEXT_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteMicromapsPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteMicromapsPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteMicromapsPropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queryPool = 1; +} + +void vkCmdWriteMicromapsPropertiesEXT_CMockIgnoreArg_firstQuery(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteMicromapsPropertiesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteMicromapsPropertiesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteMicromapsPropertiesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstQuery = 1; +} + +void vkGetDeviceMicromapCompatibilityEXT(VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDeviceMicromapCompatibilityEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDeviceMicromapCompatibilityEXT); + cmock_call_instance = (CMOCK_vkGetDeviceMicromapCompatibilityEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDeviceMicromapCompatibilityEXT_CallInstance); + Mock.vkGetDeviceMicromapCompatibilityEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeviceMicromapCompatibilityEXT_CallInstance); + if (Mock.vkGetDeviceMicromapCompatibilityEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetDeviceMicromapCompatibilityEXT_CallbackBool && + Mock.vkGetDeviceMicromapCompatibilityEXT_CallbackFunctionPointer != NULL) + { + Mock.vkGetDeviceMicromapCompatibilityEXT_CallbackFunctionPointer(device, pVersionInfo, pCompatibility, Mock.vkGetDeviceMicromapCompatibilityEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceMicromapCompatibilityEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pVersionInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceMicromapCompatibilityEXT,CMockString_pVersionInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pVersionInfo), (void*)(pVersionInfo), sizeof(const VkMicromapVersionInfoEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCompatibility) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceMicromapCompatibilityEXT,CMockString_pCompatibility); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCompatibility), (void*)(pCompatibility), sizeof(VkAccelerationStructureCompatibilityKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDeviceMicromapCompatibilityEXT_CallbackFunctionPointer != NULL) + { + Mock.vkGetDeviceMicromapCompatibilityEXT_CallbackFunctionPointer(device, pVersionInfo, pCompatibility, Mock.vkGetDeviceMicromapCompatibilityEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pCompatibility_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pCompatibility, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pCompatibility, (const void*)cmock_call_instance->ReturnThruPtr_pCompatibility_Val, + cmock_call_instance->ReturnThruPtr_pCompatibility_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetDeviceMicromapCompatibilityEXT(CMOCK_vkGetDeviceMicromapCompatibilityEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility); +void CMockExpectParameters_vkGetDeviceMicromapCompatibilityEXT(CMOCK_vkGetDeviceMicromapCompatibilityEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pVersionInfo = pVersionInfo; + cmock_call_instance->IgnoreArg_pVersionInfo = 0; + cmock_call_instance->Expected_pCompatibility = pCompatibility; + cmock_call_instance->IgnoreArg_pCompatibility = 0; + cmock_call_instance->ReturnThruPtr_pCompatibility_Used = 0; +} + +void vkGetDeviceMicromapCompatibilityEXT_CMockIgnore(void) +{ + Mock.vkGetDeviceMicromapCompatibilityEXT_IgnoreBool = (char)1; +} + +void vkGetDeviceMicromapCompatibilityEXT_CMockStopIgnore(void) +{ + Mock.vkGetDeviceMicromapCompatibilityEXT_IgnoreBool = (char)0; +} + +void vkGetDeviceMicromapCompatibilityEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceMicromapCompatibilityEXT_CALL_INSTANCE)); + CMOCK_vkGetDeviceMicromapCompatibilityEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceMicromapCompatibilityEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceMicromapCompatibilityEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceMicromapCompatibilityEXT_CallInstance, cmock_guts_index); + Mock.vkGetDeviceMicromapCompatibilityEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDeviceMicromapCompatibilityEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceMicromapCompatibilityEXT_CALL_INSTANCE)); + CMOCK_vkGetDeviceMicromapCompatibilityEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceMicromapCompatibilityEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceMicromapCompatibilityEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceMicromapCompatibilityEXT_CallInstance, cmock_guts_index); + Mock.vkGetDeviceMicromapCompatibilityEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDeviceMicromapCompatibilityEXT(cmock_call_instance, device, pVersionInfo, pCompatibility); +} + +void vkGetDeviceMicromapCompatibilityEXT_AddCallback(CMOCK_vkGetDeviceMicromapCompatibilityEXT_CALLBACK Callback) +{ + Mock.vkGetDeviceMicromapCompatibilityEXT_IgnoreBool = (char)0; + Mock.vkGetDeviceMicromapCompatibilityEXT_CallbackBool = (char)1; + Mock.vkGetDeviceMicromapCompatibilityEXT_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceMicromapCompatibilityEXT_Stub(CMOCK_vkGetDeviceMicromapCompatibilityEXT_CALLBACK Callback) +{ + Mock.vkGetDeviceMicromapCompatibilityEXT_IgnoreBool = (char)0; + Mock.vkGetDeviceMicromapCompatibilityEXT_CallbackBool = (char)0; + Mock.vkGetDeviceMicromapCompatibilityEXT_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceMicromapCompatibilityEXT_CMockReturnMemThruPtr_pCompatibility(UNITY_LINE_TYPE cmock_line, VkAccelerationStructureCompatibilityKHR const* pCompatibility, size_t cmock_size) +{ + CMOCK_vkGetDeviceMicromapCompatibilityEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceMicromapCompatibilityEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceMicromapCompatibilityEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pCompatibility_Used = 1; + cmock_call_instance->ReturnThruPtr_pCompatibility_Val = pCompatibility; + cmock_call_instance->ReturnThruPtr_pCompatibility_Size = cmock_size; +} + +void vkGetDeviceMicromapCompatibilityEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceMicromapCompatibilityEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceMicromapCompatibilityEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceMicromapCompatibilityEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetDeviceMicromapCompatibilityEXT_CMockIgnoreArg_pVersionInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceMicromapCompatibilityEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceMicromapCompatibilityEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceMicromapCompatibilityEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pVersionInfo = 1; +} + +void vkGetDeviceMicromapCompatibilityEXT_CMockIgnoreArg_pCompatibility(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceMicromapCompatibilityEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceMicromapCompatibilityEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceMicromapCompatibilityEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCompatibility = 1; +} + +void vkGetMicromapBuildSizesEXT(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetMicromapBuildSizesEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetMicromapBuildSizesEXT); + cmock_call_instance = (CMOCK_vkGetMicromapBuildSizesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetMicromapBuildSizesEXT_CallInstance); + Mock.vkGetMicromapBuildSizesEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetMicromapBuildSizesEXT_CallInstance); + if (Mock.vkGetMicromapBuildSizesEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetMicromapBuildSizesEXT_CallbackBool && + Mock.vkGetMicromapBuildSizesEXT_CallbackFunctionPointer != NULL) + { + Mock.vkGetMicromapBuildSizesEXT_CallbackFunctionPointer(device, buildType, pBuildInfo, pSizeInfo, Mock.vkGetMicromapBuildSizesEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetMicromapBuildSizesEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_buildType) + { + UNITY_SET_DETAILS(CMockString_vkGetMicromapBuildSizesEXT,CMockString_buildType); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_buildType), (void*)(&buildType), sizeof(VkAccelerationStructureBuildTypeKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pBuildInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetMicromapBuildSizesEXT,CMockString_pBuildInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pBuildInfo), (void*)(pBuildInfo), sizeof(const VkMicromapBuildInfoEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSizeInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetMicromapBuildSizesEXT,CMockString_pSizeInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSizeInfo), (void*)(pSizeInfo), sizeof(VkMicromapBuildSizesInfoEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetMicromapBuildSizesEXT_CallbackFunctionPointer != NULL) + { + Mock.vkGetMicromapBuildSizesEXT_CallbackFunctionPointer(device, buildType, pBuildInfo, pSizeInfo, Mock.vkGetMicromapBuildSizesEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pSizeInfo_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSizeInfo, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSizeInfo, (const void*)cmock_call_instance->ReturnThruPtr_pSizeInfo_Val, + cmock_call_instance->ReturnThruPtr_pSizeInfo_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetMicromapBuildSizesEXT(CMOCK_vkGetMicromapBuildSizesEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo); +void CMockExpectParameters_vkGetMicromapBuildSizesEXT(CMOCK_vkGetMicromapBuildSizesEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_buildType), (void*)(&buildType), + sizeof(VkAccelerationStructureBuildTypeKHR[sizeof(buildType) == sizeof(VkAccelerationStructureBuildTypeKHR) ? 1 : -1])); /* add VkAccelerationStructureBuildTypeKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_buildType = 0; + cmock_call_instance->Expected_pBuildInfo = pBuildInfo; + cmock_call_instance->IgnoreArg_pBuildInfo = 0; + cmock_call_instance->Expected_pSizeInfo = pSizeInfo; + cmock_call_instance->IgnoreArg_pSizeInfo = 0; + cmock_call_instance->ReturnThruPtr_pSizeInfo_Used = 0; +} + +void vkGetMicromapBuildSizesEXT_CMockIgnore(void) +{ + Mock.vkGetMicromapBuildSizesEXT_IgnoreBool = (char)1; +} + +void vkGetMicromapBuildSizesEXT_CMockStopIgnore(void) +{ + Mock.vkGetMicromapBuildSizesEXT_IgnoreBool = (char)0; +} + +void vkGetMicromapBuildSizesEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetMicromapBuildSizesEXT_CALL_INSTANCE)); + CMOCK_vkGetMicromapBuildSizesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMicromapBuildSizesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetMicromapBuildSizesEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetMicromapBuildSizesEXT_CallInstance, cmock_guts_index); + Mock.vkGetMicromapBuildSizesEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetMicromapBuildSizesEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetMicromapBuildSizesEXT_CALL_INSTANCE)); + CMOCK_vkGetMicromapBuildSizesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMicromapBuildSizesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetMicromapBuildSizesEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetMicromapBuildSizesEXT_CallInstance, cmock_guts_index); + Mock.vkGetMicromapBuildSizesEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetMicromapBuildSizesEXT(cmock_call_instance, device, buildType, pBuildInfo, pSizeInfo); +} + +void vkGetMicromapBuildSizesEXT_AddCallback(CMOCK_vkGetMicromapBuildSizesEXT_CALLBACK Callback) +{ + Mock.vkGetMicromapBuildSizesEXT_IgnoreBool = (char)0; + Mock.vkGetMicromapBuildSizesEXT_CallbackBool = (char)1; + Mock.vkGetMicromapBuildSizesEXT_CallbackFunctionPointer = Callback; +} + +void vkGetMicromapBuildSizesEXT_Stub(CMOCK_vkGetMicromapBuildSizesEXT_CALLBACK Callback) +{ + Mock.vkGetMicromapBuildSizesEXT_IgnoreBool = (char)0; + Mock.vkGetMicromapBuildSizesEXT_CallbackBool = (char)0; + Mock.vkGetMicromapBuildSizesEXT_CallbackFunctionPointer = Callback; +} + +void vkGetMicromapBuildSizesEXT_CMockReturnMemThruPtr_pSizeInfo(UNITY_LINE_TYPE cmock_line, VkMicromapBuildSizesInfoEXT const* pSizeInfo, size_t cmock_size) +{ + CMOCK_vkGetMicromapBuildSizesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMicromapBuildSizesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetMicromapBuildSizesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSizeInfo_Used = 1; + cmock_call_instance->ReturnThruPtr_pSizeInfo_Val = pSizeInfo; + cmock_call_instance->ReturnThruPtr_pSizeInfo_Size = cmock_size; +} + +void vkGetMicromapBuildSizesEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetMicromapBuildSizesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMicromapBuildSizesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetMicromapBuildSizesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetMicromapBuildSizesEXT_CMockIgnoreArg_buildType(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetMicromapBuildSizesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMicromapBuildSizesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetMicromapBuildSizesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_buildType = 1; +} + +void vkGetMicromapBuildSizesEXT_CMockIgnoreArg_pBuildInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetMicromapBuildSizesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMicromapBuildSizesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetMicromapBuildSizesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pBuildInfo = 1; +} + +void vkGetMicromapBuildSizesEXT_CMockIgnoreArg_pSizeInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetMicromapBuildSizesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetMicromapBuildSizesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetMicromapBuildSizesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSizeInfo = 1; +} + +void vkCmdDrawClusterHUAWEI(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDrawClusterHUAWEI_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDrawClusterHUAWEI); + cmock_call_instance = (CMOCK_vkCmdDrawClusterHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDrawClusterHUAWEI_CallInstance); + Mock.vkCmdDrawClusterHUAWEI_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDrawClusterHUAWEI_CallInstance); + if (Mock.vkCmdDrawClusterHUAWEI_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDrawClusterHUAWEI_CallbackBool && + Mock.vkCmdDrawClusterHUAWEI_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawClusterHUAWEI_CallbackFunctionPointer(commandBuffer, groupCountX, groupCountY, groupCountZ, Mock.vkCmdDrawClusterHUAWEI_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawClusterHUAWEI,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_groupCountX) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawClusterHUAWEI,CMockString_groupCountX); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_groupCountX, groupCountX, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_groupCountY) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawClusterHUAWEI,CMockString_groupCountY); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_groupCountY, groupCountY, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_groupCountZ) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawClusterHUAWEI,CMockString_groupCountZ); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_groupCountZ, groupCountZ, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdDrawClusterHUAWEI_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawClusterHUAWEI_CallbackFunctionPointer(commandBuffer, groupCountX, groupCountY, groupCountZ, Mock.vkCmdDrawClusterHUAWEI_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDrawClusterHUAWEI(CMOCK_vkCmdDrawClusterHUAWEI_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +void CMockExpectParameters_vkCmdDrawClusterHUAWEI(CMOCK_vkCmdDrawClusterHUAWEI_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_groupCountX = groupCountX; + cmock_call_instance->IgnoreArg_groupCountX = 0; + cmock_call_instance->Expected_groupCountY = groupCountY; + cmock_call_instance->IgnoreArg_groupCountY = 0; + cmock_call_instance->Expected_groupCountZ = groupCountZ; + cmock_call_instance->IgnoreArg_groupCountZ = 0; +} + +void vkCmdDrawClusterHUAWEI_CMockIgnore(void) +{ + Mock.vkCmdDrawClusterHUAWEI_IgnoreBool = (char)1; +} + +void vkCmdDrawClusterHUAWEI_CMockStopIgnore(void) +{ + Mock.vkCmdDrawClusterHUAWEI_IgnoreBool = (char)0; +} + +void vkCmdDrawClusterHUAWEI_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawClusterHUAWEI_CALL_INSTANCE)); + CMOCK_vkCmdDrawClusterHUAWEI_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawClusterHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawClusterHUAWEI_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawClusterHUAWEI_CallInstance, cmock_guts_index); + Mock.vkCmdDrawClusterHUAWEI_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDrawClusterHUAWEI_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawClusterHUAWEI_CALL_INSTANCE)); + CMOCK_vkCmdDrawClusterHUAWEI_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawClusterHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawClusterHUAWEI_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawClusterHUAWEI_CallInstance, cmock_guts_index); + Mock.vkCmdDrawClusterHUAWEI_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDrawClusterHUAWEI(cmock_call_instance, commandBuffer, groupCountX, groupCountY, groupCountZ); +} + +void vkCmdDrawClusterHUAWEI_AddCallback(CMOCK_vkCmdDrawClusterHUAWEI_CALLBACK Callback) +{ + Mock.vkCmdDrawClusterHUAWEI_IgnoreBool = (char)0; + Mock.vkCmdDrawClusterHUAWEI_CallbackBool = (char)1; + Mock.vkCmdDrawClusterHUAWEI_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawClusterHUAWEI_Stub(CMOCK_vkCmdDrawClusterHUAWEI_CALLBACK Callback) +{ + Mock.vkCmdDrawClusterHUAWEI_IgnoreBool = (char)0; + Mock.vkCmdDrawClusterHUAWEI_CallbackBool = (char)0; + Mock.vkCmdDrawClusterHUAWEI_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawClusterHUAWEI_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawClusterHUAWEI_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawClusterHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawClusterHUAWEI_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDrawClusterHUAWEI_CMockIgnoreArg_groupCountX(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawClusterHUAWEI_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawClusterHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawClusterHUAWEI_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_groupCountX = 1; +} + +void vkCmdDrawClusterHUAWEI_CMockIgnoreArg_groupCountY(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawClusterHUAWEI_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawClusterHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawClusterHUAWEI_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_groupCountY = 1; +} + +void vkCmdDrawClusterHUAWEI_CMockIgnoreArg_groupCountZ(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawClusterHUAWEI_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawClusterHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawClusterHUAWEI_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_groupCountZ = 1; +} + +void vkCmdDrawClusterIndirectHUAWEI(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDrawClusterIndirectHUAWEI_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDrawClusterIndirectHUAWEI); + cmock_call_instance = (CMOCK_vkCmdDrawClusterIndirectHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDrawClusterIndirectHUAWEI_CallInstance); + Mock.vkCmdDrawClusterIndirectHUAWEI_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDrawClusterIndirectHUAWEI_CallInstance); + if (Mock.vkCmdDrawClusterIndirectHUAWEI_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDrawClusterIndirectHUAWEI_CallbackBool && + Mock.vkCmdDrawClusterIndirectHUAWEI_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawClusterIndirectHUAWEI_CallbackFunctionPointer(commandBuffer, buffer, offset, Mock.vkCmdDrawClusterIndirectHUAWEI_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawClusterIndirectHUAWEI,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_buffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawClusterIndirectHUAWEI,CMockString_buffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_offset) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawClusterIndirectHUAWEI,CMockString_offset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdDrawClusterIndirectHUAWEI_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawClusterIndirectHUAWEI_CallbackFunctionPointer(commandBuffer, buffer, offset, Mock.vkCmdDrawClusterIndirectHUAWEI_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDrawClusterIndirectHUAWEI(CMOCK_vkCmdDrawClusterIndirectHUAWEI_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); +void CMockExpectParameters_vkCmdDrawClusterIndirectHUAWEI(CMOCK_vkCmdDrawClusterIndirectHUAWEI_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), + sizeof(VkBuffer[sizeof(buffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_buffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), + sizeof(VkDeviceSize[sizeof(offset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_offset = 0; +} + +void vkCmdDrawClusterIndirectHUAWEI_CMockIgnore(void) +{ + Mock.vkCmdDrawClusterIndirectHUAWEI_IgnoreBool = (char)1; +} + +void vkCmdDrawClusterIndirectHUAWEI_CMockStopIgnore(void) +{ + Mock.vkCmdDrawClusterIndirectHUAWEI_IgnoreBool = (char)0; +} + +void vkCmdDrawClusterIndirectHUAWEI_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawClusterIndirectHUAWEI_CALL_INSTANCE)); + CMOCK_vkCmdDrawClusterIndirectHUAWEI_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawClusterIndirectHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawClusterIndirectHUAWEI_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawClusterIndirectHUAWEI_CallInstance, cmock_guts_index); + Mock.vkCmdDrawClusterIndirectHUAWEI_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDrawClusterIndirectHUAWEI_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawClusterIndirectHUAWEI_CALL_INSTANCE)); + CMOCK_vkCmdDrawClusterIndirectHUAWEI_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawClusterIndirectHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawClusterIndirectHUAWEI_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawClusterIndirectHUAWEI_CallInstance, cmock_guts_index); + Mock.vkCmdDrawClusterIndirectHUAWEI_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDrawClusterIndirectHUAWEI(cmock_call_instance, commandBuffer, buffer, offset); +} + +void vkCmdDrawClusterIndirectHUAWEI_AddCallback(CMOCK_vkCmdDrawClusterIndirectHUAWEI_CALLBACK Callback) +{ + Mock.vkCmdDrawClusterIndirectHUAWEI_IgnoreBool = (char)0; + Mock.vkCmdDrawClusterIndirectHUAWEI_CallbackBool = (char)1; + Mock.vkCmdDrawClusterIndirectHUAWEI_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawClusterIndirectHUAWEI_Stub(CMOCK_vkCmdDrawClusterIndirectHUAWEI_CALLBACK Callback) +{ + Mock.vkCmdDrawClusterIndirectHUAWEI_IgnoreBool = (char)0; + Mock.vkCmdDrawClusterIndirectHUAWEI_CallbackBool = (char)0; + Mock.vkCmdDrawClusterIndirectHUAWEI_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawClusterIndirectHUAWEI_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawClusterIndirectHUAWEI_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawClusterIndirectHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawClusterIndirectHUAWEI_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDrawClusterIndirectHUAWEI_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawClusterIndirectHUAWEI_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawClusterIndirectHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawClusterIndirectHUAWEI_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_buffer = 1; +} + +void vkCmdDrawClusterIndirectHUAWEI_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawClusterIndirectHUAWEI_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawClusterIndirectHUAWEI_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawClusterIndirectHUAWEI_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_offset = 1; +} + +void vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkSetDeviceMemoryPriorityEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkSetDeviceMemoryPriorityEXT); + cmock_call_instance = (CMOCK_vkSetDeviceMemoryPriorityEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkSetDeviceMemoryPriorityEXT_CallInstance); + Mock.vkSetDeviceMemoryPriorityEXT_CallInstance = CMock_Guts_MemNext(Mock.vkSetDeviceMemoryPriorityEXT_CallInstance); + if (Mock.vkSetDeviceMemoryPriorityEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkSetDeviceMemoryPriorityEXT_CallbackBool && + Mock.vkSetDeviceMemoryPriorityEXT_CallbackFunctionPointer != NULL) + { + Mock.vkSetDeviceMemoryPriorityEXT_CallbackFunctionPointer(device, memory, priority, Mock.vkSetDeviceMemoryPriorityEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkSetDeviceMemoryPriorityEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_memory) + { + UNITY_SET_DETAILS(CMockString_vkSetDeviceMemoryPriorityEXT,CMockString_memory); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_memory), (void*)(&memory), sizeof(VkDeviceMemory), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_priority) + { + UNITY_SET_DETAILS(CMockString_vkSetDeviceMemoryPriorityEXT,CMockString_priority); + UNITY_TEST_ASSERT_EQUAL_FLOAT(cmock_call_instance->Expected_priority, priority, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkSetDeviceMemoryPriorityEXT_CallbackFunctionPointer != NULL) + { + Mock.vkSetDeviceMemoryPriorityEXT_CallbackFunctionPointer(device, memory, priority, Mock.vkSetDeviceMemoryPriorityEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkSetDeviceMemoryPriorityEXT(CMOCK_vkSetDeviceMemoryPriorityEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeviceMemory memory, float priority); +void CMockExpectParameters_vkSetDeviceMemoryPriorityEXT(CMOCK_vkSetDeviceMemoryPriorityEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeviceMemory memory, float priority) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_memory), (void*)(&memory), + sizeof(VkDeviceMemory[sizeof(memory) == sizeof(VkDeviceMemory) ? 1 : -1])); /* add VkDeviceMemory to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_memory = 0; + cmock_call_instance->Expected_priority = priority; + cmock_call_instance->IgnoreArg_priority = 0; +} + +void vkSetDeviceMemoryPriorityEXT_CMockIgnore(void) +{ + Mock.vkSetDeviceMemoryPriorityEXT_IgnoreBool = (char)1; +} + +void vkSetDeviceMemoryPriorityEXT_CMockStopIgnore(void) +{ + Mock.vkSetDeviceMemoryPriorityEXT_IgnoreBool = (char)0; +} + +void vkSetDeviceMemoryPriorityEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkSetDeviceMemoryPriorityEXT_CALL_INSTANCE)); + CMOCK_vkSetDeviceMemoryPriorityEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetDeviceMemoryPriorityEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkSetDeviceMemoryPriorityEXT_CallInstance = CMock_Guts_MemChain(Mock.vkSetDeviceMemoryPriorityEXT_CallInstance, cmock_guts_index); + Mock.vkSetDeviceMemoryPriorityEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkSetDeviceMemoryPriorityEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeviceMemory memory, float priority) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkSetDeviceMemoryPriorityEXT_CALL_INSTANCE)); + CMOCK_vkSetDeviceMemoryPriorityEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetDeviceMemoryPriorityEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkSetDeviceMemoryPriorityEXT_CallInstance = CMock_Guts_MemChain(Mock.vkSetDeviceMemoryPriorityEXT_CallInstance, cmock_guts_index); + Mock.vkSetDeviceMemoryPriorityEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkSetDeviceMemoryPriorityEXT(cmock_call_instance, device, memory, priority); +} + +void vkSetDeviceMemoryPriorityEXT_AddCallback(CMOCK_vkSetDeviceMemoryPriorityEXT_CALLBACK Callback) +{ + Mock.vkSetDeviceMemoryPriorityEXT_IgnoreBool = (char)0; + Mock.vkSetDeviceMemoryPriorityEXT_CallbackBool = (char)1; + Mock.vkSetDeviceMemoryPriorityEXT_CallbackFunctionPointer = Callback; +} + +void vkSetDeviceMemoryPriorityEXT_Stub(CMOCK_vkSetDeviceMemoryPriorityEXT_CALLBACK Callback) +{ + Mock.vkSetDeviceMemoryPriorityEXT_IgnoreBool = (char)0; + Mock.vkSetDeviceMemoryPriorityEXT_CallbackBool = (char)0; + Mock.vkSetDeviceMemoryPriorityEXT_CallbackFunctionPointer = Callback; +} + +void vkSetDeviceMemoryPriorityEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSetDeviceMemoryPriorityEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetDeviceMemoryPriorityEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSetDeviceMemoryPriorityEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkSetDeviceMemoryPriorityEXT_CMockIgnoreArg_memory(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSetDeviceMemoryPriorityEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetDeviceMemoryPriorityEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSetDeviceMemoryPriorityEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_memory = 1; +} + +void vkSetDeviceMemoryPriorityEXT_CMockIgnoreArg_priority(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkSetDeviceMemoryPriorityEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkSetDeviceMemoryPriorityEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkSetDeviceMemoryPriorityEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_priority = 1; +} + +void vkGetDescriptorSetLayoutHostMappingInfoVALVE(VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDescriptorSetLayoutHostMappingInfoVALVE_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDescriptorSetLayoutHostMappingInfoVALVE); + cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutHostMappingInfoVALVE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_CallInstance); + Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_CallInstance = CMock_Guts_MemNext(Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_CallInstance); + if (Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_CallbackBool && + Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_CallbackFunctionPointer != NULL) + { + Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_CallbackFunctionPointer(device, pBindingReference, pHostMapping, Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetDescriptorSetLayoutHostMappingInfoVALVE,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pBindingReference) + { + UNITY_SET_DETAILS(CMockString_vkGetDescriptorSetLayoutHostMappingInfoVALVE,CMockString_pBindingReference); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pBindingReference), (void*)(pBindingReference), sizeof(const VkDescriptorSetBindingReferenceVALVE), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pHostMapping) + { + UNITY_SET_DETAILS(CMockString_vkGetDescriptorSetLayoutHostMappingInfoVALVE,CMockString_pHostMapping); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pHostMapping), (void*)(pHostMapping), sizeof(VkDescriptorSetLayoutHostMappingInfoVALVE), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_CallbackFunctionPointer != NULL) + { + Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_CallbackFunctionPointer(device, pBindingReference, pHostMapping, Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pHostMapping_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pHostMapping, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pHostMapping, (const void*)cmock_call_instance->ReturnThruPtr_pHostMapping_Val, + cmock_call_instance->ReturnThruPtr_pHostMapping_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetDescriptorSetLayoutHostMappingInfoVALVE(CMOCK_vkGetDescriptorSetLayoutHostMappingInfoVALVE_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping); +void CMockExpectParameters_vkGetDescriptorSetLayoutHostMappingInfoVALVE(CMOCK_vkGetDescriptorSetLayoutHostMappingInfoVALVE_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pBindingReference = pBindingReference; + cmock_call_instance->IgnoreArg_pBindingReference = 0; + cmock_call_instance->Expected_pHostMapping = pHostMapping; + cmock_call_instance->IgnoreArg_pHostMapping = 0; + cmock_call_instance->ReturnThruPtr_pHostMapping_Used = 0; +} + +void vkGetDescriptorSetLayoutHostMappingInfoVALVE_CMockIgnore(void) +{ + Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_IgnoreBool = (char)1; +} + +void vkGetDescriptorSetLayoutHostMappingInfoVALVE_CMockStopIgnore(void) +{ + Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_IgnoreBool = (char)0; +} + +void vkGetDescriptorSetLayoutHostMappingInfoVALVE_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDescriptorSetLayoutHostMappingInfoVALVE_CALL_INSTANCE)); + CMOCK_vkGetDescriptorSetLayoutHostMappingInfoVALVE_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutHostMappingInfoVALVE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_CallInstance = CMock_Guts_MemChain(Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_CallInstance, cmock_guts_index); + Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDescriptorSetLayoutHostMappingInfoVALVE_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDescriptorSetLayoutHostMappingInfoVALVE_CALL_INSTANCE)); + CMOCK_vkGetDescriptorSetLayoutHostMappingInfoVALVE_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutHostMappingInfoVALVE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_CallInstance = CMock_Guts_MemChain(Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_CallInstance, cmock_guts_index); + Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDescriptorSetLayoutHostMappingInfoVALVE(cmock_call_instance, device, pBindingReference, pHostMapping); +} + +void vkGetDescriptorSetLayoutHostMappingInfoVALVE_AddCallback(CMOCK_vkGetDescriptorSetLayoutHostMappingInfoVALVE_CALLBACK Callback) +{ + Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_IgnoreBool = (char)0; + Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_CallbackBool = (char)1; + Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_CallbackFunctionPointer = Callback; +} + +void vkGetDescriptorSetLayoutHostMappingInfoVALVE_Stub(CMOCK_vkGetDescriptorSetLayoutHostMappingInfoVALVE_CALLBACK Callback) +{ + Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_IgnoreBool = (char)0; + Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_CallbackBool = (char)0; + Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_CallbackFunctionPointer = Callback; +} + +void vkGetDescriptorSetLayoutHostMappingInfoVALVE_CMockReturnMemThruPtr_pHostMapping(UNITY_LINE_TYPE cmock_line, VkDescriptorSetLayoutHostMappingInfoVALVE const* pHostMapping, size_t cmock_size) +{ + CMOCK_vkGetDescriptorSetLayoutHostMappingInfoVALVE_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutHostMappingInfoVALVE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pHostMapping_Used = 1; + cmock_call_instance->ReturnThruPtr_pHostMapping_Val = pHostMapping; + cmock_call_instance->ReturnThruPtr_pHostMapping_Size = cmock_size; +} + +void vkGetDescriptorSetLayoutHostMappingInfoVALVE_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDescriptorSetLayoutHostMappingInfoVALVE_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutHostMappingInfoVALVE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetDescriptorSetLayoutHostMappingInfoVALVE_CMockIgnoreArg_pBindingReference(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDescriptorSetLayoutHostMappingInfoVALVE_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutHostMappingInfoVALVE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pBindingReference = 1; +} + +void vkGetDescriptorSetLayoutHostMappingInfoVALVE_CMockIgnoreArg_pHostMapping(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDescriptorSetLayoutHostMappingInfoVALVE_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetLayoutHostMappingInfoVALVE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDescriptorSetLayoutHostMappingInfoVALVE_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pHostMapping = 1; +} + +void vkGetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, void** ppData) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDescriptorSetHostMappingVALVE_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDescriptorSetHostMappingVALVE); + cmock_call_instance = (CMOCK_vkGetDescriptorSetHostMappingVALVE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDescriptorSetHostMappingVALVE_CallInstance); + Mock.vkGetDescriptorSetHostMappingVALVE_CallInstance = CMock_Guts_MemNext(Mock.vkGetDescriptorSetHostMappingVALVE_CallInstance); + if (Mock.vkGetDescriptorSetHostMappingVALVE_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetDescriptorSetHostMappingVALVE_CallbackBool && + Mock.vkGetDescriptorSetHostMappingVALVE_CallbackFunctionPointer != NULL) + { + Mock.vkGetDescriptorSetHostMappingVALVE_CallbackFunctionPointer(device, descriptorSet, ppData, Mock.vkGetDescriptorSetHostMappingVALVE_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetDescriptorSetHostMappingVALVE,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_descriptorSet) + { + UNITY_SET_DETAILS(CMockString_vkGetDescriptorSetHostMappingVALVE,CMockString_descriptorSet); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_descriptorSet), (void*)(&descriptorSet), sizeof(VkDescriptorSet), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_ppData) + { + UNITY_SET_DETAILS(CMockString_vkGetDescriptorSetHostMappingVALVE,CMockString_ppData); + UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_ppData, ppData, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDescriptorSetHostMappingVALVE_CallbackFunctionPointer != NULL) + { + Mock.vkGetDescriptorSetHostMappingVALVE_CallbackFunctionPointer(device, descriptorSet, ppData, Mock.vkGetDescriptorSetHostMappingVALVE_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_ppData_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(ppData, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)ppData, (const void*)cmock_call_instance->ReturnThruPtr_ppData_Val, + cmock_call_instance->ReturnThruPtr_ppData_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetDescriptorSetHostMappingVALVE(CMOCK_vkGetDescriptorSetHostMappingVALVE_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDescriptorSet descriptorSet, void** ppData); +void CMockExpectParameters_vkGetDescriptorSetHostMappingVALVE(CMOCK_vkGetDescriptorSetHostMappingVALVE_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDescriptorSet descriptorSet, void** ppData) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_descriptorSet), (void*)(&descriptorSet), + sizeof(VkDescriptorSet[sizeof(descriptorSet) == sizeof(VkDescriptorSet) ? 1 : -1])); /* add VkDescriptorSet to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_descriptorSet = 0; + cmock_call_instance->Expected_ppData = ppData; + cmock_call_instance->IgnoreArg_ppData = 0; + cmock_call_instance->ReturnThruPtr_ppData_Used = 0; +} + +void vkGetDescriptorSetHostMappingVALVE_CMockIgnore(void) +{ + Mock.vkGetDescriptorSetHostMappingVALVE_IgnoreBool = (char)1; +} + +void vkGetDescriptorSetHostMappingVALVE_CMockStopIgnore(void) +{ + Mock.vkGetDescriptorSetHostMappingVALVE_IgnoreBool = (char)0; +} + +void vkGetDescriptorSetHostMappingVALVE_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDescriptorSetHostMappingVALVE_CALL_INSTANCE)); + CMOCK_vkGetDescriptorSetHostMappingVALVE_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetHostMappingVALVE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDescriptorSetHostMappingVALVE_CallInstance = CMock_Guts_MemChain(Mock.vkGetDescriptorSetHostMappingVALVE_CallInstance, cmock_guts_index); + Mock.vkGetDescriptorSetHostMappingVALVE_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDescriptorSetHostMappingVALVE_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDescriptorSet descriptorSet, void** ppData) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDescriptorSetHostMappingVALVE_CALL_INSTANCE)); + CMOCK_vkGetDescriptorSetHostMappingVALVE_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetHostMappingVALVE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDescriptorSetHostMappingVALVE_CallInstance = CMock_Guts_MemChain(Mock.vkGetDescriptorSetHostMappingVALVE_CallInstance, cmock_guts_index); + Mock.vkGetDescriptorSetHostMappingVALVE_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDescriptorSetHostMappingVALVE(cmock_call_instance, device, descriptorSet, ppData); +} + +void vkGetDescriptorSetHostMappingVALVE_AddCallback(CMOCK_vkGetDescriptorSetHostMappingVALVE_CALLBACK Callback) +{ + Mock.vkGetDescriptorSetHostMappingVALVE_IgnoreBool = (char)0; + Mock.vkGetDescriptorSetHostMappingVALVE_CallbackBool = (char)1; + Mock.vkGetDescriptorSetHostMappingVALVE_CallbackFunctionPointer = Callback; +} + +void vkGetDescriptorSetHostMappingVALVE_Stub(CMOCK_vkGetDescriptorSetHostMappingVALVE_CALLBACK Callback) +{ + Mock.vkGetDescriptorSetHostMappingVALVE_IgnoreBool = (char)0; + Mock.vkGetDescriptorSetHostMappingVALVE_CallbackBool = (char)0; + Mock.vkGetDescriptorSetHostMappingVALVE_CallbackFunctionPointer = Callback; +} + +void vkGetDescriptorSetHostMappingVALVE_CMockReturnMemThruPtr_ppData(UNITY_LINE_TYPE cmock_line, void* const* ppData, size_t cmock_size) +{ + CMOCK_vkGetDescriptorSetHostMappingVALVE_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetHostMappingVALVE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDescriptorSetHostMappingVALVE_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_ppData_Used = 1; + cmock_call_instance->ReturnThruPtr_ppData_Val = ppData; + cmock_call_instance->ReturnThruPtr_ppData_Size = cmock_size; +} + +void vkGetDescriptorSetHostMappingVALVE_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDescriptorSetHostMappingVALVE_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetHostMappingVALVE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDescriptorSetHostMappingVALVE_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetDescriptorSetHostMappingVALVE_CMockIgnoreArg_descriptorSet(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDescriptorSetHostMappingVALVE_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetHostMappingVALVE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDescriptorSetHostMappingVALVE_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_descriptorSet = 1; +} + +void vkGetDescriptorSetHostMappingVALVE_CMockIgnoreArg_ppData(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDescriptorSetHostMappingVALVE_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDescriptorSetHostMappingVALVE_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDescriptorSetHostMappingVALVE_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_ppData = 1; +} + +void vkCmdCopyMemoryIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdCopyMemoryIndirectNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdCopyMemoryIndirectNV); + cmock_call_instance = (CMOCK_vkCmdCopyMemoryIndirectNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdCopyMemoryIndirectNV_CallInstance); + Mock.vkCmdCopyMemoryIndirectNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdCopyMemoryIndirectNV_CallInstance); + if (Mock.vkCmdCopyMemoryIndirectNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdCopyMemoryIndirectNV_CallbackBool && + Mock.vkCmdCopyMemoryIndirectNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyMemoryIndirectNV_CallbackFunctionPointer(commandBuffer, copyBufferAddress, copyCount, stride, Mock.vkCmdCopyMemoryIndirectNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyMemoryIndirectNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_copyBufferAddress) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyMemoryIndirectNV,CMockString_copyBufferAddress); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_copyBufferAddress), (void*)(©BufferAddress), sizeof(VkDeviceAddress), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_copyCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyMemoryIndirectNV,CMockString_copyCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_copyCount, copyCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_stride) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyMemoryIndirectNV,CMockString_stride); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_stride, stride, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdCopyMemoryIndirectNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyMemoryIndirectNV_CallbackFunctionPointer(commandBuffer, copyBufferAddress, copyCount, stride, Mock.vkCmdCopyMemoryIndirectNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdCopyMemoryIndirectNV(CMOCK_vkCmdCopyMemoryIndirectNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride); +void CMockExpectParameters_vkCmdCopyMemoryIndirectNV(CMOCK_vkCmdCopyMemoryIndirectNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_copyBufferAddress), (void*)(©BufferAddress), + sizeof(VkDeviceAddress[sizeof(copyBufferAddress) == sizeof(VkDeviceAddress) ? 1 : -1])); /* add VkDeviceAddress to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_copyBufferAddress = 0; + cmock_call_instance->Expected_copyCount = copyCount; + cmock_call_instance->IgnoreArg_copyCount = 0; + cmock_call_instance->Expected_stride = stride; + cmock_call_instance->IgnoreArg_stride = 0; +} + +void vkCmdCopyMemoryIndirectNV_CMockIgnore(void) +{ + Mock.vkCmdCopyMemoryIndirectNV_IgnoreBool = (char)1; +} + +void vkCmdCopyMemoryIndirectNV_CMockStopIgnore(void) +{ + Mock.vkCmdCopyMemoryIndirectNV_IgnoreBool = (char)0; +} + +void vkCmdCopyMemoryIndirectNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyMemoryIndirectNV_CALL_INSTANCE)); + CMOCK_vkCmdCopyMemoryIndirectNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMemoryIndirectNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyMemoryIndirectNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyMemoryIndirectNV_CallInstance, cmock_guts_index); + Mock.vkCmdCopyMemoryIndirectNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdCopyMemoryIndirectNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyMemoryIndirectNV_CALL_INSTANCE)); + CMOCK_vkCmdCopyMemoryIndirectNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMemoryIndirectNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyMemoryIndirectNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyMemoryIndirectNV_CallInstance, cmock_guts_index); + Mock.vkCmdCopyMemoryIndirectNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdCopyMemoryIndirectNV(cmock_call_instance, commandBuffer, copyBufferAddress, copyCount, stride); +} + +void vkCmdCopyMemoryIndirectNV_AddCallback(CMOCK_vkCmdCopyMemoryIndirectNV_CALLBACK Callback) +{ + Mock.vkCmdCopyMemoryIndirectNV_IgnoreBool = (char)0; + Mock.vkCmdCopyMemoryIndirectNV_CallbackBool = (char)1; + Mock.vkCmdCopyMemoryIndirectNV_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyMemoryIndirectNV_Stub(CMOCK_vkCmdCopyMemoryIndirectNV_CALLBACK Callback) +{ + Mock.vkCmdCopyMemoryIndirectNV_IgnoreBool = (char)0; + Mock.vkCmdCopyMemoryIndirectNV_CallbackBool = (char)0; + Mock.vkCmdCopyMemoryIndirectNV_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyMemoryIndirectNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyMemoryIndirectNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMemoryIndirectNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyMemoryIndirectNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdCopyMemoryIndirectNV_CMockIgnoreArg_copyBufferAddress(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyMemoryIndirectNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMemoryIndirectNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyMemoryIndirectNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_copyBufferAddress = 1; +} + +void vkCmdCopyMemoryIndirectNV_CMockIgnoreArg_copyCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyMemoryIndirectNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMemoryIndirectNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyMemoryIndirectNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_copyCount = 1; +} + +void vkCmdCopyMemoryIndirectNV_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyMemoryIndirectNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMemoryIndirectNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyMemoryIndirectNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stride = 1; +} + +void vkCmdCopyMemoryToImageIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers* pImageSubresources) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdCopyMemoryToImageIndirectNV); + cmock_call_instance = (CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdCopyMemoryToImageIndirectNV_CallInstance); + Mock.vkCmdCopyMemoryToImageIndirectNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdCopyMemoryToImageIndirectNV_CallInstance); + if (Mock.vkCmdCopyMemoryToImageIndirectNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdCopyMemoryToImageIndirectNV_CallbackBool && + Mock.vkCmdCopyMemoryToImageIndirectNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyMemoryToImageIndirectNV_CallbackFunctionPointer(commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources, Mock.vkCmdCopyMemoryToImageIndirectNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyMemoryToImageIndirectNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_copyBufferAddress) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyMemoryToImageIndirectNV,CMockString_copyBufferAddress); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_copyBufferAddress), (void*)(©BufferAddress), sizeof(VkDeviceAddress), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_copyCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyMemoryToImageIndirectNV,CMockString_copyCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_copyCount, copyCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_stride) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyMemoryToImageIndirectNV,CMockString_stride); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_stride, stride, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dstImage) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyMemoryToImageIndirectNV,CMockString_dstImage); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dstImage), (void*)(&dstImage), sizeof(VkImage), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dstImageLayout) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyMemoryToImageIndirectNV,CMockString_dstImageLayout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dstImageLayout), (void*)(&dstImageLayout), sizeof(VkImageLayout), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pImageSubresources) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyMemoryToImageIndirectNV,CMockString_pImageSubresources); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pImageSubresources), (void*)(pImageSubresources), sizeof(const VkImageSubresourceLayers), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdCopyMemoryToImageIndirectNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyMemoryToImageIndirectNV_CallbackFunctionPointer(commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources, Mock.vkCmdCopyMemoryToImageIndirectNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdCopyMemoryToImageIndirectNV(CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers* pImageSubresources); +void CMockExpectParameters_vkCmdCopyMemoryToImageIndirectNV(CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers* pImageSubresources) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_copyBufferAddress), (void*)(©BufferAddress), + sizeof(VkDeviceAddress[sizeof(copyBufferAddress) == sizeof(VkDeviceAddress) ? 1 : -1])); /* add VkDeviceAddress to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_copyBufferAddress = 0; + cmock_call_instance->Expected_copyCount = copyCount; + cmock_call_instance->IgnoreArg_copyCount = 0; + cmock_call_instance->Expected_stride = stride; + cmock_call_instance->IgnoreArg_stride = 0; + memcpy((void*)(&cmock_call_instance->Expected_dstImage), (void*)(&dstImage), + sizeof(VkImage[sizeof(dstImage) == sizeof(VkImage) ? 1 : -1])); /* add VkImage to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dstImage = 0; + memcpy((void*)(&cmock_call_instance->Expected_dstImageLayout), (void*)(&dstImageLayout), + sizeof(VkImageLayout[sizeof(dstImageLayout) == sizeof(VkImageLayout) ? 1 : -1])); /* add VkImageLayout to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dstImageLayout = 0; + cmock_call_instance->Expected_pImageSubresources = pImageSubresources; + cmock_call_instance->IgnoreArg_pImageSubresources = 0; +} + +void vkCmdCopyMemoryToImageIndirectNV_CMockIgnore(void) +{ + Mock.vkCmdCopyMemoryToImageIndirectNV_IgnoreBool = (char)1; +} + +void vkCmdCopyMemoryToImageIndirectNV_CMockStopIgnore(void) +{ + Mock.vkCmdCopyMemoryToImageIndirectNV_IgnoreBool = (char)0; +} + +void vkCmdCopyMemoryToImageIndirectNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALL_INSTANCE)); + CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyMemoryToImageIndirectNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyMemoryToImageIndirectNV_CallInstance, cmock_guts_index); + Mock.vkCmdCopyMemoryToImageIndirectNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdCopyMemoryToImageIndirectNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers* pImageSubresources) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALL_INSTANCE)); + CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyMemoryToImageIndirectNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyMemoryToImageIndirectNV_CallInstance, cmock_guts_index); + Mock.vkCmdCopyMemoryToImageIndirectNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdCopyMemoryToImageIndirectNV(cmock_call_instance, commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources); +} + +void vkCmdCopyMemoryToImageIndirectNV_AddCallback(CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALLBACK Callback) +{ + Mock.vkCmdCopyMemoryToImageIndirectNV_IgnoreBool = (char)0; + Mock.vkCmdCopyMemoryToImageIndirectNV_CallbackBool = (char)1; + Mock.vkCmdCopyMemoryToImageIndirectNV_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyMemoryToImageIndirectNV_Stub(CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALLBACK Callback) +{ + Mock.vkCmdCopyMemoryToImageIndirectNV_IgnoreBool = (char)0; + Mock.vkCmdCopyMemoryToImageIndirectNV_CallbackBool = (char)0; + Mock.vkCmdCopyMemoryToImageIndirectNV_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyMemoryToImageIndirectNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyMemoryToImageIndirectNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdCopyMemoryToImageIndirectNV_CMockIgnoreArg_copyBufferAddress(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyMemoryToImageIndirectNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_copyBufferAddress = 1; +} + +void vkCmdCopyMemoryToImageIndirectNV_CMockIgnoreArg_copyCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyMemoryToImageIndirectNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_copyCount = 1; +} + +void vkCmdCopyMemoryToImageIndirectNV_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyMemoryToImageIndirectNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stride = 1; +} + +void vkCmdCopyMemoryToImageIndirectNV_CMockIgnoreArg_dstImage(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyMemoryToImageIndirectNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dstImage = 1; +} + +void vkCmdCopyMemoryToImageIndirectNV_CMockIgnoreArg_dstImageLayout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyMemoryToImageIndirectNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dstImageLayout = 1; +} + +void vkCmdCopyMemoryToImageIndirectNV_CMockIgnoreArg_pImageSubresources(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyMemoryToImageIndirectNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pImageSubresources = 1; +} + +void vkCmdDecompressMemoryNV(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV* pDecompressMemoryRegions) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDecompressMemoryNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDecompressMemoryNV); + cmock_call_instance = (CMOCK_vkCmdDecompressMemoryNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDecompressMemoryNV_CallInstance); + Mock.vkCmdDecompressMemoryNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDecompressMemoryNV_CallInstance); + if (Mock.vkCmdDecompressMemoryNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDecompressMemoryNV_CallbackBool && + Mock.vkCmdDecompressMemoryNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDecompressMemoryNV_CallbackFunctionPointer(commandBuffer, decompressRegionCount, pDecompressMemoryRegions, Mock.vkCmdDecompressMemoryNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDecompressMemoryNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_decompressRegionCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdDecompressMemoryNV,CMockString_decompressRegionCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_decompressRegionCount, decompressRegionCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDecompressMemoryRegions) + { + UNITY_SET_DETAILS(CMockString_vkCmdDecompressMemoryNV,CMockString_pDecompressMemoryRegions); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDecompressMemoryRegions), (void*)(pDecompressMemoryRegions), sizeof(const VkDecompressMemoryRegionNV), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdDecompressMemoryNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDecompressMemoryNV_CallbackFunctionPointer(commandBuffer, decompressRegionCount, pDecompressMemoryRegions, Mock.vkCmdDecompressMemoryNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDecompressMemoryNV(CMOCK_vkCmdDecompressMemoryNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV* pDecompressMemoryRegions); +void CMockExpectParameters_vkCmdDecompressMemoryNV(CMOCK_vkCmdDecompressMemoryNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV* pDecompressMemoryRegions) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_decompressRegionCount = decompressRegionCount; + cmock_call_instance->IgnoreArg_decompressRegionCount = 0; + cmock_call_instance->Expected_pDecompressMemoryRegions = pDecompressMemoryRegions; + cmock_call_instance->IgnoreArg_pDecompressMemoryRegions = 0; +} + +void vkCmdDecompressMemoryNV_CMockIgnore(void) +{ + Mock.vkCmdDecompressMemoryNV_IgnoreBool = (char)1; +} + +void vkCmdDecompressMemoryNV_CMockStopIgnore(void) +{ + Mock.vkCmdDecompressMemoryNV_IgnoreBool = (char)0; +} + +void vkCmdDecompressMemoryNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDecompressMemoryNV_CALL_INSTANCE)); + CMOCK_vkCmdDecompressMemoryNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDecompressMemoryNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDecompressMemoryNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDecompressMemoryNV_CallInstance, cmock_guts_index); + Mock.vkCmdDecompressMemoryNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDecompressMemoryNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV* pDecompressMemoryRegions) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDecompressMemoryNV_CALL_INSTANCE)); + CMOCK_vkCmdDecompressMemoryNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDecompressMemoryNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDecompressMemoryNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDecompressMemoryNV_CallInstance, cmock_guts_index); + Mock.vkCmdDecompressMemoryNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDecompressMemoryNV(cmock_call_instance, commandBuffer, decompressRegionCount, pDecompressMemoryRegions); +} + +void vkCmdDecompressMemoryNV_AddCallback(CMOCK_vkCmdDecompressMemoryNV_CALLBACK Callback) +{ + Mock.vkCmdDecompressMemoryNV_IgnoreBool = (char)0; + Mock.vkCmdDecompressMemoryNV_CallbackBool = (char)1; + Mock.vkCmdDecompressMemoryNV_CallbackFunctionPointer = Callback; +} + +void vkCmdDecompressMemoryNV_Stub(CMOCK_vkCmdDecompressMemoryNV_CALLBACK Callback) +{ + Mock.vkCmdDecompressMemoryNV_IgnoreBool = (char)0; + Mock.vkCmdDecompressMemoryNV_CallbackBool = (char)0; + Mock.vkCmdDecompressMemoryNV_CallbackFunctionPointer = Callback; +} + +void vkCmdDecompressMemoryNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDecompressMemoryNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDecompressMemoryNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDecompressMemoryNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDecompressMemoryNV_CMockIgnoreArg_decompressRegionCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDecompressMemoryNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDecompressMemoryNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDecompressMemoryNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_decompressRegionCount = 1; +} + +void vkCmdDecompressMemoryNV_CMockIgnoreArg_pDecompressMemoryRegions(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDecompressMemoryNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDecompressMemoryNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDecompressMemoryNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDecompressMemoryRegions = 1; +} + +void vkCmdDecompressMemoryIndirectCountNV(VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDecompressMemoryIndirectCountNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDecompressMemoryIndirectCountNV); + cmock_call_instance = (CMOCK_vkCmdDecompressMemoryIndirectCountNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDecompressMemoryIndirectCountNV_CallInstance); + Mock.vkCmdDecompressMemoryIndirectCountNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDecompressMemoryIndirectCountNV_CallInstance); + if (Mock.vkCmdDecompressMemoryIndirectCountNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDecompressMemoryIndirectCountNV_CallbackBool && + Mock.vkCmdDecompressMemoryIndirectCountNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDecompressMemoryIndirectCountNV_CallbackFunctionPointer(commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride, Mock.vkCmdDecompressMemoryIndirectCountNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDecompressMemoryIndirectCountNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_indirectCommandsAddress) + { + UNITY_SET_DETAILS(CMockString_vkCmdDecompressMemoryIndirectCountNV,CMockString_indirectCommandsAddress); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_indirectCommandsAddress), (void*)(&indirectCommandsAddress), sizeof(VkDeviceAddress), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_indirectCommandsCountAddress) + { + UNITY_SET_DETAILS(CMockString_vkCmdDecompressMemoryIndirectCountNV,CMockString_indirectCommandsCountAddress); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_indirectCommandsCountAddress), (void*)(&indirectCommandsCountAddress), sizeof(VkDeviceAddress), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_stride) + { + UNITY_SET_DETAILS(CMockString_vkCmdDecompressMemoryIndirectCountNV,CMockString_stride); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_stride, stride, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdDecompressMemoryIndirectCountNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDecompressMemoryIndirectCountNV_CallbackFunctionPointer(commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride, Mock.vkCmdDecompressMemoryIndirectCountNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDecompressMemoryIndirectCountNV(CMOCK_vkCmdDecompressMemoryIndirectCountNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride); +void CMockExpectParameters_vkCmdDecompressMemoryIndirectCountNV(CMOCK_vkCmdDecompressMemoryIndirectCountNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_indirectCommandsAddress), (void*)(&indirectCommandsAddress), + sizeof(VkDeviceAddress[sizeof(indirectCommandsAddress) == sizeof(VkDeviceAddress) ? 1 : -1])); /* add VkDeviceAddress to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_indirectCommandsAddress = 0; + memcpy((void*)(&cmock_call_instance->Expected_indirectCommandsCountAddress), (void*)(&indirectCommandsCountAddress), + sizeof(VkDeviceAddress[sizeof(indirectCommandsCountAddress) == sizeof(VkDeviceAddress) ? 1 : -1])); /* add VkDeviceAddress to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_indirectCommandsCountAddress = 0; + cmock_call_instance->Expected_stride = stride; + cmock_call_instance->IgnoreArg_stride = 0; +} + +void vkCmdDecompressMemoryIndirectCountNV_CMockIgnore(void) +{ + Mock.vkCmdDecompressMemoryIndirectCountNV_IgnoreBool = (char)1; +} + +void vkCmdDecompressMemoryIndirectCountNV_CMockStopIgnore(void) +{ + Mock.vkCmdDecompressMemoryIndirectCountNV_IgnoreBool = (char)0; +} + +void vkCmdDecompressMemoryIndirectCountNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDecompressMemoryIndirectCountNV_CALL_INSTANCE)); + CMOCK_vkCmdDecompressMemoryIndirectCountNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDecompressMemoryIndirectCountNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDecompressMemoryIndirectCountNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDecompressMemoryIndirectCountNV_CallInstance, cmock_guts_index); + Mock.vkCmdDecompressMemoryIndirectCountNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDecompressMemoryIndirectCountNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDecompressMemoryIndirectCountNV_CALL_INSTANCE)); + CMOCK_vkCmdDecompressMemoryIndirectCountNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDecompressMemoryIndirectCountNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDecompressMemoryIndirectCountNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDecompressMemoryIndirectCountNV_CallInstance, cmock_guts_index); + Mock.vkCmdDecompressMemoryIndirectCountNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDecompressMemoryIndirectCountNV(cmock_call_instance, commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride); +} + +void vkCmdDecompressMemoryIndirectCountNV_AddCallback(CMOCK_vkCmdDecompressMemoryIndirectCountNV_CALLBACK Callback) +{ + Mock.vkCmdDecompressMemoryIndirectCountNV_IgnoreBool = (char)0; + Mock.vkCmdDecompressMemoryIndirectCountNV_CallbackBool = (char)1; + Mock.vkCmdDecompressMemoryIndirectCountNV_CallbackFunctionPointer = Callback; +} + +void vkCmdDecompressMemoryIndirectCountNV_Stub(CMOCK_vkCmdDecompressMemoryIndirectCountNV_CALLBACK Callback) +{ + Mock.vkCmdDecompressMemoryIndirectCountNV_IgnoreBool = (char)0; + Mock.vkCmdDecompressMemoryIndirectCountNV_CallbackBool = (char)0; + Mock.vkCmdDecompressMemoryIndirectCountNV_CallbackFunctionPointer = Callback; +} + +void vkCmdDecompressMemoryIndirectCountNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDecompressMemoryIndirectCountNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDecompressMemoryIndirectCountNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDecompressMemoryIndirectCountNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDecompressMemoryIndirectCountNV_CMockIgnoreArg_indirectCommandsAddress(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDecompressMemoryIndirectCountNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDecompressMemoryIndirectCountNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDecompressMemoryIndirectCountNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_indirectCommandsAddress = 1; +} + +void vkCmdDecompressMemoryIndirectCountNV_CMockIgnoreArg_indirectCommandsCountAddress(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDecompressMemoryIndirectCountNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDecompressMemoryIndirectCountNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDecompressMemoryIndirectCountNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_indirectCommandsCountAddress = 1; +} + +void vkCmdDecompressMemoryIndirectCountNV_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDecompressMemoryIndirectCountNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDecompressMemoryIndirectCountNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDecompressMemoryIndirectCountNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stride = 1; +} + +void vkCmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetTessellationDomainOriginEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetTessellationDomainOriginEXT); + cmock_call_instance = (CMOCK_vkCmdSetTessellationDomainOriginEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetTessellationDomainOriginEXT_CallInstance); + Mock.vkCmdSetTessellationDomainOriginEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetTessellationDomainOriginEXT_CallInstance); + if (Mock.vkCmdSetTessellationDomainOriginEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetTessellationDomainOriginEXT_CallbackBool && + Mock.vkCmdSetTessellationDomainOriginEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetTessellationDomainOriginEXT_CallbackFunctionPointer(commandBuffer, domainOrigin, Mock.vkCmdSetTessellationDomainOriginEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetTessellationDomainOriginEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_domainOrigin) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetTessellationDomainOriginEXT,CMockString_domainOrigin); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_domainOrigin), (void*)(&domainOrigin), sizeof(VkTessellationDomainOrigin), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetTessellationDomainOriginEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetTessellationDomainOriginEXT_CallbackFunctionPointer(commandBuffer, domainOrigin, Mock.vkCmdSetTessellationDomainOriginEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetTessellationDomainOriginEXT(CMOCK_vkCmdSetTessellationDomainOriginEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin); +void CMockExpectParameters_vkCmdSetTessellationDomainOriginEXT(CMOCK_vkCmdSetTessellationDomainOriginEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_domainOrigin), (void*)(&domainOrigin), + sizeof(VkTessellationDomainOrigin[sizeof(domainOrigin) == sizeof(VkTessellationDomainOrigin) ? 1 : -1])); /* add VkTessellationDomainOrigin to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_domainOrigin = 0; +} + +void vkCmdSetTessellationDomainOriginEXT_CMockIgnore(void) +{ + Mock.vkCmdSetTessellationDomainOriginEXT_IgnoreBool = (char)1; +} + +void vkCmdSetTessellationDomainOriginEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetTessellationDomainOriginEXT_IgnoreBool = (char)0; +} + +void vkCmdSetTessellationDomainOriginEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetTessellationDomainOriginEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetTessellationDomainOriginEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetTessellationDomainOriginEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetTessellationDomainOriginEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetTessellationDomainOriginEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetTessellationDomainOriginEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetTessellationDomainOriginEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetTessellationDomainOriginEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetTessellationDomainOriginEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetTessellationDomainOriginEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetTessellationDomainOriginEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetTessellationDomainOriginEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetTessellationDomainOriginEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetTessellationDomainOriginEXT(cmock_call_instance, commandBuffer, domainOrigin); +} + +void vkCmdSetTessellationDomainOriginEXT_AddCallback(CMOCK_vkCmdSetTessellationDomainOriginEXT_CALLBACK Callback) +{ + Mock.vkCmdSetTessellationDomainOriginEXT_IgnoreBool = (char)0; + Mock.vkCmdSetTessellationDomainOriginEXT_CallbackBool = (char)1; + Mock.vkCmdSetTessellationDomainOriginEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetTessellationDomainOriginEXT_Stub(CMOCK_vkCmdSetTessellationDomainOriginEXT_CALLBACK Callback) +{ + Mock.vkCmdSetTessellationDomainOriginEXT_IgnoreBool = (char)0; + Mock.vkCmdSetTessellationDomainOriginEXT_CallbackBool = (char)0; + Mock.vkCmdSetTessellationDomainOriginEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetTessellationDomainOriginEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetTessellationDomainOriginEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetTessellationDomainOriginEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetTessellationDomainOriginEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetTessellationDomainOriginEXT_CMockIgnoreArg_domainOrigin(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetTessellationDomainOriginEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetTessellationDomainOriginEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetTessellationDomainOriginEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_domainOrigin = 1; +} + +void vkCmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetDepthClampEnableEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetDepthClampEnableEXT); + cmock_call_instance = (CMOCK_vkCmdSetDepthClampEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetDepthClampEnableEXT_CallInstance); + Mock.vkCmdSetDepthClampEnableEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetDepthClampEnableEXT_CallInstance); + if (Mock.vkCmdSetDepthClampEnableEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetDepthClampEnableEXT_CallbackBool && + Mock.vkCmdSetDepthClampEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDepthClampEnableEXT_CallbackFunctionPointer(commandBuffer, depthClampEnable, Mock.vkCmdSetDepthClampEnableEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthClampEnableEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_depthClampEnable) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthClampEnableEXT,CMockString_depthClampEnable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_depthClampEnable), (void*)(&depthClampEnable), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetDepthClampEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDepthClampEnableEXT_CallbackFunctionPointer(commandBuffer, depthClampEnable, Mock.vkCmdSetDepthClampEnableEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetDepthClampEnableEXT(CMOCK_vkCmdSetDepthClampEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 depthClampEnable); +void CMockExpectParameters_vkCmdSetDepthClampEnableEXT(CMOCK_vkCmdSetDepthClampEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 depthClampEnable) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_depthClampEnable), (void*)(&depthClampEnable), + sizeof(VkBool32[sizeof(depthClampEnable) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_depthClampEnable = 0; +} + +void vkCmdSetDepthClampEnableEXT_CMockIgnore(void) +{ + Mock.vkCmdSetDepthClampEnableEXT_IgnoreBool = (char)1; +} + +void vkCmdSetDepthClampEnableEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetDepthClampEnableEXT_IgnoreBool = (char)0; +} + +void vkCmdSetDepthClampEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDepthClampEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetDepthClampEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthClampEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDepthClampEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDepthClampEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetDepthClampEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetDepthClampEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 depthClampEnable) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDepthClampEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetDepthClampEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthClampEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDepthClampEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDepthClampEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetDepthClampEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetDepthClampEnableEXT(cmock_call_instance, commandBuffer, depthClampEnable); +} + +void vkCmdSetDepthClampEnableEXT_AddCallback(CMOCK_vkCmdSetDepthClampEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetDepthClampEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetDepthClampEnableEXT_CallbackBool = (char)1; + Mock.vkCmdSetDepthClampEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDepthClampEnableEXT_Stub(CMOCK_vkCmdSetDepthClampEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetDepthClampEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetDepthClampEnableEXT_CallbackBool = (char)0; + Mock.vkCmdSetDepthClampEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDepthClampEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthClampEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthClampEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthClampEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetDepthClampEnableEXT_CMockIgnoreArg_depthClampEnable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthClampEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthClampEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthClampEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_depthClampEnable = 1; +} + +void vkCmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetPolygonModeEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetPolygonModeEXT); + cmock_call_instance = (CMOCK_vkCmdSetPolygonModeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetPolygonModeEXT_CallInstance); + Mock.vkCmdSetPolygonModeEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetPolygonModeEXT_CallInstance); + if (Mock.vkCmdSetPolygonModeEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetPolygonModeEXT_CallbackBool && + Mock.vkCmdSetPolygonModeEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetPolygonModeEXT_CallbackFunctionPointer(commandBuffer, polygonMode, Mock.vkCmdSetPolygonModeEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetPolygonModeEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_polygonMode) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetPolygonModeEXT,CMockString_polygonMode); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_polygonMode), (void*)(&polygonMode), sizeof(VkPolygonMode), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetPolygonModeEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetPolygonModeEXT_CallbackFunctionPointer(commandBuffer, polygonMode, Mock.vkCmdSetPolygonModeEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetPolygonModeEXT(CMOCK_vkCmdSetPolygonModeEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPolygonMode polygonMode); +void CMockExpectParameters_vkCmdSetPolygonModeEXT(CMOCK_vkCmdSetPolygonModeEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkPolygonMode polygonMode) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_polygonMode), (void*)(&polygonMode), + sizeof(VkPolygonMode[sizeof(polygonMode) == sizeof(VkPolygonMode) ? 1 : -1])); /* add VkPolygonMode to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_polygonMode = 0; +} + +void vkCmdSetPolygonModeEXT_CMockIgnore(void) +{ + Mock.vkCmdSetPolygonModeEXT_IgnoreBool = (char)1; +} + +void vkCmdSetPolygonModeEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetPolygonModeEXT_IgnoreBool = (char)0; +} + +void vkCmdSetPolygonModeEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetPolygonModeEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetPolygonModeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPolygonModeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetPolygonModeEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetPolygonModeEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetPolygonModeEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetPolygonModeEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPolygonMode polygonMode) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetPolygonModeEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetPolygonModeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPolygonModeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetPolygonModeEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetPolygonModeEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetPolygonModeEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetPolygonModeEXT(cmock_call_instance, commandBuffer, polygonMode); +} + +void vkCmdSetPolygonModeEXT_AddCallback(CMOCK_vkCmdSetPolygonModeEXT_CALLBACK Callback) +{ + Mock.vkCmdSetPolygonModeEXT_IgnoreBool = (char)0; + Mock.vkCmdSetPolygonModeEXT_CallbackBool = (char)1; + Mock.vkCmdSetPolygonModeEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetPolygonModeEXT_Stub(CMOCK_vkCmdSetPolygonModeEXT_CALLBACK Callback) +{ + Mock.vkCmdSetPolygonModeEXT_IgnoreBool = (char)0; + Mock.vkCmdSetPolygonModeEXT_CallbackBool = (char)0; + Mock.vkCmdSetPolygonModeEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetPolygonModeEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetPolygonModeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPolygonModeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetPolygonModeEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetPolygonModeEXT_CMockIgnoreArg_polygonMode(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetPolygonModeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetPolygonModeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetPolygonModeEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_polygonMode = 1; +} + +void vkCmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetRasterizationSamplesEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetRasterizationSamplesEXT); + cmock_call_instance = (CMOCK_vkCmdSetRasterizationSamplesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetRasterizationSamplesEXT_CallInstance); + Mock.vkCmdSetRasterizationSamplesEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetRasterizationSamplesEXT_CallInstance); + if (Mock.vkCmdSetRasterizationSamplesEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetRasterizationSamplesEXT_CallbackBool && + Mock.vkCmdSetRasterizationSamplesEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetRasterizationSamplesEXT_CallbackFunctionPointer(commandBuffer, rasterizationSamples, Mock.vkCmdSetRasterizationSamplesEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetRasterizationSamplesEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_rasterizationSamples) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetRasterizationSamplesEXT,CMockString_rasterizationSamples); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_rasterizationSamples), (void*)(&rasterizationSamples), sizeof(VkSampleCountFlagBits), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetRasterizationSamplesEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetRasterizationSamplesEXT_CallbackFunctionPointer(commandBuffer, rasterizationSamples, Mock.vkCmdSetRasterizationSamplesEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetRasterizationSamplesEXT(CMOCK_vkCmdSetRasterizationSamplesEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples); +void CMockExpectParameters_vkCmdSetRasterizationSamplesEXT(CMOCK_vkCmdSetRasterizationSamplesEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_rasterizationSamples), (void*)(&rasterizationSamples), + sizeof(VkSampleCountFlagBits[sizeof(rasterizationSamples) == sizeof(VkSampleCountFlagBits) ? 1 : -1])); /* add VkSampleCountFlagBits to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_rasterizationSamples = 0; +} + +void vkCmdSetRasterizationSamplesEXT_CMockIgnore(void) +{ + Mock.vkCmdSetRasterizationSamplesEXT_IgnoreBool = (char)1; +} + +void vkCmdSetRasterizationSamplesEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetRasterizationSamplesEXT_IgnoreBool = (char)0; +} + +void vkCmdSetRasterizationSamplesEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetRasterizationSamplesEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetRasterizationSamplesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetRasterizationSamplesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetRasterizationSamplesEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetRasterizationSamplesEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetRasterizationSamplesEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetRasterizationSamplesEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetRasterizationSamplesEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetRasterizationSamplesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetRasterizationSamplesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetRasterizationSamplesEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetRasterizationSamplesEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetRasterizationSamplesEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetRasterizationSamplesEXT(cmock_call_instance, commandBuffer, rasterizationSamples); +} + +void vkCmdSetRasterizationSamplesEXT_AddCallback(CMOCK_vkCmdSetRasterizationSamplesEXT_CALLBACK Callback) +{ + Mock.vkCmdSetRasterizationSamplesEXT_IgnoreBool = (char)0; + Mock.vkCmdSetRasterizationSamplesEXT_CallbackBool = (char)1; + Mock.vkCmdSetRasterizationSamplesEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetRasterizationSamplesEXT_Stub(CMOCK_vkCmdSetRasterizationSamplesEXT_CALLBACK Callback) +{ + Mock.vkCmdSetRasterizationSamplesEXT_IgnoreBool = (char)0; + Mock.vkCmdSetRasterizationSamplesEXT_CallbackBool = (char)0; + Mock.vkCmdSetRasterizationSamplesEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetRasterizationSamplesEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetRasterizationSamplesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetRasterizationSamplesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetRasterizationSamplesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetRasterizationSamplesEXT_CMockIgnoreArg_rasterizationSamples(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetRasterizationSamplesEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetRasterizationSamplesEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetRasterizationSamplesEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_rasterizationSamples = 1; +} + +void vkCmdSetSampleMaskEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetSampleMaskEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetSampleMaskEXT); + cmock_call_instance = (CMOCK_vkCmdSetSampleMaskEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetSampleMaskEXT_CallInstance); + Mock.vkCmdSetSampleMaskEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetSampleMaskEXT_CallInstance); + if (Mock.vkCmdSetSampleMaskEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetSampleMaskEXT_CallbackBool && + Mock.vkCmdSetSampleMaskEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetSampleMaskEXT_CallbackFunctionPointer(commandBuffer, samples, pSampleMask, Mock.vkCmdSetSampleMaskEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetSampleMaskEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_samples) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetSampleMaskEXT,CMockString_samples); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_samples), (void*)(&samples), sizeof(VkSampleCountFlagBits), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSampleMask) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetSampleMaskEXT,CMockString_pSampleMask); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSampleMask), (void*)(pSampleMask), sizeof(const VkSampleMask), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetSampleMaskEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetSampleMaskEXT_CallbackFunctionPointer(commandBuffer, samples, pSampleMask, Mock.vkCmdSetSampleMaskEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetSampleMaskEXT(CMOCK_vkCmdSetSampleMaskEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask); +void CMockExpectParameters_vkCmdSetSampleMaskEXT(CMOCK_vkCmdSetSampleMaskEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_samples), (void*)(&samples), + sizeof(VkSampleCountFlagBits[sizeof(samples) == sizeof(VkSampleCountFlagBits) ? 1 : -1])); /* add VkSampleCountFlagBits to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_samples = 0; + cmock_call_instance->Expected_pSampleMask = pSampleMask; + cmock_call_instance->IgnoreArg_pSampleMask = 0; +} + +void vkCmdSetSampleMaskEXT_CMockIgnore(void) +{ + Mock.vkCmdSetSampleMaskEXT_IgnoreBool = (char)1; +} + +void vkCmdSetSampleMaskEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetSampleMaskEXT_IgnoreBool = (char)0; +} + +void vkCmdSetSampleMaskEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetSampleMaskEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetSampleMaskEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetSampleMaskEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetSampleMaskEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetSampleMaskEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetSampleMaskEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetSampleMaskEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetSampleMaskEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetSampleMaskEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetSampleMaskEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetSampleMaskEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetSampleMaskEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetSampleMaskEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetSampleMaskEXT(cmock_call_instance, commandBuffer, samples, pSampleMask); +} + +void vkCmdSetSampleMaskEXT_AddCallback(CMOCK_vkCmdSetSampleMaskEXT_CALLBACK Callback) +{ + Mock.vkCmdSetSampleMaskEXT_IgnoreBool = (char)0; + Mock.vkCmdSetSampleMaskEXT_CallbackBool = (char)1; + Mock.vkCmdSetSampleMaskEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetSampleMaskEXT_Stub(CMOCK_vkCmdSetSampleMaskEXT_CALLBACK Callback) +{ + Mock.vkCmdSetSampleMaskEXT_IgnoreBool = (char)0; + Mock.vkCmdSetSampleMaskEXT_CallbackBool = (char)0; + Mock.vkCmdSetSampleMaskEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetSampleMaskEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetSampleMaskEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetSampleMaskEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetSampleMaskEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetSampleMaskEXT_CMockIgnoreArg_samples(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetSampleMaskEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetSampleMaskEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetSampleMaskEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_samples = 1; +} + +void vkCmdSetSampleMaskEXT_CMockIgnoreArg_pSampleMask(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetSampleMaskEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetSampleMaskEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetSampleMaskEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSampleMask = 1; +} + +void vkCmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetAlphaToCoverageEnableEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetAlphaToCoverageEnableEXT); + cmock_call_instance = (CMOCK_vkCmdSetAlphaToCoverageEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetAlphaToCoverageEnableEXT_CallInstance); + Mock.vkCmdSetAlphaToCoverageEnableEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetAlphaToCoverageEnableEXT_CallInstance); + if (Mock.vkCmdSetAlphaToCoverageEnableEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetAlphaToCoverageEnableEXT_CallbackBool && + Mock.vkCmdSetAlphaToCoverageEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetAlphaToCoverageEnableEXT_CallbackFunctionPointer(commandBuffer, alphaToCoverageEnable, Mock.vkCmdSetAlphaToCoverageEnableEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetAlphaToCoverageEnableEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_alphaToCoverageEnable) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetAlphaToCoverageEnableEXT,CMockString_alphaToCoverageEnable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_alphaToCoverageEnable), (void*)(&alphaToCoverageEnable), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetAlphaToCoverageEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetAlphaToCoverageEnableEXT_CallbackFunctionPointer(commandBuffer, alphaToCoverageEnable, Mock.vkCmdSetAlphaToCoverageEnableEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetAlphaToCoverageEnableEXT(CMOCK_vkCmdSetAlphaToCoverageEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable); +void CMockExpectParameters_vkCmdSetAlphaToCoverageEnableEXT(CMOCK_vkCmdSetAlphaToCoverageEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_alphaToCoverageEnable), (void*)(&alphaToCoverageEnable), + sizeof(VkBool32[sizeof(alphaToCoverageEnable) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_alphaToCoverageEnable = 0; +} + +void vkCmdSetAlphaToCoverageEnableEXT_CMockIgnore(void) +{ + Mock.vkCmdSetAlphaToCoverageEnableEXT_IgnoreBool = (char)1; +} + +void vkCmdSetAlphaToCoverageEnableEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetAlphaToCoverageEnableEXT_IgnoreBool = (char)0; +} + +void vkCmdSetAlphaToCoverageEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetAlphaToCoverageEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetAlphaToCoverageEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetAlphaToCoverageEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetAlphaToCoverageEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetAlphaToCoverageEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetAlphaToCoverageEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetAlphaToCoverageEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetAlphaToCoverageEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetAlphaToCoverageEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetAlphaToCoverageEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetAlphaToCoverageEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetAlphaToCoverageEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetAlphaToCoverageEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetAlphaToCoverageEnableEXT(cmock_call_instance, commandBuffer, alphaToCoverageEnable); +} + +void vkCmdSetAlphaToCoverageEnableEXT_AddCallback(CMOCK_vkCmdSetAlphaToCoverageEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetAlphaToCoverageEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetAlphaToCoverageEnableEXT_CallbackBool = (char)1; + Mock.vkCmdSetAlphaToCoverageEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetAlphaToCoverageEnableEXT_Stub(CMOCK_vkCmdSetAlphaToCoverageEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetAlphaToCoverageEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetAlphaToCoverageEnableEXT_CallbackBool = (char)0; + Mock.vkCmdSetAlphaToCoverageEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetAlphaToCoverageEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetAlphaToCoverageEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetAlphaToCoverageEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetAlphaToCoverageEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetAlphaToCoverageEnableEXT_CMockIgnoreArg_alphaToCoverageEnable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetAlphaToCoverageEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetAlphaToCoverageEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetAlphaToCoverageEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_alphaToCoverageEnable = 1; +} + +void vkCmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetAlphaToOneEnableEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetAlphaToOneEnableEXT); + cmock_call_instance = (CMOCK_vkCmdSetAlphaToOneEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetAlphaToOneEnableEXT_CallInstance); + Mock.vkCmdSetAlphaToOneEnableEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetAlphaToOneEnableEXT_CallInstance); + if (Mock.vkCmdSetAlphaToOneEnableEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetAlphaToOneEnableEXT_CallbackBool && + Mock.vkCmdSetAlphaToOneEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetAlphaToOneEnableEXT_CallbackFunctionPointer(commandBuffer, alphaToOneEnable, Mock.vkCmdSetAlphaToOneEnableEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetAlphaToOneEnableEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_alphaToOneEnable) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetAlphaToOneEnableEXT,CMockString_alphaToOneEnable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_alphaToOneEnable), (void*)(&alphaToOneEnable), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetAlphaToOneEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetAlphaToOneEnableEXT_CallbackFunctionPointer(commandBuffer, alphaToOneEnable, Mock.vkCmdSetAlphaToOneEnableEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetAlphaToOneEnableEXT(CMOCK_vkCmdSetAlphaToOneEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable); +void CMockExpectParameters_vkCmdSetAlphaToOneEnableEXT(CMOCK_vkCmdSetAlphaToOneEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_alphaToOneEnable), (void*)(&alphaToOneEnable), + sizeof(VkBool32[sizeof(alphaToOneEnable) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_alphaToOneEnable = 0; +} + +void vkCmdSetAlphaToOneEnableEXT_CMockIgnore(void) +{ + Mock.vkCmdSetAlphaToOneEnableEXT_IgnoreBool = (char)1; +} + +void vkCmdSetAlphaToOneEnableEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetAlphaToOneEnableEXT_IgnoreBool = (char)0; +} + +void vkCmdSetAlphaToOneEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetAlphaToOneEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetAlphaToOneEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetAlphaToOneEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetAlphaToOneEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetAlphaToOneEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetAlphaToOneEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetAlphaToOneEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetAlphaToOneEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetAlphaToOneEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetAlphaToOneEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetAlphaToOneEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetAlphaToOneEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetAlphaToOneEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetAlphaToOneEnableEXT(cmock_call_instance, commandBuffer, alphaToOneEnable); +} + +void vkCmdSetAlphaToOneEnableEXT_AddCallback(CMOCK_vkCmdSetAlphaToOneEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetAlphaToOneEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetAlphaToOneEnableEXT_CallbackBool = (char)1; + Mock.vkCmdSetAlphaToOneEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetAlphaToOneEnableEXT_Stub(CMOCK_vkCmdSetAlphaToOneEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetAlphaToOneEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetAlphaToOneEnableEXT_CallbackBool = (char)0; + Mock.vkCmdSetAlphaToOneEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetAlphaToOneEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetAlphaToOneEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetAlphaToOneEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetAlphaToOneEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetAlphaToOneEnableEXT_CMockIgnoreArg_alphaToOneEnable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetAlphaToOneEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetAlphaToOneEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetAlphaToOneEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_alphaToOneEnable = 1; +} + +void vkCmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetLogicOpEnableEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetLogicOpEnableEXT); + cmock_call_instance = (CMOCK_vkCmdSetLogicOpEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetLogicOpEnableEXT_CallInstance); + Mock.vkCmdSetLogicOpEnableEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetLogicOpEnableEXT_CallInstance); + if (Mock.vkCmdSetLogicOpEnableEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetLogicOpEnableEXT_CallbackBool && + Mock.vkCmdSetLogicOpEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetLogicOpEnableEXT_CallbackFunctionPointer(commandBuffer, logicOpEnable, Mock.vkCmdSetLogicOpEnableEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetLogicOpEnableEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_logicOpEnable) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetLogicOpEnableEXT,CMockString_logicOpEnable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_logicOpEnable), (void*)(&logicOpEnable), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetLogicOpEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetLogicOpEnableEXT_CallbackFunctionPointer(commandBuffer, logicOpEnable, Mock.vkCmdSetLogicOpEnableEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetLogicOpEnableEXT(CMOCK_vkCmdSetLogicOpEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 logicOpEnable); +void CMockExpectParameters_vkCmdSetLogicOpEnableEXT(CMOCK_vkCmdSetLogicOpEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 logicOpEnable) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_logicOpEnable), (void*)(&logicOpEnable), + sizeof(VkBool32[sizeof(logicOpEnable) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_logicOpEnable = 0; +} + +void vkCmdSetLogicOpEnableEXT_CMockIgnore(void) +{ + Mock.vkCmdSetLogicOpEnableEXT_IgnoreBool = (char)1; +} + +void vkCmdSetLogicOpEnableEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetLogicOpEnableEXT_IgnoreBool = (char)0; +} + +void vkCmdSetLogicOpEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetLogicOpEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetLogicOpEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetLogicOpEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetLogicOpEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetLogicOpEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetLogicOpEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetLogicOpEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 logicOpEnable) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetLogicOpEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetLogicOpEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetLogicOpEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetLogicOpEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetLogicOpEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetLogicOpEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetLogicOpEnableEXT(cmock_call_instance, commandBuffer, logicOpEnable); +} + +void vkCmdSetLogicOpEnableEXT_AddCallback(CMOCK_vkCmdSetLogicOpEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetLogicOpEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetLogicOpEnableEXT_CallbackBool = (char)1; + Mock.vkCmdSetLogicOpEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetLogicOpEnableEXT_Stub(CMOCK_vkCmdSetLogicOpEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetLogicOpEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetLogicOpEnableEXT_CallbackBool = (char)0; + Mock.vkCmdSetLogicOpEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetLogicOpEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetLogicOpEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetLogicOpEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetLogicOpEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetLogicOpEnableEXT_CMockIgnoreArg_logicOpEnable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetLogicOpEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetLogicOpEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetLogicOpEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_logicOpEnable = 1; +} + +void vkCmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetColorBlendEnableEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetColorBlendEnableEXT); + cmock_call_instance = (CMOCK_vkCmdSetColorBlendEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetColorBlendEnableEXT_CallInstance); + Mock.vkCmdSetColorBlendEnableEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetColorBlendEnableEXT_CallInstance); + if (Mock.vkCmdSetColorBlendEnableEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetColorBlendEnableEXT_CallbackBool && + Mock.vkCmdSetColorBlendEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetColorBlendEnableEXT_CallbackFunctionPointer(commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables, Mock.vkCmdSetColorBlendEnableEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetColorBlendEnableEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstAttachment) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetColorBlendEnableEXT,CMockString_firstAttachment); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstAttachment, firstAttachment, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_attachmentCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetColorBlendEnableEXT,CMockString_attachmentCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_attachmentCount, attachmentCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pColorBlendEnables) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetColorBlendEnableEXT,CMockString_pColorBlendEnables); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pColorBlendEnables), (void*)(pColorBlendEnables), sizeof(const VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetColorBlendEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetColorBlendEnableEXT_CallbackFunctionPointer(commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables, Mock.vkCmdSetColorBlendEnableEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetColorBlendEnableEXT(CMOCK_vkCmdSetColorBlendEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables); +void CMockExpectParameters_vkCmdSetColorBlendEnableEXT(CMOCK_vkCmdSetColorBlendEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_firstAttachment = firstAttachment; + cmock_call_instance->IgnoreArg_firstAttachment = 0; + cmock_call_instance->Expected_attachmentCount = attachmentCount; + cmock_call_instance->IgnoreArg_attachmentCount = 0; + cmock_call_instance->Expected_pColorBlendEnables = pColorBlendEnables; + cmock_call_instance->IgnoreArg_pColorBlendEnables = 0; +} + +void vkCmdSetColorBlendEnableEXT_CMockIgnore(void) +{ + Mock.vkCmdSetColorBlendEnableEXT_IgnoreBool = (char)1; +} + +void vkCmdSetColorBlendEnableEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetColorBlendEnableEXT_IgnoreBool = (char)0; +} + +void vkCmdSetColorBlendEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetColorBlendEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetColorBlendEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetColorBlendEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetColorBlendEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetColorBlendEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetColorBlendEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetColorBlendEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetColorBlendEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetColorBlendEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetColorBlendEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetColorBlendEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetColorBlendEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetColorBlendEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetColorBlendEnableEXT(cmock_call_instance, commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables); +} + +void vkCmdSetColorBlendEnableEXT_AddCallback(CMOCK_vkCmdSetColorBlendEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetColorBlendEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetColorBlendEnableEXT_CallbackBool = (char)1; + Mock.vkCmdSetColorBlendEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetColorBlendEnableEXT_Stub(CMOCK_vkCmdSetColorBlendEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetColorBlendEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetColorBlendEnableEXT_CallbackBool = (char)0; + Mock.vkCmdSetColorBlendEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetColorBlendEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetColorBlendEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetColorBlendEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetColorBlendEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetColorBlendEnableEXT_CMockIgnoreArg_firstAttachment(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetColorBlendEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetColorBlendEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetColorBlendEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstAttachment = 1; +} + +void vkCmdSetColorBlendEnableEXT_CMockIgnoreArg_attachmentCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetColorBlendEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetColorBlendEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetColorBlendEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_attachmentCount = 1; +} + +void vkCmdSetColorBlendEnableEXT_CMockIgnoreArg_pColorBlendEnables(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetColorBlendEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetColorBlendEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetColorBlendEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pColorBlendEnables = 1; +} + +void vkCmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetColorBlendEquationEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetColorBlendEquationEXT); + cmock_call_instance = (CMOCK_vkCmdSetColorBlendEquationEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetColorBlendEquationEXT_CallInstance); + Mock.vkCmdSetColorBlendEquationEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetColorBlendEquationEXT_CallInstance); + if (Mock.vkCmdSetColorBlendEquationEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetColorBlendEquationEXT_CallbackBool && + Mock.vkCmdSetColorBlendEquationEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetColorBlendEquationEXT_CallbackFunctionPointer(commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations, Mock.vkCmdSetColorBlendEquationEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetColorBlendEquationEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstAttachment) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetColorBlendEquationEXT,CMockString_firstAttachment); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstAttachment, firstAttachment, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_attachmentCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetColorBlendEquationEXT,CMockString_attachmentCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_attachmentCount, attachmentCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pColorBlendEquations) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetColorBlendEquationEXT,CMockString_pColorBlendEquations); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pColorBlendEquations), (void*)(pColorBlendEquations), sizeof(const VkColorBlendEquationEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetColorBlendEquationEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetColorBlendEquationEXT_CallbackFunctionPointer(commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations, Mock.vkCmdSetColorBlendEquationEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetColorBlendEquationEXT(CMOCK_vkCmdSetColorBlendEquationEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations); +void CMockExpectParameters_vkCmdSetColorBlendEquationEXT(CMOCK_vkCmdSetColorBlendEquationEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_firstAttachment = firstAttachment; + cmock_call_instance->IgnoreArg_firstAttachment = 0; + cmock_call_instance->Expected_attachmentCount = attachmentCount; + cmock_call_instance->IgnoreArg_attachmentCount = 0; + cmock_call_instance->Expected_pColorBlendEquations = pColorBlendEquations; + cmock_call_instance->IgnoreArg_pColorBlendEquations = 0; +} + +void vkCmdSetColorBlendEquationEXT_CMockIgnore(void) +{ + Mock.vkCmdSetColorBlendEquationEXT_IgnoreBool = (char)1; +} + +void vkCmdSetColorBlendEquationEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetColorBlendEquationEXT_IgnoreBool = (char)0; +} + +void vkCmdSetColorBlendEquationEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetColorBlendEquationEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetColorBlendEquationEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetColorBlendEquationEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetColorBlendEquationEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetColorBlendEquationEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetColorBlendEquationEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetColorBlendEquationEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetColorBlendEquationEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetColorBlendEquationEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetColorBlendEquationEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetColorBlendEquationEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetColorBlendEquationEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetColorBlendEquationEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetColorBlendEquationEXT(cmock_call_instance, commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations); +} + +void vkCmdSetColorBlendEquationEXT_AddCallback(CMOCK_vkCmdSetColorBlendEquationEXT_CALLBACK Callback) +{ + Mock.vkCmdSetColorBlendEquationEXT_IgnoreBool = (char)0; + Mock.vkCmdSetColorBlendEquationEXT_CallbackBool = (char)1; + Mock.vkCmdSetColorBlendEquationEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetColorBlendEquationEXT_Stub(CMOCK_vkCmdSetColorBlendEquationEXT_CALLBACK Callback) +{ + Mock.vkCmdSetColorBlendEquationEXT_IgnoreBool = (char)0; + Mock.vkCmdSetColorBlendEquationEXT_CallbackBool = (char)0; + Mock.vkCmdSetColorBlendEquationEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetColorBlendEquationEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetColorBlendEquationEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetColorBlendEquationEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetColorBlendEquationEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetColorBlendEquationEXT_CMockIgnoreArg_firstAttachment(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetColorBlendEquationEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetColorBlendEquationEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetColorBlendEquationEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstAttachment = 1; +} + +void vkCmdSetColorBlendEquationEXT_CMockIgnoreArg_attachmentCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetColorBlendEquationEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetColorBlendEquationEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetColorBlendEquationEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_attachmentCount = 1; +} + +void vkCmdSetColorBlendEquationEXT_CMockIgnoreArg_pColorBlendEquations(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetColorBlendEquationEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetColorBlendEquationEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetColorBlendEquationEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pColorBlendEquations = 1; +} + +void vkCmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetColorWriteMaskEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetColorWriteMaskEXT); + cmock_call_instance = (CMOCK_vkCmdSetColorWriteMaskEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetColorWriteMaskEXT_CallInstance); + Mock.vkCmdSetColorWriteMaskEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetColorWriteMaskEXT_CallInstance); + if (Mock.vkCmdSetColorWriteMaskEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetColorWriteMaskEXT_CallbackBool && + Mock.vkCmdSetColorWriteMaskEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetColorWriteMaskEXT_CallbackFunctionPointer(commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks, Mock.vkCmdSetColorWriteMaskEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetColorWriteMaskEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstAttachment) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetColorWriteMaskEXT,CMockString_firstAttachment); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstAttachment, firstAttachment, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_attachmentCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetColorWriteMaskEXT,CMockString_attachmentCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_attachmentCount, attachmentCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pColorWriteMasks) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetColorWriteMaskEXT,CMockString_pColorWriteMasks); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pColorWriteMasks), (void*)(pColorWriteMasks), sizeof(const VkColorComponentFlags), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetColorWriteMaskEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetColorWriteMaskEXT_CallbackFunctionPointer(commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks, Mock.vkCmdSetColorWriteMaskEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetColorWriteMaskEXT(CMOCK_vkCmdSetColorWriteMaskEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks); +void CMockExpectParameters_vkCmdSetColorWriteMaskEXT(CMOCK_vkCmdSetColorWriteMaskEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_firstAttachment = firstAttachment; + cmock_call_instance->IgnoreArg_firstAttachment = 0; + cmock_call_instance->Expected_attachmentCount = attachmentCount; + cmock_call_instance->IgnoreArg_attachmentCount = 0; + cmock_call_instance->Expected_pColorWriteMasks = pColorWriteMasks; + cmock_call_instance->IgnoreArg_pColorWriteMasks = 0; +} + +void vkCmdSetColorWriteMaskEXT_CMockIgnore(void) +{ + Mock.vkCmdSetColorWriteMaskEXT_IgnoreBool = (char)1; +} + +void vkCmdSetColorWriteMaskEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetColorWriteMaskEXT_IgnoreBool = (char)0; +} + +void vkCmdSetColorWriteMaskEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetColorWriteMaskEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetColorWriteMaskEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetColorWriteMaskEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetColorWriteMaskEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetColorWriteMaskEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetColorWriteMaskEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetColorWriteMaskEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetColorWriteMaskEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetColorWriteMaskEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetColorWriteMaskEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetColorWriteMaskEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetColorWriteMaskEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetColorWriteMaskEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetColorWriteMaskEXT(cmock_call_instance, commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks); +} + +void vkCmdSetColorWriteMaskEXT_AddCallback(CMOCK_vkCmdSetColorWriteMaskEXT_CALLBACK Callback) +{ + Mock.vkCmdSetColorWriteMaskEXT_IgnoreBool = (char)0; + Mock.vkCmdSetColorWriteMaskEXT_CallbackBool = (char)1; + Mock.vkCmdSetColorWriteMaskEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetColorWriteMaskEXT_Stub(CMOCK_vkCmdSetColorWriteMaskEXT_CALLBACK Callback) +{ + Mock.vkCmdSetColorWriteMaskEXT_IgnoreBool = (char)0; + Mock.vkCmdSetColorWriteMaskEXT_CallbackBool = (char)0; + Mock.vkCmdSetColorWriteMaskEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetColorWriteMaskEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetColorWriteMaskEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetColorWriteMaskEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetColorWriteMaskEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetColorWriteMaskEXT_CMockIgnoreArg_firstAttachment(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetColorWriteMaskEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetColorWriteMaskEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetColorWriteMaskEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstAttachment = 1; +} + +void vkCmdSetColorWriteMaskEXT_CMockIgnoreArg_attachmentCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetColorWriteMaskEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetColorWriteMaskEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetColorWriteMaskEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_attachmentCount = 1; +} + +void vkCmdSetColorWriteMaskEXT_CMockIgnoreArg_pColorWriteMasks(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetColorWriteMaskEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetColorWriteMaskEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetColorWriteMaskEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pColorWriteMasks = 1; +} + +void vkCmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer, uint32_t rasterizationStream) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetRasterizationStreamEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetRasterizationStreamEXT); + cmock_call_instance = (CMOCK_vkCmdSetRasterizationStreamEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetRasterizationStreamEXT_CallInstance); + Mock.vkCmdSetRasterizationStreamEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetRasterizationStreamEXT_CallInstance); + if (Mock.vkCmdSetRasterizationStreamEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetRasterizationStreamEXT_CallbackBool && + Mock.vkCmdSetRasterizationStreamEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetRasterizationStreamEXT_CallbackFunctionPointer(commandBuffer, rasterizationStream, Mock.vkCmdSetRasterizationStreamEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetRasterizationStreamEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_rasterizationStream) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetRasterizationStreamEXT,CMockString_rasterizationStream); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_rasterizationStream, rasterizationStream, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetRasterizationStreamEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetRasterizationStreamEXT_CallbackFunctionPointer(commandBuffer, rasterizationStream, Mock.vkCmdSetRasterizationStreamEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetRasterizationStreamEXT(CMOCK_vkCmdSetRasterizationStreamEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t rasterizationStream); +void CMockExpectParameters_vkCmdSetRasterizationStreamEXT(CMOCK_vkCmdSetRasterizationStreamEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t rasterizationStream) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_rasterizationStream = rasterizationStream; + cmock_call_instance->IgnoreArg_rasterizationStream = 0; +} + +void vkCmdSetRasterizationStreamEXT_CMockIgnore(void) +{ + Mock.vkCmdSetRasterizationStreamEXT_IgnoreBool = (char)1; +} + +void vkCmdSetRasterizationStreamEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetRasterizationStreamEXT_IgnoreBool = (char)0; +} + +void vkCmdSetRasterizationStreamEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetRasterizationStreamEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetRasterizationStreamEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetRasterizationStreamEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetRasterizationStreamEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetRasterizationStreamEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetRasterizationStreamEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetRasterizationStreamEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t rasterizationStream) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetRasterizationStreamEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetRasterizationStreamEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetRasterizationStreamEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetRasterizationStreamEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetRasterizationStreamEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetRasterizationStreamEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetRasterizationStreamEXT(cmock_call_instance, commandBuffer, rasterizationStream); +} + +void vkCmdSetRasterizationStreamEXT_AddCallback(CMOCK_vkCmdSetRasterizationStreamEXT_CALLBACK Callback) +{ + Mock.vkCmdSetRasterizationStreamEXT_IgnoreBool = (char)0; + Mock.vkCmdSetRasterizationStreamEXT_CallbackBool = (char)1; + Mock.vkCmdSetRasterizationStreamEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetRasterizationStreamEXT_Stub(CMOCK_vkCmdSetRasterizationStreamEXT_CALLBACK Callback) +{ + Mock.vkCmdSetRasterizationStreamEXT_IgnoreBool = (char)0; + Mock.vkCmdSetRasterizationStreamEXT_CallbackBool = (char)0; + Mock.vkCmdSetRasterizationStreamEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetRasterizationStreamEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetRasterizationStreamEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetRasterizationStreamEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetRasterizationStreamEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetRasterizationStreamEXT_CMockIgnoreArg_rasterizationStream(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetRasterizationStreamEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetRasterizationStreamEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetRasterizationStreamEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_rasterizationStream = 1; +} + +void vkCmdSetConservativeRasterizationModeEXT(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetConservativeRasterizationModeEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetConservativeRasterizationModeEXT); + cmock_call_instance = (CMOCK_vkCmdSetConservativeRasterizationModeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetConservativeRasterizationModeEXT_CallInstance); + Mock.vkCmdSetConservativeRasterizationModeEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetConservativeRasterizationModeEXT_CallInstance); + if (Mock.vkCmdSetConservativeRasterizationModeEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetConservativeRasterizationModeEXT_CallbackBool && + Mock.vkCmdSetConservativeRasterizationModeEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetConservativeRasterizationModeEXT_CallbackFunctionPointer(commandBuffer, conservativeRasterizationMode, Mock.vkCmdSetConservativeRasterizationModeEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetConservativeRasterizationModeEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_conservativeRasterizationMode) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetConservativeRasterizationModeEXT,CMockString_conservativeRasterizationMode); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_conservativeRasterizationMode), (void*)(&conservativeRasterizationMode), sizeof(VkConservativeRasterizationModeEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetConservativeRasterizationModeEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetConservativeRasterizationModeEXT_CallbackFunctionPointer(commandBuffer, conservativeRasterizationMode, Mock.vkCmdSetConservativeRasterizationModeEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetConservativeRasterizationModeEXT(CMOCK_vkCmdSetConservativeRasterizationModeEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode); +void CMockExpectParameters_vkCmdSetConservativeRasterizationModeEXT(CMOCK_vkCmdSetConservativeRasterizationModeEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_conservativeRasterizationMode), (void*)(&conservativeRasterizationMode), + sizeof(VkConservativeRasterizationModeEXT[sizeof(conservativeRasterizationMode) == sizeof(VkConservativeRasterizationModeEXT) ? 1 : -1])); /* add VkConservativeRasterizationModeEXT to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_conservativeRasterizationMode = 0; +} + +void vkCmdSetConservativeRasterizationModeEXT_CMockIgnore(void) +{ + Mock.vkCmdSetConservativeRasterizationModeEXT_IgnoreBool = (char)1; +} + +void vkCmdSetConservativeRasterizationModeEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetConservativeRasterizationModeEXT_IgnoreBool = (char)0; +} + +void vkCmdSetConservativeRasterizationModeEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetConservativeRasterizationModeEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetConservativeRasterizationModeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetConservativeRasterizationModeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetConservativeRasterizationModeEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetConservativeRasterizationModeEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetConservativeRasterizationModeEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetConservativeRasterizationModeEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetConservativeRasterizationModeEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetConservativeRasterizationModeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetConservativeRasterizationModeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetConservativeRasterizationModeEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetConservativeRasterizationModeEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetConservativeRasterizationModeEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetConservativeRasterizationModeEXT(cmock_call_instance, commandBuffer, conservativeRasterizationMode); +} + +void vkCmdSetConservativeRasterizationModeEXT_AddCallback(CMOCK_vkCmdSetConservativeRasterizationModeEXT_CALLBACK Callback) +{ + Mock.vkCmdSetConservativeRasterizationModeEXT_IgnoreBool = (char)0; + Mock.vkCmdSetConservativeRasterizationModeEXT_CallbackBool = (char)1; + Mock.vkCmdSetConservativeRasterizationModeEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetConservativeRasterizationModeEXT_Stub(CMOCK_vkCmdSetConservativeRasterizationModeEXT_CALLBACK Callback) +{ + Mock.vkCmdSetConservativeRasterizationModeEXT_IgnoreBool = (char)0; + Mock.vkCmdSetConservativeRasterizationModeEXT_CallbackBool = (char)0; + Mock.vkCmdSetConservativeRasterizationModeEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetConservativeRasterizationModeEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetConservativeRasterizationModeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetConservativeRasterizationModeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetConservativeRasterizationModeEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetConservativeRasterizationModeEXT_CMockIgnoreArg_conservativeRasterizationMode(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetConservativeRasterizationModeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetConservativeRasterizationModeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetConservativeRasterizationModeEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_conservativeRasterizationMode = 1; +} + +void vkCmdSetExtraPrimitiveOverestimationSizeEXT(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetExtraPrimitiveOverestimationSizeEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetExtraPrimitiveOverestimationSizeEXT); + cmock_call_instance = (CMOCK_vkCmdSetExtraPrimitiveOverestimationSizeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetExtraPrimitiveOverestimationSizeEXT_CallInstance); + Mock.vkCmdSetExtraPrimitiveOverestimationSizeEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetExtraPrimitiveOverestimationSizeEXT_CallInstance); + if (Mock.vkCmdSetExtraPrimitiveOverestimationSizeEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetExtraPrimitiveOverestimationSizeEXT_CallbackBool && + Mock.vkCmdSetExtraPrimitiveOverestimationSizeEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetExtraPrimitiveOverestimationSizeEXT_CallbackFunctionPointer(commandBuffer, extraPrimitiveOverestimationSize, Mock.vkCmdSetExtraPrimitiveOverestimationSizeEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetExtraPrimitiveOverestimationSizeEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_extraPrimitiveOverestimationSize) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetExtraPrimitiveOverestimationSizeEXT,CMockString_extraPrimitiveOverestimationSize); + UNITY_TEST_ASSERT_EQUAL_FLOAT(cmock_call_instance->Expected_extraPrimitiveOverestimationSize, extraPrimitiveOverestimationSize, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetExtraPrimitiveOverestimationSizeEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetExtraPrimitiveOverestimationSizeEXT_CallbackFunctionPointer(commandBuffer, extraPrimitiveOverestimationSize, Mock.vkCmdSetExtraPrimitiveOverestimationSizeEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetExtraPrimitiveOverestimationSizeEXT(CMOCK_vkCmdSetExtraPrimitiveOverestimationSizeEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize); +void CMockExpectParameters_vkCmdSetExtraPrimitiveOverestimationSizeEXT(CMOCK_vkCmdSetExtraPrimitiveOverestimationSizeEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_extraPrimitiveOverestimationSize = extraPrimitiveOverestimationSize; + cmock_call_instance->IgnoreArg_extraPrimitiveOverestimationSize = 0; +} + +void vkCmdSetExtraPrimitiveOverestimationSizeEXT_CMockIgnore(void) +{ + Mock.vkCmdSetExtraPrimitiveOverestimationSizeEXT_IgnoreBool = (char)1; +} + +void vkCmdSetExtraPrimitiveOverestimationSizeEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetExtraPrimitiveOverestimationSizeEXT_IgnoreBool = (char)0; +} + +void vkCmdSetExtraPrimitiveOverestimationSizeEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetExtraPrimitiveOverestimationSizeEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetExtraPrimitiveOverestimationSizeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetExtraPrimitiveOverestimationSizeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetExtraPrimitiveOverestimationSizeEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetExtraPrimitiveOverestimationSizeEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetExtraPrimitiveOverestimationSizeEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetExtraPrimitiveOverestimationSizeEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetExtraPrimitiveOverestimationSizeEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetExtraPrimitiveOverestimationSizeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetExtraPrimitiveOverestimationSizeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetExtraPrimitiveOverestimationSizeEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetExtraPrimitiveOverestimationSizeEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetExtraPrimitiveOverestimationSizeEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetExtraPrimitiveOverestimationSizeEXT(cmock_call_instance, commandBuffer, extraPrimitiveOverestimationSize); +} + +void vkCmdSetExtraPrimitiveOverestimationSizeEXT_AddCallback(CMOCK_vkCmdSetExtraPrimitiveOverestimationSizeEXT_CALLBACK Callback) +{ + Mock.vkCmdSetExtraPrimitiveOverestimationSizeEXT_IgnoreBool = (char)0; + Mock.vkCmdSetExtraPrimitiveOverestimationSizeEXT_CallbackBool = (char)1; + Mock.vkCmdSetExtraPrimitiveOverestimationSizeEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetExtraPrimitiveOverestimationSizeEXT_Stub(CMOCK_vkCmdSetExtraPrimitiveOverestimationSizeEXT_CALLBACK Callback) +{ + Mock.vkCmdSetExtraPrimitiveOverestimationSizeEXT_IgnoreBool = (char)0; + Mock.vkCmdSetExtraPrimitiveOverestimationSizeEXT_CallbackBool = (char)0; + Mock.vkCmdSetExtraPrimitiveOverestimationSizeEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetExtraPrimitiveOverestimationSizeEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetExtraPrimitiveOverestimationSizeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetExtraPrimitiveOverestimationSizeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetExtraPrimitiveOverestimationSizeEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetExtraPrimitiveOverestimationSizeEXT_CMockIgnoreArg_extraPrimitiveOverestimationSize(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetExtraPrimitiveOverestimationSizeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetExtraPrimitiveOverestimationSizeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetExtraPrimitiveOverestimationSizeEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_extraPrimitiveOverestimationSize = 1; +} + +void vkCmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetDepthClipEnableEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetDepthClipEnableEXT); + cmock_call_instance = (CMOCK_vkCmdSetDepthClipEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetDepthClipEnableEXT_CallInstance); + Mock.vkCmdSetDepthClipEnableEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetDepthClipEnableEXT_CallInstance); + if (Mock.vkCmdSetDepthClipEnableEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetDepthClipEnableEXT_CallbackBool && + Mock.vkCmdSetDepthClipEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDepthClipEnableEXT_CallbackFunctionPointer(commandBuffer, depthClipEnable, Mock.vkCmdSetDepthClipEnableEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthClipEnableEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_depthClipEnable) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthClipEnableEXT,CMockString_depthClipEnable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_depthClipEnable), (void*)(&depthClipEnable), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetDepthClipEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDepthClipEnableEXT_CallbackFunctionPointer(commandBuffer, depthClipEnable, Mock.vkCmdSetDepthClipEnableEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetDepthClipEnableEXT(CMOCK_vkCmdSetDepthClipEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 depthClipEnable); +void CMockExpectParameters_vkCmdSetDepthClipEnableEXT(CMOCK_vkCmdSetDepthClipEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 depthClipEnable) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_depthClipEnable), (void*)(&depthClipEnable), + sizeof(VkBool32[sizeof(depthClipEnable) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_depthClipEnable = 0; +} + +void vkCmdSetDepthClipEnableEXT_CMockIgnore(void) +{ + Mock.vkCmdSetDepthClipEnableEXT_IgnoreBool = (char)1; +} + +void vkCmdSetDepthClipEnableEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetDepthClipEnableEXT_IgnoreBool = (char)0; +} + +void vkCmdSetDepthClipEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDepthClipEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetDepthClipEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthClipEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDepthClipEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDepthClipEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetDepthClipEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetDepthClipEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 depthClipEnable) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDepthClipEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetDepthClipEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthClipEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDepthClipEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDepthClipEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetDepthClipEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetDepthClipEnableEXT(cmock_call_instance, commandBuffer, depthClipEnable); +} + +void vkCmdSetDepthClipEnableEXT_AddCallback(CMOCK_vkCmdSetDepthClipEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetDepthClipEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetDepthClipEnableEXT_CallbackBool = (char)1; + Mock.vkCmdSetDepthClipEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDepthClipEnableEXT_Stub(CMOCK_vkCmdSetDepthClipEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetDepthClipEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetDepthClipEnableEXT_CallbackBool = (char)0; + Mock.vkCmdSetDepthClipEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDepthClipEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthClipEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthClipEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthClipEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetDepthClipEnableEXT_CMockIgnoreArg_depthClipEnable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthClipEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthClipEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthClipEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_depthClipEnable = 1; +} + +void vkCmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetSampleLocationsEnableEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetSampleLocationsEnableEXT); + cmock_call_instance = (CMOCK_vkCmdSetSampleLocationsEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetSampleLocationsEnableEXT_CallInstance); + Mock.vkCmdSetSampleLocationsEnableEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetSampleLocationsEnableEXT_CallInstance); + if (Mock.vkCmdSetSampleLocationsEnableEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetSampleLocationsEnableEXT_CallbackBool && + Mock.vkCmdSetSampleLocationsEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetSampleLocationsEnableEXT_CallbackFunctionPointer(commandBuffer, sampleLocationsEnable, Mock.vkCmdSetSampleLocationsEnableEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetSampleLocationsEnableEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_sampleLocationsEnable) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetSampleLocationsEnableEXT,CMockString_sampleLocationsEnable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_sampleLocationsEnable), (void*)(&sampleLocationsEnable), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetSampleLocationsEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetSampleLocationsEnableEXT_CallbackFunctionPointer(commandBuffer, sampleLocationsEnable, Mock.vkCmdSetSampleLocationsEnableEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetSampleLocationsEnableEXT(CMOCK_vkCmdSetSampleLocationsEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable); +void CMockExpectParameters_vkCmdSetSampleLocationsEnableEXT(CMOCK_vkCmdSetSampleLocationsEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_sampleLocationsEnable), (void*)(&sampleLocationsEnable), + sizeof(VkBool32[sizeof(sampleLocationsEnable) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_sampleLocationsEnable = 0; +} + +void vkCmdSetSampleLocationsEnableEXT_CMockIgnore(void) +{ + Mock.vkCmdSetSampleLocationsEnableEXT_IgnoreBool = (char)1; +} + +void vkCmdSetSampleLocationsEnableEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetSampleLocationsEnableEXT_IgnoreBool = (char)0; +} + +void vkCmdSetSampleLocationsEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetSampleLocationsEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetSampleLocationsEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetSampleLocationsEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetSampleLocationsEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetSampleLocationsEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetSampleLocationsEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetSampleLocationsEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetSampleLocationsEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetSampleLocationsEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetSampleLocationsEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetSampleLocationsEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetSampleLocationsEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetSampleLocationsEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetSampleLocationsEnableEXT(cmock_call_instance, commandBuffer, sampleLocationsEnable); +} + +void vkCmdSetSampleLocationsEnableEXT_AddCallback(CMOCK_vkCmdSetSampleLocationsEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetSampleLocationsEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetSampleLocationsEnableEXT_CallbackBool = (char)1; + Mock.vkCmdSetSampleLocationsEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetSampleLocationsEnableEXT_Stub(CMOCK_vkCmdSetSampleLocationsEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetSampleLocationsEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetSampleLocationsEnableEXT_CallbackBool = (char)0; + Mock.vkCmdSetSampleLocationsEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetSampleLocationsEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetSampleLocationsEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetSampleLocationsEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetSampleLocationsEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetSampleLocationsEnableEXT_CMockIgnoreArg_sampleLocationsEnable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetSampleLocationsEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetSampleLocationsEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetSampleLocationsEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_sampleLocationsEnable = 1; +} + +void vkCmdSetColorBlendAdvancedEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetColorBlendAdvancedEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetColorBlendAdvancedEXT); + cmock_call_instance = (CMOCK_vkCmdSetColorBlendAdvancedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetColorBlendAdvancedEXT_CallInstance); + Mock.vkCmdSetColorBlendAdvancedEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetColorBlendAdvancedEXT_CallInstance); + if (Mock.vkCmdSetColorBlendAdvancedEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetColorBlendAdvancedEXT_CallbackBool && + Mock.vkCmdSetColorBlendAdvancedEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetColorBlendAdvancedEXT_CallbackFunctionPointer(commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced, Mock.vkCmdSetColorBlendAdvancedEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetColorBlendAdvancedEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstAttachment) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetColorBlendAdvancedEXT,CMockString_firstAttachment); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstAttachment, firstAttachment, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_attachmentCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetColorBlendAdvancedEXT,CMockString_attachmentCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_attachmentCount, attachmentCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pColorBlendAdvanced) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetColorBlendAdvancedEXT,CMockString_pColorBlendAdvanced); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pColorBlendAdvanced), (void*)(pColorBlendAdvanced), sizeof(const VkColorBlendAdvancedEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetColorBlendAdvancedEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetColorBlendAdvancedEXT_CallbackFunctionPointer(commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced, Mock.vkCmdSetColorBlendAdvancedEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetColorBlendAdvancedEXT(CMOCK_vkCmdSetColorBlendAdvancedEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced); +void CMockExpectParameters_vkCmdSetColorBlendAdvancedEXT(CMOCK_vkCmdSetColorBlendAdvancedEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_firstAttachment = firstAttachment; + cmock_call_instance->IgnoreArg_firstAttachment = 0; + cmock_call_instance->Expected_attachmentCount = attachmentCount; + cmock_call_instance->IgnoreArg_attachmentCount = 0; + cmock_call_instance->Expected_pColorBlendAdvanced = pColorBlendAdvanced; + cmock_call_instance->IgnoreArg_pColorBlendAdvanced = 0; +} + +void vkCmdSetColorBlendAdvancedEXT_CMockIgnore(void) +{ + Mock.vkCmdSetColorBlendAdvancedEXT_IgnoreBool = (char)1; +} + +void vkCmdSetColorBlendAdvancedEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetColorBlendAdvancedEXT_IgnoreBool = (char)0; +} + +void vkCmdSetColorBlendAdvancedEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetColorBlendAdvancedEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetColorBlendAdvancedEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetColorBlendAdvancedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetColorBlendAdvancedEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetColorBlendAdvancedEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetColorBlendAdvancedEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetColorBlendAdvancedEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetColorBlendAdvancedEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetColorBlendAdvancedEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetColorBlendAdvancedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetColorBlendAdvancedEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetColorBlendAdvancedEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetColorBlendAdvancedEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetColorBlendAdvancedEXT(cmock_call_instance, commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced); +} + +void vkCmdSetColorBlendAdvancedEXT_AddCallback(CMOCK_vkCmdSetColorBlendAdvancedEXT_CALLBACK Callback) +{ + Mock.vkCmdSetColorBlendAdvancedEXT_IgnoreBool = (char)0; + Mock.vkCmdSetColorBlendAdvancedEXT_CallbackBool = (char)1; + Mock.vkCmdSetColorBlendAdvancedEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetColorBlendAdvancedEXT_Stub(CMOCK_vkCmdSetColorBlendAdvancedEXT_CALLBACK Callback) +{ + Mock.vkCmdSetColorBlendAdvancedEXT_IgnoreBool = (char)0; + Mock.vkCmdSetColorBlendAdvancedEXT_CallbackBool = (char)0; + Mock.vkCmdSetColorBlendAdvancedEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetColorBlendAdvancedEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetColorBlendAdvancedEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetColorBlendAdvancedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetColorBlendAdvancedEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetColorBlendAdvancedEXT_CMockIgnoreArg_firstAttachment(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetColorBlendAdvancedEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetColorBlendAdvancedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetColorBlendAdvancedEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstAttachment = 1; +} + +void vkCmdSetColorBlendAdvancedEXT_CMockIgnoreArg_attachmentCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetColorBlendAdvancedEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetColorBlendAdvancedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetColorBlendAdvancedEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_attachmentCount = 1; +} + +void vkCmdSetColorBlendAdvancedEXT_CMockIgnoreArg_pColorBlendAdvanced(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetColorBlendAdvancedEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetColorBlendAdvancedEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetColorBlendAdvancedEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pColorBlendAdvanced = 1; +} + +void vkCmdSetProvokingVertexModeEXT(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetProvokingVertexModeEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetProvokingVertexModeEXT); + cmock_call_instance = (CMOCK_vkCmdSetProvokingVertexModeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetProvokingVertexModeEXT_CallInstance); + Mock.vkCmdSetProvokingVertexModeEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetProvokingVertexModeEXT_CallInstance); + if (Mock.vkCmdSetProvokingVertexModeEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetProvokingVertexModeEXT_CallbackBool && + Mock.vkCmdSetProvokingVertexModeEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetProvokingVertexModeEXT_CallbackFunctionPointer(commandBuffer, provokingVertexMode, Mock.vkCmdSetProvokingVertexModeEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetProvokingVertexModeEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_provokingVertexMode) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetProvokingVertexModeEXT,CMockString_provokingVertexMode); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_provokingVertexMode), (void*)(&provokingVertexMode), sizeof(VkProvokingVertexModeEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetProvokingVertexModeEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetProvokingVertexModeEXT_CallbackFunctionPointer(commandBuffer, provokingVertexMode, Mock.vkCmdSetProvokingVertexModeEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetProvokingVertexModeEXT(CMOCK_vkCmdSetProvokingVertexModeEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode); +void CMockExpectParameters_vkCmdSetProvokingVertexModeEXT(CMOCK_vkCmdSetProvokingVertexModeEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_provokingVertexMode), (void*)(&provokingVertexMode), + sizeof(VkProvokingVertexModeEXT[sizeof(provokingVertexMode) == sizeof(VkProvokingVertexModeEXT) ? 1 : -1])); /* add VkProvokingVertexModeEXT to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_provokingVertexMode = 0; +} + +void vkCmdSetProvokingVertexModeEXT_CMockIgnore(void) +{ + Mock.vkCmdSetProvokingVertexModeEXT_IgnoreBool = (char)1; +} + +void vkCmdSetProvokingVertexModeEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetProvokingVertexModeEXT_IgnoreBool = (char)0; +} + +void vkCmdSetProvokingVertexModeEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetProvokingVertexModeEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetProvokingVertexModeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetProvokingVertexModeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetProvokingVertexModeEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetProvokingVertexModeEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetProvokingVertexModeEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetProvokingVertexModeEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetProvokingVertexModeEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetProvokingVertexModeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetProvokingVertexModeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetProvokingVertexModeEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetProvokingVertexModeEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetProvokingVertexModeEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetProvokingVertexModeEXT(cmock_call_instance, commandBuffer, provokingVertexMode); +} + +void vkCmdSetProvokingVertexModeEXT_AddCallback(CMOCK_vkCmdSetProvokingVertexModeEXT_CALLBACK Callback) +{ + Mock.vkCmdSetProvokingVertexModeEXT_IgnoreBool = (char)0; + Mock.vkCmdSetProvokingVertexModeEXT_CallbackBool = (char)1; + Mock.vkCmdSetProvokingVertexModeEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetProvokingVertexModeEXT_Stub(CMOCK_vkCmdSetProvokingVertexModeEXT_CALLBACK Callback) +{ + Mock.vkCmdSetProvokingVertexModeEXT_IgnoreBool = (char)0; + Mock.vkCmdSetProvokingVertexModeEXT_CallbackBool = (char)0; + Mock.vkCmdSetProvokingVertexModeEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetProvokingVertexModeEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetProvokingVertexModeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetProvokingVertexModeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetProvokingVertexModeEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetProvokingVertexModeEXT_CMockIgnoreArg_provokingVertexMode(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetProvokingVertexModeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetProvokingVertexModeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetProvokingVertexModeEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_provokingVertexMode = 1; +} + +void vkCmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetLineRasterizationModeEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetLineRasterizationModeEXT); + cmock_call_instance = (CMOCK_vkCmdSetLineRasterizationModeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetLineRasterizationModeEXT_CallInstance); + Mock.vkCmdSetLineRasterizationModeEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetLineRasterizationModeEXT_CallInstance); + if (Mock.vkCmdSetLineRasterizationModeEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetLineRasterizationModeEXT_CallbackBool && + Mock.vkCmdSetLineRasterizationModeEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetLineRasterizationModeEXT_CallbackFunctionPointer(commandBuffer, lineRasterizationMode, Mock.vkCmdSetLineRasterizationModeEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetLineRasterizationModeEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_lineRasterizationMode) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetLineRasterizationModeEXT,CMockString_lineRasterizationMode); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_lineRasterizationMode), (void*)(&lineRasterizationMode), sizeof(VkLineRasterizationModeEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetLineRasterizationModeEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetLineRasterizationModeEXT_CallbackFunctionPointer(commandBuffer, lineRasterizationMode, Mock.vkCmdSetLineRasterizationModeEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetLineRasterizationModeEXT(CMOCK_vkCmdSetLineRasterizationModeEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode); +void CMockExpectParameters_vkCmdSetLineRasterizationModeEXT(CMOCK_vkCmdSetLineRasterizationModeEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_lineRasterizationMode), (void*)(&lineRasterizationMode), + sizeof(VkLineRasterizationModeEXT[sizeof(lineRasterizationMode) == sizeof(VkLineRasterizationModeEXT) ? 1 : -1])); /* add VkLineRasterizationModeEXT to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_lineRasterizationMode = 0; +} + +void vkCmdSetLineRasterizationModeEXT_CMockIgnore(void) +{ + Mock.vkCmdSetLineRasterizationModeEXT_IgnoreBool = (char)1; +} + +void vkCmdSetLineRasterizationModeEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetLineRasterizationModeEXT_IgnoreBool = (char)0; +} + +void vkCmdSetLineRasterizationModeEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetLineRasterizationModeEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetLineRasterizationModeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetLineRasterizationModeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetLineRasterizationModeEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetLineRasterizationModeEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetLineRasterizationModeEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetLineRasterizationModeEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetLineRasterizationModeEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetLineRasterizationModeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetLineRasterizationModeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetLineRasterizationModeEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetLineRasterizationModeEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetLineRasterizationModeEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetLineRasterizationModeEXT(cmock_call_instance, commandBuffer, lineRasterizationMode); +} + +void vkCmdSetLineRasterizationModeEXT_AddCallback(CMOCK_vkCmdSetLineRasterizationModeEXT_CALLBACK Callback) +{ + Mock.vkCmdSetLineRasterizationModeEXT_IgnoreBool = (char)0; + Mock.vkCmdSetLineRasterizationModeEXT_CallbackBool = (char)1; + Mock.vkCmdSetLineRasterizationModeEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetLineRasterizationModeEXT_Stub(CMOCK_vkCmdSetLineRasterizationModeEXT_CALLBACK Callback) +{ + Mock.vkCmdSetLineRasterizationModeEXT_IgnoreBool = (char)0; + Mock.vkCmdSetLineRasterizationModeEXT_CallbackBool = (char)0; + Mock.vkCmdSetLineRasterizationModeEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetLineRasterizationModeEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetLineRasterizationModeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetLineRasterizationModeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetLineRasterizationModeEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetLineRasterizationModeEXT_CMockIgnoreArg_lineRasterizationMode(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetLineRasterizationModeEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetLineRasterizationModeEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetLineRasterizationModeEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_lineRasterizationMode = 1; +} + +void vkCmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetLineStippleEnableEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetLineStippleEnableEXT); + cmock_call_instance = (CMOCK_vkCmdSetLineStippleEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetLineStippleEnableEXT_CallInstance); + Mock.vkCmdSetLineStippleEnableEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetLineStippleEnableEXT_CallInstance); + if (Mock.vkCmdSetLineStippleEnableEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetLineStippleEnableEXT_CallbackBool && + Mock.vkCmdSetLineStippleEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetLineStippleEnableEXT_CallbackFunctionPointer(commandBuffer, stippledLineEnable, Mock.vkCmdSetLineStippleEnableEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetLineStippleEnableEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_stippledLineEnable) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetLineStippleEnableEXT,CMockString_stippledLineEnable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_stippledLineEnable), (void*)(&stippledLineEnable), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetLineStippleEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetLineStippleEnableEXT_CallbackFunctionPointer(commandBuffer, stippledLineEnable, Mock.vkCmdSetLineStippleEnableEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetLineStippleEnableEXT(CMOCK_vkCmdSetLineStippleEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable); +void CMockExpectParameters_vkCmdSetLineStippleEnableEXT(CMOCK_vkCmdSetLineStippleEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_stippledLineEnable), (void*)(&stippledLineEnable), + sizeof(VkBool32[sizeof(stippledLineEnable) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_stippledLineEnable = 0; +} + +void vkCmdSetLineStippleEnableEXT_CMockIgnore(void) +{ + Mock.vkCmdSetLineStippleEnableEXT_IgnoreBool = (char)1; +} + +void vkCmdSetLineStippleEnableEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetLineStippleEnableEXT_IgnoreBool = (char)0; +} + +void vkCmdSetLineStippleEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetLineStippleEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetLineStippleEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetLineStippleEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetLineStippleEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetLineStippleEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetLineStippleEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetLineStippleEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetLineStippleEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetLineStippleEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetLineStippleEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetLineStippleEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetLineStippleEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetLineStippleEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetLineStippleEnableEXT(cmock_call_instance, commandBuffer, stippledLineEnable); +} + +void vkCmdSetLineStippleEnableEXT_AddCallback(CMOCK_vkCmdSetLineStippleEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetLineStippleEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetLineStippleEnableEXT_CallbackBool = (char)1; + Mock.vkCmdSetLineStippleEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetLineStippleEnableEXT_Stub(CMOCK_vkCmdSetLineStippleEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetLineStippleEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetLineStippleEnableEXT_CallbackBool = (char)0; + Mock.vkCmdSetLineStippleEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetLineStippleEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetLineStippleEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetLineStippleEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetLineStippleEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetLineStippleEnableEXT_CMockIgnoreArg_stippledLineEnable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetLineStippleEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetLineStippleEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetLineStippleEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stippledLineEnable = 1; +} + +void vkCmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetDepthClipNegativeOneToOneEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetDepthClipNegativeOneToOneEXT); + cmock_call_instance = (CMOCK_vkCmdSetDepthClipNegativeOneToOneEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetDepthClipNegativeOneToOneEXT_CallInstance); + Mock.vkCmdSetDepthClipNegativeOneToOneEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetDepthClipNegativeOneToOneEXT_CallInstance); + if (Mock.vkCmdSetDepthClipNegativeOneToOneEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetDepthClipNegativeOneToOneEXT_CallbackBool && + Mock.vkCmdSetDepthClipNegativeOneToOneEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDepthClipNegativeOneToOneEXT_CallbackFunctionPointer(commandBuffer, negativeOneToOne, Mock.vkCmdSetDepthClipNegativeOneToOneEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthClipNegativeOneToOneEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_negativeOneToOne) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetDepthClipNegativeOneToOneEXT,CMockString_negativeOneToOne); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_negativeOneToOne), (void*)(&negativeOneToOne), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetDepthClipNegativeOneToOneEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetDepthClipNegativeOneToOneEXT_CallbackFunctionPointer(commandBuffer, negativeOneToOne, Mock.vkCmdSetDepthClipNegativeOneToOneEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetDepthClipNegativeOneToOneEXT(CMOCK_vkCmdSetDepthClipNegativeOneToOneEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne); +void CMockExpectParameters_vkCmdSetDepthClipNegativeOneToOneEXT(CMOCK_vkCmdSetDepthClipNegativeOneToOneEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_negativeOneToOne), (void*)(&negativeOneToOne), + sizeof(VkBool32[sizeof(negativeOneToOne) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_negativeOneToOne = 0; +} + +void vkCmdSetDepthClipNegativeOneToOneEXT_CMockIgnore(void) +{ + Mock.vkCmdSetDepthClipNegativeOneToOneEXT_IgnoreBool = (char)1; +} + +void vkCmdSetDepthClipNegativeOneToOneEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetDepthClipNegativeOneToOneEXT_IgnoreBool = (char)0; +} + +void vkCmdSetDepthClipNegativeOneToOneEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDepthClipNegativeOneToOneEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetDepthClipNegativeOneToOneEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthClipNegativeOneToOneEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDepthClipNegativeOneToOneEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDepthClipNegativeOneToOneEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetDepthClipNegativeOneToOneEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetDepthClipNegativeOneToOneEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetDepthClipNegativeOneToOneEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetDepthClipNegativeOneToOneEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthClipNegativeOneToOneEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetDepthClipNegativeOneToOneEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetDepthClipNegativeOneToOneEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetDepthClipNegativeOneToOneEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetDepthClipNegativeOneToOneEXT(cmock_call_instance, commandBuffer, negativeOneToOne); +} + +void vkCmdSetDepthClipNegativeOneToOneEXT_AddCallback(CMOCK_vkCmdSetDepthClipNegativeOneToOneEXT_CALLBACK Callback) +{ + Mock.vkCmdSetDepthClipNegativeOneToOneEXT_IgnoreBool = (char)0; + Mock.vkCmdSetDepthClipNegativeOneToOneEXT_CallbackBool = (char)1; + Mock.vkCmdSetDepthClipNegativeOneToOneEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDepthClipNegativeOneToOneEXT_Stub(CMOCK_vkCmdSetDepthClipNegativeOneToOneEXT_CALLBACK Callback) +{ + Mock.vkCmdSetDepthClipNegativeOneToOneEXT_IgnoreBool = (char)0; + Mock.vkCmdSetDepthClipNegativeOneToOneEXT_CallbackBool = (char)0; + Mock.vkCmdSetDepthClipNegativeOneToOneEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetDepthClipNegativeOneToOneEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthClipNegativeOneToOneEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthClipNegativeOneToOneEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthClipNegativeOneToOneEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetDepthClipNegativeOneToOneEXT_CMockIgnoreArg_negativeOneToOne(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetDepthClipNegativeOneToOneEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetDepthClipNegativeOneToOneEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetDepthClipNegativeOneToOneEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_negativeOneToOne = 1; +} + +void vkCmdSetViewportWScalingEnableNV(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetViewportWScalingEnableNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetViewportWScalingEnableNV); + cmock_call_instance = (CMOCK_vkCmdSetViewportWScalingEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetViewportWScalingEnableNV_CallInstance); + Mock.vkCmdSetViewportWScalingEnableNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetViewportWScalingEnableNV_CallInstance); + if (Mock.vkCmdSetViewportWScalingEnableNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetViewportWScalingEnableNV_CallbackBool && + Mock.vkCmdSetViewportWScalingEnableNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetViewportWScalingEnableNV_CallbackFunctionPointer(commandBuffer, viewportWScalingEnable, Mock.vkCmdSetViewportWScalingEnableNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetViewportWScalingEnableNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_viewportWScalingEnable) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetViewportWScalingEnableNV,CMockString_viewportWScalingEnable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_viewportWScalingEnable), (void*)(&viewportWScalingEnable), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetViewportWScalingEnableNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetViewportWScalingEnableNV_CallbackFunctionPointer(commandBuffer, viewportWScalingEnable, Mock.vkCmdSetViewportWScalingEnableNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetViewportWScalingEnableNV(CMOCK_vkCmdSetViewportWScalingEnableNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable); +void CMockExpectParameters_vkCmdSetViewportWScalingEnableNV(CMOCK_vkCmdSetViewportWScalingEnableNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_viewportWScalingEnable), (void*)(&viewportWScalingEnable), + sizeof(VkBool32[sizeof(viewportWScalingEnable) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_viewportWScalingEnable = 0; +} + +void vkCmdSetViewportWScalingEnableNV_CMockIgnore(void) +{ + Mock.vkCmdSetViewportWScalingEnableNV_IgnoreBool = (char)1; +} + +void vkCmdSetViewportWScalingEnableNV_CMockStopIgnore(void) +{ + Mock.vkCmdSetViewportWScalingEnableNV_IgnoreBool = (char)0; +} + +void vkCmdSetViewportWScalingEnableNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetViewportWScalingEnableNV_CALL_INSTANCE)); + CMOCK_vkCmdSetViewportWScalingEnableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportWScalingEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetViewportWScalingEnableNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetViewportWScalingEnableNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetViewportWScalingEnableNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetViewportWScalingEnableNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetViewportWScalingEnableNV_CALL_INSTANCE)); + CMOCK_vkCmdSetViewportWScalingEnableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportWScalingEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetViewportWScalingEnableNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetViewportWScalingEnableNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetViewportWScalingEnableNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetViewportWScalingEnableNV(cmock_call_instance, commandBuffer, viewportWScalingEnable); +} + +void vkCmdSetViewportWScalingEnableNV_AddCallback(CMOCK_vkCmdSetViewportWScalingEnableNV_CALLBACK Callback) +{ + Mock.vkCmdSetViewportWScalingEnableNV_IgnoreBool = (char)0; + Mock.vkCmdSetViewportWScalingEnableNV_CallbackBool = (char)1; + Mock.vkCmdSetViewportWScalingEnableNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetViewportWScalingEnableNV_Stub(CMOCK_vkCmdSetViewportWScalingEnableNV_CALLBACK Callback) +{ + Mock.vkCmdSetViewportWScalingEnableNV_IgnoreBool = (char)0; + Mock.vkCmdSetViewportWScalingEnableNV_CallbackBool = (char)0; + Mock.vkCmdSetViewportWScalingEnableNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetViewportWScalingEnableNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetViewportWScalingEnableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportWScalingEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetViewportWScalingEnableNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetViewportWScalingEnableNV_CMockIgnoreArg_viewportWScalingEnable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetViewportWScalingEnableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportWScalingEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetViewportWScalingEnableNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_viewportWScalingEnable = 1; +} + +void vkCmdSetViewportSwizzleNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetViewportSwizzleNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetViewportSwizzleNV); + cmock_call_instance = (CMOCK_vkCmdSetViewportSwizzleNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetViewportSwizzleNV_CallInstance); + Mock.vkCmdSetViewportSwizzleNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetViewportSwizzleNV_CallInstance); + if (Mock.vkCmdSetViewportSwizzleNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetViewportSwizzleNV_CallbackBool && + Mock.vkCmdSetViewportSwizzleNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetViewportSwizzleNV_CallbackFunctionPointer(commandBuffer, firstViewport, viewportCount, pViewportSwizzles, Mock.vkCmdSetViewportSwizzleNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetViewportSwizzleNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstViewport) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetViewportSwizzleNV,CMockString_firstViewport); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstViewport, firstViewport, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_viewportCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetViewportSwizzleNV,CMockString_viewportCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_viewportCount, viewportCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pViewportSwizzles) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetViewportSwizzleNV,CMockString_pViewportSwizzles); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pViewportSwizzles), (void*)(pViewportSwizzles), sizeof(const VkViewportSwizzleNV), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetViewportSwizzleNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetViewportSwizzleNV_CallbackFunctionPointer(commandBuffer, firstViewport, viewportCount, pViewportSwizzles, Mock.vkCmdSetViewportSwizzleNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetViewportSwizzleNV(CMOCK_vkCmdSetViewportSwizzleNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles); +void CMockExpectParameters_vkCmdSetViewportSwizzleNV(CMOCK_vkCmdSetViewportSwizzleNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_firstViewport = firstViewport; + cmock_call_instance->IgnoreArg_firstViewport = 0; + cmock_call_instance->Expected_viewportCount = viewportCount; + cmock_call_instance->IgnoreArg_viewportCount = 0; + cmock_call_instance->Expected_pViewportSwizzles = pViewportSwizzles; + cmock_call_instance->IgnoreArg_pViewportSwizzles = 0; +} + +void vkCmdSetViewportSwizzleNV_CMockIgnore(void) +{ + Mock.vkCmdSetViewportSwizzleNV_IgnoreBool = (char)1; +} + +void vkCmdSetViewportSwizzleNV_CMockStopIgnore(void) +{ + Mock.vkCmdSetViewportSwizzleNV_IgnoreBool = (char)0; +} + +void vkCmdSetViewportSwizzleNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetViewportSwizzleNV_CALL_INSTANCE)); + CMOCK_vkCmdSetViewportSwizzleNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportSwizzleNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetViewportSwizzleNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetViewportSwizzleNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetViewportSwizzleNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetViewportSwizzleNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetViewportSwizzleNV_CALL_INSTANCE)); + CMOCK_vkCmdSetViewportSwizzleNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportSwizzleNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetViewportSwizzleNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetViewportSwizzleNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetViewportSwizzleNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetViewportSwizzleNV(cmock_call_instance, commandBuffer, firstViewport, viewportCount, pViewportSwizzles); +} + +void vkCmdSetViewportSwizzleNV_AddCallback(CMOCK_vkCmdSetViewportSwizzleNV_CALLBACK Callback) +{ + Mock.vkCmdSetViewportSwizzleNV_IgnoreBool = (char)0; + Mock.vkCmdSetViewportSwizzleNV_CallbackBool = (char)1; + Mock.vkCmdSetViewportSwizzleNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetViewportSwizzleNV_Stub(CMOCK_vkCmdSetViewportSwizzleNV_CALLBACK Callback) +{ + Mock.vkCmdSetViewportSwizzleNV_IgnoreBool = (char)0; + Mock.vkCmdSetViewportSwizzleNV_CallbackBool = (char)0; + Mock.vkCmdSetViewportSwizzleNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetViewportSwizzleNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetViewportSwizzleNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportSwizzleNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetViewportSwizzleNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetViewportSwizzleNV_CMockIgnoreArg_firstViewport(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetViewportSwizzleNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportSwizzleNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetViewportSwizzleNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstViewport = 1; +} + +void vkCmdSetViewportSwizzleNV_CMockIgnoreArg_viewportCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetViewportSwizzleNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportSwizzleNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetViewportSwizzleNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_viewportCount = 1; +} + +void vkCmdSetViewportSwizzleNV_CMockIgnoreArg_pViewportSwizzles(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetViewportSwizzleNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetViewportSwizzleNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetViewportSwizzleNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pViewportSwizzles = 1; +} + +void vkCmdSetCoverageToColorEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetCoverageToColorEnableNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetCoverageToColorEnableNV); + cmock_call_instance = (CMOCK_vkCmdSetCoverageToColorEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetCoverageToColorEnableNV_CallInstance); + Mock.vkCmdSetCoverageToColorEnableNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetCoverageToColorEnableNV_CallInstance); + if (Mock.vkCmdSetCoverageToColorEnableNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetCoverageToColorEnableNV_CallbackBool && + Mock.vkCmdSetCoverageToColorEnableNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetCoverageToColorEnableNV_CallbackFunctionPointer(commandBuffer, coverageToColorEnable, Mock.vkCmdSetCoverageToColorEnableNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetCoverageToColorEnableNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_coverageToColorEnable) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetCoverageToColorEnableNV,CMockString_coverageToColorEnable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_coverageToColorEnable), (void*)(&coverageToColorEnable), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetCoverageToColorEnableNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetCoverageToColorEnableNV_CallbackFunctionPointer(commandBuffer, coverageToColorEnable, Mock.vkCmdSetCoverageToColorEnableNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetCoverageToColorEnableNV(CMOCK_vkCmdSetCoverageToColorEnableNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable); +void CMockExpectParameters_vkCmdSetCoverageToColorEnableNV(CMOCK_vkCmdSetCoverageToColorEnableNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_coverageToColorEnable), (void*)(&coverageToColorEnable), + sizeof(VkBool32[sizeof(coverageToColorEnable) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_coverageToColorEnable = 0; +} + +void vkCmdSetCoverageToColorEnableNV_CMockIgnore(void) +{ + Mock.vkCmdSetCoverageToColorEnableNV_IgnoreBool = (char)1; +} + +void vkCmdSetCoverageToColorEnableNV_CMockStopIgnore(void) +{ + Mock.vkCmdSetCoverageToColorEnableNV_IgnoreBool = (char)0; +} + +void vkCmdSetCoverageToColorEnableNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetCoverageToColorEnableNV_CALL_INSTANCE)); + CMOCK_vkCmdSetCoverageToColorEnableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoverageToColorEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetCoverageToColorEnableNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetCoverageToColorEnableNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetCoverageToColorEnableNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetCoverageToColorEnableNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetCoverageToColorEnableNV_CALL_INSTANCE)); + CMOCK_vkCmdSetCoverageToColorEnableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoverageToColorEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetCoverageToColorEnableNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetCoverageToColorEnableNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetCoverageToColorEnableNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetCoverageToColorEnableNV(cmock_call_instance, commandBuffer, coverageToColorEnable); +} + +void vkCmdSetCoverageToColorEnableNV_AddCallback(CMOCK_vkCmdSetCoverageToColorEnableNV_CALLBACK Callback) +{ + Mock.vkCmdSetCoverageToColorEnableNV_IgnoreBool = (char)0; + Mock.vkCmdSetCoverageToColorEnableNV_CallbackBool = (char)1; + Mock.vkCmdSetCoverageToColorEnableNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetCoverageToColorEnableNV_Stub(CMOCK_vkCmdSetCoverageToColorEnableNV_CALLBACK Callback) +{ + Mock.vkCmdSetCoverageToColorEnableNV_IgnoreBool = (char)0; + Mock.vkCmdSetCoverageToColorEnableNV_CallbackBool = (char)0; + Mock.vkCmdSetCoverageToColorEnableNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetCoverageToColorEnableNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetCoverageToColorEnableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoverageToColorEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetCoverageToColorEnableNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetCoverageToColorEnableNV_CMockIgnoreArg_coverageToColorEnable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetCoverageToColorEnableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoverageToColorEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetCoverageToColorEnableNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_coverageToColorEnable = 1; +} + +void vkCmdSetCoverageToColorLocationNV(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetCoverageToColorLocationNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetCoverageToColorLocationNV); + cmock_call_instance = (CMOCK_vkCmdSetCoverageToColorLocationNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetCoverageToColorLocationNV_CallInstance); + Mock.vkCmdSetCoverageToColorLocationNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetCoverageToColorLocationNV_CallInstance); + if (Mock.vkCmdSetCoverageToColorLocationNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetCoverageToColorLocationNV_CallbackBool && + Mock.vkCmdSetCoverageToColorLocationNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetCoverageToColorLocationNV_CallbackFunctionPointer(commandBuffer, coverageToColorLocation, Mock.vkCmdSetCoverageToColorLocationNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetCoverageToColorLocationNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_coverageToColorLocation) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetCoverageToColorLocationNV,CMockString_coverageToColorLocation); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_coverageToColorLocation, coverageToColorLocation, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetCoverageToColorLocationNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetCoverageToColorLocationNV_CallbackFunctionPointer(commandBuffer, coverageToColorLocation, Mock.vkCmdSetCoverageToColorLocationNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetCoverageToColorLocationNV(CMOCK_vkCmdSetCoverageToColorLocationNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation); +void CMockExpectParameters_vkCmdSetCoverageToColorLocationNV(CMOCK_vkCmdSetCoverageToColorLocationNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_coverageToColorLocation = coverageToColorLocation; + cmock_call_instance->IgnoreArg_coverageToColorLocation = 0; +} + +void vkCmdSetCoverageToColorLocationNV_CMockIgnore(void) +{ + Mock.vkCmdSetCoverageToColorLocationNV_IgnoreBool = (char)1; +} + +void vkCmdSetCoverageToColorLocationNV_CMockStopIgnore(void) +{ + Mock.vkCmdSetCoverageToColorLocationNV_IgnoreBool = (char)0; +} + +void vkCmdSetCoverageToColorLocationNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetCoverageToColorLocationNV_CALL_INSTANCE)); + CMOCK_vkCmdSetCoverageToColorLocationNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoverageToColorLocationNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetCoverageToColorLocationNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetCoverageToColorLocationNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetCoverageToColorLocationNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetCoverageToColorLocationNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetCoverageToColorLocationNV_CALL_INSTANCE)); + CMOCK_vkCmdSetCoverageToColorLocationNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoverageToColorLocationNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetCoverageToColorLocationNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetCoverageToColorLocationNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetCoverageToColorLocationNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetCoverageToColorLocationNV(cmock_call_instance, commandBuffer, coverageToColorLocation); +} + +void vkCmdSetCoverageToColorLocationNV_AddCallback(CMOCK_vkCmdSetCoverageToColorLocationNV_CALLBACK Callback) +{ + Mock.vkCmdSetCoverageToColorLocationNV_IgnoreBool = (char)0; + Mock.vkCmdSetCoverageToColorLocationNV_CallbackBool = (char)1; + Mock.vkCmdSetCoverageToColorLocationNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetCoverageToColorLocationNV_Stub(CMOCK_vkCmdSetCoverageToColorLocationNV_CALLBACK Callback) +{ + Mock.vkCmdSetCoverageToColorLocationNV_IgnoreBool = (char)0; + Mock.vkCmdSetCoverageToColorLocationNV_CallbackBool = (char)0; + Mock.vkCmdSetCoverageToColorLocationNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetCoverageToColorLocationNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetCoverageToColorLocationNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoverageToColorLocationNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetCoverageToColorLocationNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetCoverageToColorLocationNV_CMockIgnoreArg_coverageToColorLocation(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetCoverageToColorLocationNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoverageToColorLocationNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetCoverageToColorLocationNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_coverageToColorLocation = 1; +} + +void vkCmdSetCoverageModulationModeNV(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetCoverageModulationModeNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetCoverageModulationModeNV); + cmock_call_instance = (CMOCK_vkCmdSetCoverageModulationModeNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetCoverageModulationModeNV_CallInstance); + Mock.vkCmdSetCoverageModulationModeNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetCoverageModulationModeNV_CallInstance); + if (Mock.vkCmdSetCoverageModulationModeNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetCoverageModulationModeNV_CallbackBool && + Mock.vkCmdSetCoverageModulationModeNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetCoverageModulationModeNV_CallbackFunctionPointer(commandBuffer, coverageModulationMode, Mock.vkCmdSetCoverageModulationModeNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetCoverageModulationModeNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_coverageModulationMode) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetCoverageModulationModeNV,CMockString_coverageModulationMode); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_coverageModulationMode), (void*)(&coverageModulationMode), sizeof(VkCoverageModulationModeNV), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetCoverageModulationModeNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetCoverageModulationModeNV_CallbackFunctionPointer(commandBuffer, coverageModulationMode, Mock.vkCmdSetCoverageModulationModeNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetCoverageModulationModeNV(CMOCK_vkCmdSetCoverageModulationModeNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode); +void CMockExpectParameters_vkCmdSetCoverageModulationModeNV(CMOCK_vkCmdSetCoverageModulationModeNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_coverageModulationMode), (void*)(&coverageModulationMode), + sizeof(VkCoverageModulationModeNV[sizeof(coverageModulationMode) == sizeof(VkCoverageModulationModeNV) ? 1 : -1])); /* add VkCoverageModulationModeNV to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_coverageModulationMode = 0; +} + +void vkCmdSetCoverageModulationModeNV_CMockIgnore(void) +{ + Mock.vkCmdSetCoverageModulationModeNV_IgnoreBool = (char)1; +} + +void vkCmdSetCoverageModulationModeNV_CMockStopIgnore(void) +{ + Mock.vkCmdSetCoverageModulationModeNV_IgnoreBool = (char)0; +} + +void vkCmdSetCoverageModulationModeNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetCoverageModulationModeNV_CALL_INSTANCE)); + CMOCK_vkCmdSetCoverageModulationModeNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoverageModulationModeNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetCoverageModulationModeNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetCoverageModulationModeNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetCoverageModulationModeNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetCoverageModulationModeNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetCoverageModulationModeNV_CALL_INSTANCE)); + CMOCK_vkCmdSetCoverageModulationModeNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoverageModulationModeNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetCoverageModulationModeNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetCoverageModulationModeNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetCoverageModulationModeNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetCoverageModulationModeNV(cmock_call_instance, commandBuffer, coverageModulationMode); +} + +void vkCmdSetCoverageModulationModeNV_AddCallback(CMOCK_vkCmdSetCoverageModulationModeNV_CALLBACK Callback) +{ + Mock.vkCmdSetCoverageModulationModeNV_IgnoreBool = (char)0; + Mock.vkCmdSetCoverageModulationModeNV_CallbackBool = (char)1; + Mock.vkCmdSetCoverageModulationModeNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetCoverageModulationModeNV_Stub(CMOCK_vkCmdSetCoverageModulationModeNV_CALLBACK Callback) +{ + Mock.vkCmdSetCoverageModulationModeNV_IgnoreBool = (char)0; + Mock.vkCmdSetCoverageModulationModeNV_CallbackBool = (char)0; + Mock.vkCmdSetCoverageModulationModeNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetCoverageModulationModeNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetCoverageModulationModeNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoverageModulationModeNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetCoverageModulationModeNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetCoverageModulationModeNV_CMockIgnoreArg_coverageModulationMode(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetCoverageModulationModeNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoverageModulationModeNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetCoverageModulationModeNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_coverageModulationMode = 1; +} + +void vkCmdSetCoverageModulationTableEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetCoverageModulationTableEnableNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetCoverageModulationTableEnableNV); + cmock_call_instance = (CMOCK_vkCmdSetCoverageModulationTableEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetCoverageModulationTableEnableNV_CallInstance); + Mock.vkCmdSetCoverageModulationTableEnableNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetCoverageModulationTableEnableNV_CallInstance); + if (Mock.vkCmdSetCoverageModulationTableEnableNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetCoverageModulationTableEnableNV_CallbackBool && + Mock.vkCmdSetCoverageModulationTableEnableNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetCoverageModulationTableEnableNV_CallbackFunctionPointer(commandBuffer, coverageModulationTableEnable, Mock.vkCmdSetCoverageModulationTableEnableNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetCoverageModulationTableEnableNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_coverageModulationTableEnable) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetCoverageModulationTableEnableNV,CMockString_coverageModulationTableEnable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_coverageModulationTableEnable), (void*)(&coverageModulationTableEnable), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetCoverageModulationTableEnableNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetCoverageModulationTableEnableNV_CallbackFunctionPointer(commandBuffer, coverageModulationTableEnable, Mock.vkCmdSetCoverageModulationTableEnableNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetCoverageModulationTableEnableNV(CMOCK_vkCmdSetCoverageModulationTableEnableNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable); +void CMockExpectParameters_vkCmdSetCoverageModulationTableEnableNV(CMOCK_vkCmdSetCoverageModulationTableEnableNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_coverageModulationTableEnable), (void*)(&coverageModulationTableEnable), + sizeof(VkBool32[sizeof(coverageModulationTableEnable) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_coverageModulationTableEnable = 0; +} + +void vkCmdSetCoverageModulationTableEnableNV_CMockIgnore(void) +{ + Mock.vkCmdSetCoverageModulationTableEnableNV_IgnoreBool = (char)1; +} + +void vkCmdSetCoverageModulationTableEnableNV_CMockStopIgnore(void) +{ + Mock.vkCmdSetCoverageModulationTableEnableNV_IgnoreBool = (char)0; +} + +void vkCmdSetCoverageModulationTableEnableNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetCoverageModulationTableEnableNV_CALL_INSTANCE)); + CMOCK_vkCmdSetCoverageModulationTableEnableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoverageModulationTableEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetCoverageModulationTableEnableNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetCoverageModulationTableEnableNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetCoverageModulationTableEnableNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetCoverageModulationTableEnableNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetCoverageModulationTableEnableNV_CALL_INSTANCE)); + CMOCK_vkCmdSetCoverageModulationTableEnableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoverageModulationTableEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetCoverageModulationTableEnableNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetCoverageModulationTableEnableNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetCoverageModulationTableEnableNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetCoverageModulationTableEnableNV(cmock_call_instance, commandBuffer, coverageModulationTableEnable); +} + +void vkCmdSetCoverageModulationTableEnableNV_AddCallback(CMOCK_vkCmdSetCoverageModulationTableEnableNV_CALLBACK Callback) +{ + Mock.vkCmdSetCoverageModulationTableEnableNV_IgnoreBool = (char)0; + Mock.vkCmdSetCoverageModulationTableEnableNV_CallbackBool = (char)1; + Mock.vkCmdSetCoverageModulationTableEnableNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetCoverageModulationTableEnableNV_Stub(CMOCK_vkCmdSetCoverageModulationTableEnableNV_CALLBACK Callback) +{ + Mock.vkCmdSetCoverageModulationTableEnableNV_IgnoreBool = (char)0; + Mock.vkCmdSetCoverageModulationTableEnableNV_CallbackBool = (char)0; + Mock.vkCmdSetCoverageModulationTableEnableNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetCoverageModulationTableEnableNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetCoverageModulationTableEnableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoverageModulationTableEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetCoverageModulationTableEnableNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetCoverageModulationTableEnableNV_CMockIgnoreArg_coverageModulationTableEnable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetCoverageModulationTableEnableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoverageModulationTableEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetCoverageModulationTableEnableNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_coverageModulationTableEnable = 1; +} + +void vkCmdSetCoverageModulationTableNV(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetCoverageModulationTableNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetCoverageModulationTableNV); + cmock_call_instance = (CMOCK_vkCmdSetCoverageModulationTableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetCoverageModulationTableNV_CallInstance); + Mock.vkCmdSetCoverageModulationTableNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetCoverageModulationTableNV_CallInstance); + if (Mock.vkCmdSetCoverageModulationTableNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetCoverageModulationTableNV_CallbackBool && + Mock.vkCmdSetCoverageModulationTableNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetCoverageModulationTableNV_CallbackFunctionPointer(commandBuffer, coverageModulationTableCount, pCoverageModulationTable, Mock.vkCmdSetCoverageModulationTableNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetCoverageModulationTableNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_coverageModulationTableCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetCoverageModulationTableNV,CMockString_coverageModulationTableCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_coverageModulationTableCount, coverageModulationTableCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCoverageModulationTable) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetCoverageModulationTableNV,CMockString_pCoverageModulationTable); + if (cmock_call_instance->Expected_pCoverageModulationTable == NULL) + { UNITY_TEST_ASSERT_NULL(pCoverageModulationTable, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(cmock_call_instance->Expected_pCoverageModulationTable, pCoverageModulationTable, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkCmdSetCoverageModulationTableNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetCoverageModulationTableNV_CallbackFunctionPointer(commandBuffer, coverageModulationTableCount, pCoverageModulationTable, Mock.vkCmdSetCoverageModulationTableNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetCoverageModulationTableNV(CMOCK_vkCmdSetCoverageModulationTableNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable); +void CMockExpectParameters_vkCmdSetCoverageModulationTableNV(CMOCK_vkCmdSetCoverageModulationTableNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_coverageModulationTableCount = coverageModulationTableCount; + cmock_call_instance->IgnoreArg_coverageModulationTableCount = 0; + cmock_call_instance->Expected_pCoverageModulationTable = pCoverageModulationTable; + cmock_call_instance->IgnoreArg_pCoverageModulationTable = 0; +} + +void vkCmdSetCoverageModulationTableNV_CMockIgnore(void) +{ + Mock.vkCmdSetCoverageModulationTableNV_IgnoreBool = (char)1; +} + +void vkCmdSetCoverageModulationTableNV_CMockStopIgnore(void) +{ + Mock.vkCmdSetCoverageModulationTableNV_IgnoreBool = (char)0; +} + +void vkCmdSetCoverageModulationTableNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetCoverageModulationTableNV_CALL_INSTANCE)); + CMOCK_vkCmdSetCoverageModulationTableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoverageModulationTableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetCoverageModulationTableNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetCoverageModulationTableNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetCoverageModulationTableNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetCoverageModulationTableNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetCoverageModulationTableNV_CALL_INSTANCE)); + CMOCK_vkCmdSetCoverageModulationTableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoverageModulationTableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetCoverageModulationTableNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetCoverageModulationTableNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetCoverageModulationTableNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetCoverageModulationTableNV(cmock_call_instance, commandBuffer, coverageModulationTableCount, pCoverageModulationTable); +} + +void vkCmdSetCoverageModulationTableNV_AddCallback(CMOCK_vkCmdSetCoverageModulationTableNV_CALLBACK Callback) +{ + Mock.vkCmdSetCoverageModulationTableNV_IgnoreBool = (char)0; + Mock.vkCmdSetCoverageModulationTableNV_CallbackBool = (char)1; + Mock.vkCmdSetCoverageModulationTableNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetCoverageModulationTableNV_Stub(CMOCK_vkCmdSetCoverageModulationTableNV_CALLBACK Callback) +{ + Mock.vkCmdSetCoverageModulationTableNV_IgnoreBool = (char)0; + Mock.vkCmdSetCoverageModulationTableNV_CallbackBool = (char)0; + Mock.vkCmdSetCoverageModulationTableNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetCoverageModulationTableNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetCoverageModulationTableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoverageModulationTableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetCoverageModulationTableNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetCoverageModulationTableNV_CMockIgnoreArg_coverageModulationTableCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetCoverageModulationTableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoverageModulationTableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetCoverageModulationTableNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_coverageModulationTableCount = 1; +} + +void vkCmdSetCoverageModulationTableNV_CMockIgnoreArg_pCoverageModulationTable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetCoverageModulationTableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoverageModulationTableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetCoverageModulationTableNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCoverageModulationTable = 1; +} + +void vkCmdSetShadingRateImageEnableNV(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetShadingRateImageEnableNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetShadingRateImageEnableNV); + cmock_call_instance = (CMOCK_vkCmdSetShadingRateImageEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetShadingRateImageEnableNV_CallInstance); + Mock.vkCmdSetShadingRateImageEnableNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetShadingRateImageEnableNV_CallInstance); + if (Mock.vkCmdSetShadingRateImageEnableNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetShadingRateImageEnableNV_CallbackBool && + Mock.vkCmdSetShadingRateImageEnableNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetShadingRateImageEnableNV_CallbackFunctionPointer(commandBuffer, shadingRateImageEnable, Mock.vkCmdSetShadingRateImageEnableNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetShadingRateImageEnableNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_shadingRateImageEnable) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetShadingRateImageEnableNV,CMockString_shadingRateImageEnable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_shadingRateImageEnable), (void*)(&shadingRateImageEnable), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetShadingRateImageEnableNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetShadingRateImageEnableNV_CallbackFunctionPointer(commandBuffer, shadingRateImageEnable, Mock.vkCmdSetShadingRateImageEnableNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetShadingRateImageEnableNV(CMOCK_vkCmdSetShadingRateImageEnableNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable); +void CMockExpectParameters_vkCmdSetShadingRateImageEnableNV(CMOCK_vkCmdSetShadingRateImageEnableNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_shadingRateImageEnable), (void*)(&shadingRateImageEnable), + sizeof(VkBool32[sizeof(shadingRateImageEnable) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_shadingRateImageEnable = 0; +} + +void vkCmdSetShadingRateImageEnableNV_CMockIgnore(void) +{ + Mock.vkCmdSetShadingRateImageEnableNV_IgnoreBool = (char)1; +} + +void vkCmdSetShadingRateImageEnableNV_CMockStopIgnore(void) +{ + Mock.vkCmdSetShadingRateImageEnableNV_IgnoreBool = (char)0; +} + +void vkCmdSetShadingRateImageEnableNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetShadingRateImageEnableNV_CALL_INSTANCE)); + CMOCK_vkCmdSetShadingRateImageEnableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetShadingRateImageEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetShadingRateImageEnableNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetShadingRateImageEnableNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetShadingRateImageEnableNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetShadingRateImageEnableNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetShadingRateImageEnableNV_CALL_INSTANCE)); + CMOCK_vkCmdSetShadingRateImageEnableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetShadingRateImageEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetShadingRateImageEnableNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetShadingRateImageEnableNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetShadingRateImageEnableNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetShadingRateImageEnableNV(cmock_call_instance, commandBuffer, shadingRateImageEnable); +} + +void vkCmdSetShadingRateImageEnableNV_AddCallback(CMOCK_vkCmdSetShadingRateImageEnableNV_CALLBACK Callback) +{ + Mock.vkCmdSetShadingRateImageEnableNV_IgnoreBool = (char)0; + Mock.vkCmdSetShadingRateImageEnableNV_CallbackBool = (char)1; + Mock.vkCmdSetShadingRateImageEnableNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetShadingRateImageEnableNV_Stub(CMOCK_vkCmdSetShadingRateImageEnableNV_CALLBACK Callback) +{ + Mock.vkCmdSetShadingRateImageEnableNV_IgnoreBool = (char)0; + Mock.vkCmdSetShadingRateImageEnableNV_CallbackBool = (char)0; + Mock.vkCmdSetShadingRateImageEnableNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetShadingRateImageEnableNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetShadingRateImageEnableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetShadingRateImageEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetShadingRateImageEnableNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetShadingRateImageEnableNV_CMockIgnoreArg_shadingRateImageEnable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetShadingRateImageEnableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetShadingRateImageEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetShadingRateImageEnableNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_shadingRateImageEnable = 1; +} + +void vkCmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetRepresentativeFragmentTestEnableNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetRepresentativeFragmentTestEnableNV); + cmock_call_instance = (CMOCK_vkCmdSetRepresentativeFragmentTestEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetRepresentativeFragmentTestEnableNV_CallInstance); + Mock.vkCmdSetRepresentativeFragmentTestEnableNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetRepresentativeFragmentTestEnableNV_CallInstance); + if (Mock.vkCmdSetRepresentativeFragmentTestEnableNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetRepresentativeFragmentTestEnableNV_CallbackBool && + Mock.vkCmdSetRepresentativeFragmentTestEnableNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetRepresentativeFragmentTestEnableNV_CallbackFunctionPointer(commandBuffer, representativeFragmentTestEnable, Mock.vkCmdSetRepresentativeFragmentTestEnableNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetRepresentativeFragmentTestEnableNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_representativeFragmentTestEnable) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetRepresentativeFragmentTestEnableNV,CMockString_representativeFragmentTestEnable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_representativeFragmentTestEnable), (void*)(&representativeFragmentTestEnable), sizeof(VkBool32), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetRepresentativeFragmentTestEnableNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetRepresentativeFragmentTestEnableNV_CallbackFunctionPointer(commandBuffer, representativeFragmentTestEnable, Mock.vkCmdSetRepresentativeFragmentTestEnableNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetRepresentativeFragmentTestEnableNV(CMOCK_vkCmdSetRepresentativeFragmentTestEnableNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable); +void CMockExpectParameters_vkCmdSetRepresentativeFragmentTestEnableNV(CMOCK_vkCmdSetRepresentativeFragmentTestEnableNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_representativeFragmentTestEnable), (void*)(&representativeFragmentTestEnable), + sizeof(VkBool32[sizeof(representativeFragmentTestEnable) == sizeof(VkBool32) ? 1 : -1])); /* add VkBool32 to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_representativeFragmentTestEnable = 0; +} + +void vkCmdSetRepresentativeFragmentTestEnableNV_CMockIgnore(void) +{ + Mock.vkCmdSetRepresentativeFragmentTestEnableNV_IgnoreBool = (char)1; +} + +void vkCmdSetRepresentativeFragmentTestEnableNV_CMockStopIgnore(void) +{ + Mock.vkCmdSetRepresentativeFragmentTestEnableNV_IgnoreBool = (char)0; +} + +void vkCmdSetRepresentativeFragmentTestEnableNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetRepresentativeFragmentTestEnableNV_CALL_INSTANCE)); + CMOCK_vkCmdSetRepresentativeFragmentTestEnableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetRepresentativeFragmentTestEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetRepresentativeFragmentTestEnableNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetRepresentativeFragmentTestEnableNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetRepresentativeFragmentTestEnableNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetRepresentativeFragmentTestEnableNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetRepresentativeFragmentTestEnableNV_CALL_INSTANCE)); + CMOCK_vkCmdSetRepresentativeFragmentTestEnableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetRepresentativeFragmentTestEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetRepresentativeFragmentTestEnableNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetRepresentativeFragmentTestEnableNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetRepresentativeFragmentTestEnableNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetRepresentativeFragmentTestEnableNV(cmock_call_instance, commandBuffer, representativeFragmentTestEnable); +} + +void vkCmdSetRepresentativeFragmentTestEnableNV_AddCallback(CMOCK_vkCmdSetRepresentativeFragmentTestEnableNV_CALLBACK Callback) +{ + Mock.vkCmdSetRepresentativeFragmentTestEnableNV_IgnoreBool = (char)0; + Mock.vkCmdSetRepresentativeFragmentTestEnableNV_CallbackBool = (char)1; + Mock.vkCmdSetRepresentativeFragmentTestEnableNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetRepresentativeFragmentTestEnableNV_Stub(CMOCK_vkCmdSetRepresentativeFragmentTestEnableNV_CALLBACK Callback) +{ + Mock.vkCmdSetRepresentativeFragmentTestEnableNV_IgnoreBool = (char)0; + Mock.vkCmdSetRepresentativeFragmentTestEnableNV_CallbackBool = (char)0; + Mock.vkCmdSetRepresentativeFragmentTestEnableNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetRepresentativeFragmentTestEnableNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetRepresentativeFragmentTestEnableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetRepresentativeFragmentTestEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetRepresentativeFragmentTestEnableNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetRepresentativeFragmentTestEnableNV_CMockIgnoreArg_representativeFragmentTestEnable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetRepresentativeFragmentTestEnableNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetRepresentativeFragmentTestEnableNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetRepresentativeFragmentTestEnableNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_representativeFragmentTestEnable = 1; +} + +void vkCmdSetCoverageReductionModeNV(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetCoverageReductionModeNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetCoverageReductionModeNV); + cmock_call_instance = (CMOCK_vkCmdSetCoverageReductionModeNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetCoverageReductionModeNV_CallInstance); + Mock.vkCmdSetCoverageReductionModeNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetCoverageReductionModeNV_CallInstance); + if (Mock.vkCmdSetCoverageReductionModeNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetCoverageReductionModeNV_CallbackBool && + Mock.vkCmdSetCoverageReductionModeNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetCoverageReductionModeNV_CallbackFunctionPointer(commandBuffer, coverageReductionMode, Mock.vkCmdSetCoverageReductionModeNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetCoverageReductionModeNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_coverageReductionMode) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetCoverageReductionModeNV,CMockString_coverageReductionMode); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_coverageReductionMode), (void*)(&coverageReductionMode), sizeof(VkCoverageReductionModeNV), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetCoverageReductionModeNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetCoverageReductionModeNV_CallbackFunctionPointer(commandBuffer, coverageReductionMode, Mock.vkCmdSetCoverageReductionModeNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetCoverageReductionModeNV(CMOCK_vkCmdSetCoverageReductionModeNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode); +void CMockExpectParameters_vkCmdSetCoverageReductionModeNV(CMOCK_vkCmdSetCoverageReductionModeNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_coverageReductionMode), (void*)(&coverageReductionMode), + sizeof(VkCoverageReductionModeNV[sizeof(coverageReductionMode) == sizeof(VkCoverageReductionModeNV) ? 1 : -1])); /* add VkCoverageReductionModeNV to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_coverageReductionMode = 0; +} + +void vkCmdSetCoverageReductionModeNV_CMockIgnore(void) +{ + Mock.vkCmdSetCoverageReductionModeNV_IgnoreBool = (char)1; +} + +void vkCmdSetCoverageReductionModeNV_CMockStopIgnore(void) +{ + Mock.vkCmdSetCoverageReductionModeNV_IgnoreBool = (char)0; +} + +void vkCmdSetCoverageReductionModeNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetCoverageReductionModeNV_CALL_INSTANCE)); + CMOCK_vkCmdSetCoverageReductionModeNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoverageReductionModeNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetCoverageReductionModeNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetCoverageReductionModeNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetCoverageReductionModeNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetCoverageReductionModeNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetCoverageReductionModeNV_CALL_INSTANCE)); + CMOCK_vkCmdSetCoverageReductionModeNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoverageReductionModeNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetCoverageReductionModeNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetCoverageReductionModeNV_CallInstance, cmock_guts_index); + Mock.vkCmdSetCoverageReductionModeNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetCoverageReductionModeNV(cmock_call_instance, commandBuffer, coverageReductionMode); +} + +void vkCmdSetCoverageReductionModeNV_AddCallback(CMOCK_vkCmdSetCoverageReductionModeNV_CALLBACK Callback) +{ + Mock.vkCmdSetCoverageReductionModeNV_IgnoreBool = (char)0; + Mock.vkCmdSetCoverageReductionModeNV_CallbackBool = (char)1; + Mock.vkCmdSetCoverageReductionModeNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetCoverageReductionModeNV_Stub(CMOCK_vkCmdSetCoverageReductionModeNV_CALLBACK Callback) +{ + Mock.vkCmdSetCoverageReductionModeNV_IgnoreBool = (char)0; + Mock.vkCmdSetCoverageReductionModeNV_CallbackBool = (char)0; + Mock.vkCmdSetCoverageReductionModeNV_CallbackFunctionPointer = Callback; +} + +void vkCmdSetCoverageReductionModeNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetCoverageReductionModeNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoverageReductionModeNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetCoverageReductionModeNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetCoverageReductionModeNV_CMockIgnoreArg_coverageReductionMode(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetCoverageReductionModeNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetCoverageReductionModeNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetCoverageReductionModeNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_coverageReductionMode = 1; +} + +void vkGetShaderModuleIdentifierEXT(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetShaderModuleIdentifierEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetShaderModuleIdentifierEXT); + cmock_call_instance = (CMOCK_vkGetShaderModuleIdentifierEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetShaderModuleIdentifierEXT_CallInstance); + Mock.vkGetShaderModuleIdentifierEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetShaderModuleIdentifierEXT_CallInstance); + if (Mock.vkGetShaderModuleIdentifierEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetShaderModuleIdentifierEXT_CallbackBool && + Mock.vkGetShaderModuleIdentifierEXT_CallbackFunctionPointer != NULL) + { + Mock.vkGetShaderModuleIdentifierEXT_CallbackFunctionPointer(device, shaderModule, pIdentifier, Mock.vkGetShaderModuleIdentifierEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetShaderModuleIdentifierEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_shaderModule) + { + UNITY_SET_DETAILS(CMockString_vkGetShaderModuleIdentifierEXT,CMockString_shaderModule); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_shaderModule), (void*)(&shaderModule), sizeof(VkShaderModule), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pIdentifier) + { + UNITY_SET_DETAILS(CMockString_vkGetShaderModuleIdentifierEXT,CMockString_pIdentifier); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pIdentifier), (void*)(pIdentifier), sizeof(VkShaderModuleIdentifierEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetShaderModuleIdentifierEXT_CallbackFunctionPointer != NULL) + { + Mock.vkGetShaderModuleIdentifierEXT_CallbackFunctionPointer(device, shaderModule, pIdentifier, Mock.vkGetShaderModuleIdentifierEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pIdentifier_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pIdentifier, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pIdentifier, (const void*)cmock_call_instance->ReturnThruPtr_pIdentifier_Val, + cmock_call_instance->ReturnThruPtr_pIdentifier_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetShaderModuleIdentifierEXT(CMOCK_vkGetShaderModuleIdentifierEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier); +void CMockExpectParameters_vkGetShaderModuleIdentifierEXT(CMOCK_vkGetShaderModuleIdentifierEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_shaderModule), (void*)(&shaderModule), + sizeof(VkShaderModule[sizeof(shaderModule) == sizeof(VkShaderModule) ? 1 : -1])); /* add VkShaderModule to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_shaderModule = 0; + cmock_call_instance->Expected_pIdentifier = pIdentifier; + cmock_call_instance->IgnoreArg_pIdentifier = 0; + cmock_call_instance->ReturnThruPtr_pIdentifier_Used = 0; +} + +void vkGetShaderModuleIdentifierEXT_CMockIgnore(void) +{ + Mock.vkGetShaderModuleIdentifierEXT_IgnoreBool = (char)1; +} + +void vkGetShaderModuleIdentifierEXT_CMockStopIgnore(void) +{ + Mock.vkGetShaderModuleIdentifierEXT_IgnoreBool = (char)0; +} + +void vkGetShaderModuleIdentifierEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetShaderModuleIdentifierEXT_CALL_INSTANCE)); + CMOCK_vkGetShaderModuleIdentifierEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderModuleIdentifierEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetShaderModuleIdentifierEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetShaderModuleIdentifierEXT_CallInstance, cmock_guts_index); + Mock.vkGetShaderModuleIdentifierEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetShaderModuleIdentifierEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetShaderModuleIdentifierEXT_CALL_INSTANCE)); + CMOCK_vkGetShaderModuleIdentifierEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderModuleIdentifierEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetShaderModuleIdentifierEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetShaderModuleIdentifierEXT_CallInstance, cmock_guts_index); + Mock.vkGetShaderModuleIdentifierEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetShaderModuleIdentifierEXT(cmock_call_instance, device, shaderModule, pIdentifier); +} + +void vkGetShaderModuleIdentifierEXT_AddCallback(CMOCK_vkGetShaderModuleIdentifierEXT_CALLBACK Callback) +{ + Mock.vkGetShaderModuleIdentifierEXT_IgnoreBool = (char)0; + Mock.vkGetShaderModuleIdentifierEXT_CallbackBool = (char)1; + Mock.vkGetShaderModuleIdentifierEXT_CallbackFunctionPointer = Callback; +} + +void vkGetShaderModuleIdentifierEXT_Stub(CMOCK_vkGetShaderModuleIdentifierEXT_CALLBACK Callback) +{ + Mock.vkGetShaderModuleIdentifierEXT_IgnoreBool = (char)0; + Mock.vkGetShaderModuleIdentifierEXT_CallbackBool = (char)0; + Mock.vkGetShaderModuleIdentifierEXT_CallbackFunctionPointer = Callback; +} + +void vkGetShaderModuleIdentifierEXT_CMockReturnMemThruPtr_pIdentifier(UNITY_LINE_TYPE cmock_line, VkShaderModuleIdentifierEXT const* pIdentifier, size_t cmock_size) +{ + CMOCK_vkGetShaderModuleIdentifierEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderModuleIdentifierEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetShaderModuleIdentifierEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pIdentifier_Used = 1; + cmock_call_instance->ReturnThruPtr_pIdentifier_Val = pIdentifier; + cmock_call_instance->ReturnThruPtr_pIdentifier_Size = cmock_size; +} + +void vkGetShaderModuleIdentifierEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetShaderModuleIdentifierEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderModuleIdentifierEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetShaderModuleIdentifierEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetShaderModuleIdentifierEXT_CMockIgnoreArg_shaderModule(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetShaderModuleIdentifierEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderModuleIdentifierEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetShaderModuleIdentifierEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_shaderModule = 1; +} + +void vkGetShaderModuleIdentifierEXT_CMockIgnoreArg_pIdentifier(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetShaderModuleIdentifierEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderModuleIdentifierEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetShaderModuleIdentifierEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pIdentifier = 1; +} + +void vkGetShaderModuleCreateInfoIdentifierEXT(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetShaderModuleCreateInfoIdentifierEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetShaderModuleCreateInfoIdentifierEXT); + cmock_call_instance = (CMOCK_vkGetShaderModuleCreateInfoIdentifierEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetShaderModuleCreateInfoIdentifierEXT_CallInstance); + Mock.vkGetShaderModuleCreateInfoIdentifierEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetShaderModuleCreateInfoIdentifierEXT_CallInstance); + if (Mock.vkGetShaderModuleCreateInfoIdentifierEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetShaderModuleCreateInfoIdentifierEXT_CallbackBool && + Mock.vkGetShaderModuleCreateInfoIdentifierEXT_CallbackFunctionPointer != NULL) + { + Mock.vkGetShaderModuleCreateInfoIdentifierEXT_CallbackFunctionPointer(device, pCreateInfo, pIdentifier, Mock.vkGetShaderModuleCreateInfoIdentifierEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetShaderModuleCreateInfoIdentifierEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetShaderModuleCreateInfoIdentifierEXT,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkShaderModuleCreateInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pIdentifier) + { + UNITY_SET_DETAILS(CMockString_vkGetShaderModuleCreateInfoIdentifierEXT,CMockString_pIdentifier); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pIdentifier), (void*)(pIdentifier), sizeof(VkShaderModuleIdentifierEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetShaderModuleCreateInfoIdentifierEXT_CallbackFunctionPointer != NULL) + { + Mock.vkGetShaderModuleCreateInfoIdentifierEXT_CallbackFunctionPointer(device, pCreateInfo, pIdentifier, Mock.vkGetShaderModuleCreateInfoIdentifierEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pIdentifier_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pIdentifier, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pIdentifier, (const void*)cmock_call_instance->ReturnThruPtr_pIdentifier_Val, + cmock_call_instance->ReturnThruPtr_pIdentifier_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetShaderModuleCreateInfoIdentifierEXT(CMOCK_vkGetShaderModuleCreateInfoIdentifierEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier); +void CMockExpectParameters_vkGetShaderModuleCreateInfoIdentifierEXT(CMOCK_vkGetShaderModuleCreateInfoIdentifierEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pIdentifier = pIdentifier; + cmock_call_instance->IgnoreArg_pIdentifier = 0; + cmock_call_instance->ReturnThruPtr_pIdentifier_Used = 0; +} + +void vkGetShaderModuleCreateInfoIdentifierEXT_CMockIgnore(void) +{ + Mock.vkGetShaderModuleCreateInfoIdentifierEXT_IgnoreBool = (char)1; +} + +void vkGetShaderModuleCreateInfoIdentifierEXT_CMockStopIgnore(void) +{ + Mock.vkGetShaderModuleCreateInfoIdentifierEXT_IgnoreBool = (char)0; +} + +void vkGetShaderModuleCreateInfoIdentifierEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetShaderModuleCreateInfoIdentifierEXT_CALL_INSTANCE)); + CMOCK_vkGetShaderModuleCreateInfoIdentifierEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderModuleCreateInfoIdentifierEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetShaderModuleCreateInfoIdentifierEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetShaderModuleCreateInfoIdentifierEXT_CallInstance, cmock_guts_index); + Mock.vkGetShaderModuleCreateInfoIdentifierEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetShaderModuleCreateInfoIdentifierEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetShaderModuleCreateInfoIdentifierEXT_CALL_INSTANCE)); + CMOCK_vkGetShaderModuleCreateInfoIdentifierEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderModuleCreateInfoIdentifierEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetShaderModuleCreateInfoIdentifierEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetShaderModuleCreateInfoIdentifierEXT_CallInstance, cmock_guts_index); + Mock.vkGetShaderModuleCreateInfoIdentifierEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetShaderModuleCreateInfoIdentifierEXT(cmock_call_instance, device, pCreateInfo, pIdentifier); +} + +void vkGetShaderModuleCreateInfoIdentifierEXT_AddCallback(CMOCK_vkGetShaderModuleCreateInfoIdentifierEXT_CALLBACK Callback) +{ + Mock.vkGetShaderModuleCreateInfoIdentifierEXT_IgnoreBool = (char)0; + Mock.vkGetShaderModuleCreateInfoIdentifierEXT_CallbackBool = (char)1; + Mock.vkGetShaderModuleCreateInfoIdentifierEXT_CallbackFunctionPointer = Callback; +} + +void vkGetShaderModuleCreateInfoIdentifierEXT_Stub(CMOCK_vkGetShaderModuleCreateInfoIdentifierEXT_CALLBACK Callback) +{ + Mock.vkGetShaderModuleCreateInfoIdentifierEXT_IgnoreBool = (char)0; + Mock.vkGetShaderModuleCreateInfoIdentifierEXT_CallbackBool = (char)0; + Mock.vkGetShaderModuleCreateInfoIdentifierEXT_CallbackFunctionPointer = Callback; +} + +void vkGetShaderModuleCreateInfoIdentifierEXT_CMockReturnMemThruPtr_pIdentifier(UNITY_LINE_TYPE cmock_line, VkShaderModuleIdentifierEXT const* pIdentifier, size_t cmock_size) +{ + CMOCK_vkGetShaderModuleCreateInfoIdentifierEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderModuleCreateInfoIdentifierEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetShaderModuleCreateInfoIdentifierEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pIdentifier_Used = 1; + cmock_call_instance->ReturnThruPtr_pIdentifier_Val = pIdentifier; + cmock_call_instance->ReturnThruPtr_pIdentifier_Size = cmock_size; +} + +void vkGetShaderModuleCreateInfoIdentifierEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetShaderModuleCreateInfoIdentifierEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderModuleCreateInfoIdentifierEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetShaderModuleCreateInfoIdentifierEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetShaderModuleCreateInfoIdentifierEXT_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetShaderModuleCreateInfoIdentifierEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderModuleCreateInfoIdentifierEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetShaderModuleCreateInfoIdentifierEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkGetShaderModuleCreateInfoIdentifierEXT_CMockIgnoreArg_pIdentifier(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetShaderModuleCreateInfoIdentifierEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderModuleCreateInfoIdentifierEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetShaderModuleCreateInfoIdentifierEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pIdentifier = 1; +} + +VkResult vkGetPhysicalDeviceOpticalFlowImageFormatsNV(VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetPhysicalDeviceOpticalFlowImageFormatsNV); + cmock_call_instance = (CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallInstance); + Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallInstance); + if (Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_FinalReturn; + memcpy((void*)(&Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallbackBool && + Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallbackFunctionPointer(physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties, Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_physicalDevice) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceOpticalFlowImageFormatsNV,CMockString_physicalDevice); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), sizeof(VkPhysicalDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pOpticalFlowImageFormatInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceOpticalFlowImageFormatsNV,CMockString_pOpticalFlowImageFormatInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pOpticalFlowImageFormatInfo), (void*)(pOpticalFlowImageFormatInfo), sizeof(const VkOpticalFlowImageFormatInfoNV), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pFormatCount) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceOpticalFlowImageFormatsNV,CMockString_pFormatCount); + if (cmock_call_instance->Expected_pFormatCount == NULL) + { UNITY_TEST_ASSERT_NULL(pFormatCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pFormatCount, pFormatCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pImageFormatProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetPhysicalDeviceOpticalFlowImageFormatsNV,CMockString_pImageFormatProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pImageFormatProperties), (void*)(pImageFormatProperties), sizeof(VkOpticalFlowImageFormatPropertiesNV), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallbackFunctionPointer(physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties, Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pFormatCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pFormatCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pFormatCount, (const void*)cmock_call_instance->ReturnThruPtr_pFormatCount_Val, + cmock_call_instance->ReturnThruPtr_pFormatCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pImageFormatProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pImageFormatProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pImageFormatProperties, (const void*)cmock_call_instance->ReturnThruPtr_pImageFormatProperties_Val, + cmock_call_instance->ReturnThruPtr_pImageFormatProperties_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties); +void CMockExpectParameters_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALL_INSTANCE* cmock_call_instance, VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_physicalDevice), (void*)(&physicalDevice), + sizeof(VkPhysicalDevice[sizeof(physicalDevice) == sizeof(VkPhysicalDevice) ? 1 : -1])); /* add VkPhysicalDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_physicalDevice = 0; + cmock_call_instance->Expected_pOpticalFlowImageFormatInfo = pOpticalFlowImageFormatInfo; + cmock_call_instance->IgnoreArg_pOpticalFlowImageFormatInfo = 0; + cmock_call_instance->Expected_pFormatCount = pFormatCount; + cmock_call_instance->IgnoreArg_pFormatCount = 0; + cmock_call_instance->ReturnThruPtr_pFormatCount_Used = 0; + cmock_call_instance->Expected_pImageFormatProperties = pImageFormatProperties; + cmock_call_instance->IgnoreArg_pImageFormatProperties = 0; + cmock_call_instance->ReturnThruPtr_pImageFormatProperties_Used = 0; +} + +void vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_IgnoreBool = (char)1; +} + +void vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockStopIgnore(void) +{ + if(Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_IgnoreBool) + Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallInstance = CMock_Guts_MemNext(Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallInstance); + Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_IgnoreBool = (char)0; +} + +void vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALL_INSTANCE)); + CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallInstance = CMock_Guts_MemChain(Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallInstance, cmock_guts_index); + Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(cmock_call_instance, physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetPhysicalDeviceOpticalFlowImageFormatsNV_AddCallback(CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallbackBool = (char)1; + Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceOpticalFlowImageFormatsNV_Stub(CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALLBACK Callback) +{ + Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_IgnoreBool = (char)0; + Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallbackBool = (char)0; + Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallbackFunctionPointer = Callback; +} + +void vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockReturnMemThruPtr_pFormatCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pFormatCount, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pFormatCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pFormatCount_Val = pFormatCount; + cmock_call_instance->ReturnThruPtr_pFormatCount_Size = cmock_size; +} + +void vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockReturnMemThruPtr_pImageFormatProperties(UNITY_LINE_TYPE cmock_line, VkOpticalFlowImageFormatPropertiesNV const* pImageFormatProperties, size_t cmock_size) +{ + CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pImageFormatProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pImageFormatProperties_Val = pImageFormatProperties; + cmock_call_instance->ReturnThruPtr_pImageFormatProperties_Size = cmock_size; +} + +void vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_physicalDevice = 1; +} + +void vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockIgnoreArg_pOpticalFlowImageFormatInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pOpticalFlowImageFormatInfo = 1; +} + +void vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockIgnoreArg_pFormatCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pFormatCount = 1; +} + +void vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockIgnoreArg_pImageFormatProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pImageFormatProperties = 1; +} + +VkResult vkCreateOpticalFlowSessionNV(VkDevice device, const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkOpticalFlowSessionNV* pSession) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateOpticalFlowSessionNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateOpticalFlowSessionNV); + cmock_call_instance = (CMOCK_vkCreateOpticalFlowSessionNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateOpticalFlowSessionNV_CallInstance); + Mock.vkCreateOpticalFlowSessionNV_CallInstance = CMock_Guts_MemNext(Mock.vkCreateOpticalFlowSessionNV_CallInstance); + if (Mock.vkCreateOpticalFlowSessionNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateOpticalFlowSessionNV_FinalReturn; + memcpy((void*)(&Mock.vkCreateOpticalFlowSessionNV_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateOpticalFlowSessionNV_CallbackBool && + Mock.vkCreateOpticalFlowSessionNV_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateOpticalFlowSessionNV_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pSession, Mock.vkCreateOpticalFlowSessionNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateOpticalFlowSessionNV,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateOpticalFlowSessionNV,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkOpticalFlowSessionCreateInfoNV), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateOpticalFlowSessionNV,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pSession) + { + UNITY_SET_DETAILS(CMockString_vkCreateOpticalFlowSessionNV,CMockString_pSession); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSession), (void*)(pSession), sizeof(VkOpticalFlowSessionNV), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateOpticalFlowSessionNV_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateOpticalFlowSessionNV_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pSession, Mock.vkCreateOpticalFlowSessionNV_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pSession_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSession, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSession, (const void*)cmock_call_instance->ReturnThruPtr_pSession_Val, + cmock_call_instance->ReturnThruPtr_pSession_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateOpticalFlowSessionNV(CMOCK_vkCreateOpticalFlowSessionNV_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkOpticalFlowSessionNV* pSession); +void CMockExpectParameters_vkCreateOpticalFlowSessionNV(CMOCK_vkCreateOpticalFlowSessionNV_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkOpticalFlowSessionNV* pSession) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pSession = pSession; + cmock_call_instance->IgnoreArg_pSession = 0; + cmock_call_instance->ReturnThruPtr_pSession_Used = 0; +} + +void vkCreateOpticalFlowSessionNV_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateOpticalFlowSessionNV_CALL_INSTANCE)); + CMOCK_vkCreateOpticalFlowSessionNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateOpticalFlowSessionNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateOpticalFlowSessionNV_CallInstance = CMock_Guts_MemChain(Mock.vkCreateOpticalFlowSessionNV_CallInstance, cmock_guts_index); + Mock.vkCreateOpticalFlowSessionNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateOpticalFlowSessionNV_IgnoreBool = (char)1; +} + +void vkCreateOpticalFlowSessionNV_CMockStopIgnore(void) +{ + if(Mock.vkCreateOpticalFlowSessionNV_IgnoreBool) + Mock.vkCreateOpticalFlowSessionNV_CallInstance = CMock_Guts_MemNext(Mock.vkCreateOpticalFlowSessionNV_CallInstance); + Mock.vkCreateOpticalFlowSessionNV_IgnoreBool = (char)0; +} + +void vkCreateOpticalFlowSessionNV_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateOpticalFlowSessionNV_CALL_INSTANCE)); + CMOCK_vkCreateOpticalFlowSessionNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateOpticalFlowSessionNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateOpticalFlowSessionNV_CallInstance = CMock_Guts_MemChain(Mock.vkCreateOpticalFlowSessionNV_CallInstance, cmock_guts_index); + Mock.vkCreateOpticalFlowSessionNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateOpticalFlowSessionNV_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkOpticalFlowSessionNV* pSession, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateOpticalFlowSessionNV_CALL_INSTANCE)); + CMOCK_vkCreateOpticalFlowSessionNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateOpticalFlowSessionNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateOpticalFlowSessionNV_CallInstance = CMock_Guts_MemChain(Mock.vkCreateOpticalFlowSessionNV_CallInstance, cmock_guts_index); + Mock.vkCreateOpticalFlowSessionNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateOpticalFlowSessionNV(cmock_call_instance, device, pCreateInfo, pAllocator, pSession); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateOpticalFlowSessionNV_AddCallback(CMOCK_vkCreateOpticalFlowSessionNV_CALLBACK Callback) +{ + Mock.vkCreateOpticalFlowSessionNV_IgnoreBool = (char)0; + Mock.vkCreateOpticalFlowSessionNV_CallbackBool = (char)1; + Mock.vkCreateOpticalFlowSessionNV_CallbackFunctionPointer = Callback; +} + +void vkCreateOpticalFlowSessionNV_Stub(CMOCK_vkCreateOpticalFlowSessionNV_CALLBACK Callback) +{ + Mock.vkCreateOpticalFlowSessionNV_IgnoreBool = (char)0; + Mock.vkCreateOpticalFlowSessionNV_CallbackBool = (char)0; + Mock.vkCreateOpticalFlowSessionNV_CallbackFunctionPointer = Callback; +} + +void vkCreateOpticalFlowSessionNV_CMockReturnMemThruPtr_pSession(UNITY_LINE_TYPE cmock_line, VkOpticalFlowSessionNV const* pSession, size_t cmock_size) +{ + CMOCK_vkCreateOpticalFlowSessionNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateOpticalFlowSessionNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateOpticalFlowSessionNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSession_Used = 1; + cmock_call_instance->ReturnThruPtr_pSession_Val = pSession; + cmock_call_instance->ReturnThruPtr_pSession_Size = cmock_size; +} + +void vkCreateOpticalFlowSessionNV_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateOpticalFlowSessionNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateOpticalFlowSessionNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateOpticalFlowSessionNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateOpticalFlowSessionNV_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateOpticalFlowSessionNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateOpticalFlowSessionNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateOpticalFlowSessionNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateOpticalFlowSessionNV_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateOpticalFlowSessionNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateOpticalFlowSessionNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateOpticalFlowSessionNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateOpticalFlowSessionNV_CMockIgnoreArg_pSession(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateOpticalFlowSessionNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateOpticalFlowSessionNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateOpticalFlowSessionNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSession = 1; +} + +void vkDestroyOpticalFlowSessionNV(VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyOpticalFlowSessionNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyOpticalFlowSessionNV); + cmock_call_instance = (CMOCK_vkDestroyOpticalFlowSessionNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyOpticalFlowSessionNV_CallInstance); + Mock.vkDestroyOpticalFlowSessionNV_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyOpticalFlowSessionNV_CallInstance); + if (Mock.vkDestroyOpticalFlowSessionNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyOpticalFlowSessionNV_CallbackBool && + Mock.vkDestroyOpticalFlowSessionNV_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyOpticalFlowSessionNV_CallbackFunctionPointer(device, session, pAllocator, Mock.vkDestroyOpticalFlowSessionNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyOpticalFlowSessionNV,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_session) + { + UNITY_SET_DETAILS(CMockString_vkDestroyOpticalFlowSessionNV,CMockString_session); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_session), (void*)(&session), sizeof(VkOpticalFlowSessionNV), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyOpticalFlowSessionNV,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyOpticalFlowSessionNV_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyOpticalFlowSessionNV_CallbackFunctionPointer(device, session, pAllocator, Mock.vkDestroyOpticalFlowSessionNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyOpticalFlowSessionNV(CMOCK_vkDestroyOpticalFlowSessionNV_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyOpticalFlowSessionNV(CMOCK_vkDestroyOpticalFlowSessionNV_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_session), (void*)(&session), + sizeof(VkOpticalFlowSessionNV[sizeof(session) == sizeof(VkOpticalFlowSessionNV) ? 1 : -1])); /* add VkOpticalFlowSessionNV to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_session = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyOpticalFlowSessionNV_CMockIgnore(void) +{ + Mock.vkDestroyOpticalFlowSessionNV_IgnoreBool = (char)1; +} + +void vkDestroyOpticalFlowSessionNV_CMockStopIgnore(void) +{ + Mock.vkDestroyOpticalFlowSessionNV_IgnoreBool = (char)0; +} + +void vkDestroyOpticalFlowSessionNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyOpticalFlowSessionNV_CALL_INSTANCE)); + CMOCK_vkDestroyOpticalFlowSessionNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyOpticalFlowSessionNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyOpticalFlowSessionNV_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyOpticalFlowSessionNV_CallInstance, cmock_guts_index); + Mock.vkDestroyOpticalFlowSessionNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyOpticalFlowSessionNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyOpticalFlowSessionNV_CALL_INSTANCE)); + CMOCK_vkDestroyOpticalFlowSessionNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyOpticalFlowSessionNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyOpticalFlowSessionNV_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyOpticalFlowSessionNV_CallInstance, cmock_guts_index); + Mock.vkDestroyOpticalFlowSessionNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyOpticalFlowSessionNV(cmock_call_instance, device, session, pAllocator); +} + +void vkDestroyOpticalFlowSessionNV_AddCallback(CMOCK_vkDestroyOpticalFlowSessionNV_CALLBACK Callback) +{ + Mock.vkDestroyOpticalFlowSessionNV_IgnoreBool = (char)0; + Mock.vkDestroyOpticalFlowSessionNV_CallbackBool = (char)1; + Mock.vkDestroyOpticalFlowSessionNV_CallbackFunctionPointer = Callback; +} + +void vkDestroyOpticalFlowSessionNV_Stub(CMOCK_vkDestroyOpticalFlowSessionNV_CALLBACK Callback) +{ + Mock.vkDestroyOpticalFlowSessionNV_IgnoreBool = (char)0; + Mock.vkDestroyOpticalFlowSessionNV_CallbackBool = (char)0; + Mock.vkDestroyOpticalFlowSessionNV_CallbackFunctionPointer = Callback; +} + +void vkDestroyOpticalFlowSessionNV_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyOpticalFlowSessionNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyOpticalFlowSessionNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyOpticalFlowSessionNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyOpticalFlowSessionNV_CMockIgnoreArg_session(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyOpticalFlowSessionNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyOpticalFlowSessionNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyOpticalFlowSessionNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_session = 1; +} + +void vkDestroyOpticalFlowSessionNV_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyOpticalFlowSessionNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyOpticalFlowSessionNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyOpticalFlowSessionNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +VkResult vkBindOpticalFlowSessionImageNV(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkBindOpticalFlowSessionImageNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkBindOpticalFlowSessionImageNV); + cmock_call_instance = (CMOCK_vkBindOpticalFlowSessionImageNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkBindOpticalFlowSessionImageNV_CallInstance); + Mock.vkBindOpticalFlowSessionImageNV_CallInstance = CMock_Guts_MemNext(Mock.vkBindOpticalFlowSessionImageNV_CallInstance); + if (Mock.vkBindOpticalFlowSessionImageNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkBindOpticalFlowSessionImageNV_FinalReturn; + memcpy((void*)(&Mock.vkBindOpticalFlowSessionImageNV_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkBindOpticalFlowSessionImageNV_CallbackBool && + Mock.vkBindOpticalFlowSessionImageNV_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkBindOpticalFlowSessionImageNV_CallbackFunctionPointer(device, session, bindingPoint, view, layout, Mock.vkBindOpticalFlowSessionImageNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkBindOpticalFlowSessionImageNV,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_session) + { + UNITY_SET_DETAILS(CMockString_vkBindOpticalFlowSessionImageNV,CMockString_session); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_session), (void*)(&session), sizeof(VkOpticalFlowSessionNV), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_bindingPoint) + { + UNITY_SET_DETAILS(CMockString_vkBindOpticalFlowSessionImageNV,CMockString_bindingPoint); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_bindingPoint), (void*)(&bindingPoint), sizeof(VkOpticalFlowSessionBindingPointNV), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_view) + { + UNITY_SET_DETAILS(CMockString_vkBindOpticalFlowSessionImageNV,CMockString_view); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_view), (void*)(&view), sizeof(VkImageView), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_layout) + { + UNITY_SET_DETAILS(CMockString_vkBindOpticalFlowSessionImageNV,CMockString_layout); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_layout), (void*)(&layout), sizeof(VkImageLayout), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkBindOpticalFlowSessionImageNV_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkBindOpticalFlowSessionImageNV_CallbackFunctionPointer(device, session, bindingPoint, view, layout, Mock.vkBindOpticalFlowSessionImageNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkBindOpticalFlowSessionImageNV(CMOCK_vkBindOpticalFlowSessionImageNV_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout); +void CMockExpectParameters_vkBindOpticalFlowSessionImageNV(CMOCK_vkBindOpticalFlowSessionImageNV_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_session), (void*)(&session), + sizeof(VkOpticalFlowSessionNV[sizeof(session) == sizeof(VkOpticalFlowSessionNV) ? 1 : -1])); /* add VkOpticalFlowSessionNV to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_session = 0; + memcpy((void*)(&cmock_call_instance->Expected_bindingPoint), (void*)(&bindingPoint), + sizeof(VkOpticalFlowSessionBindingPointNV[sizeof(bindingPoint) == sizeof(VkOpticalFlowSessionBindingPointNV) ? 1 : -1])); /* add VkOpticalFlowSessionBindingPointNV to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_bindingPoint = 0; + memcpy((void*)(&cmock_call_instance->Expected_view), (void*)(&view), + sizeof(VkImageView[sizeof(view) == sizeof(VkImageView) ? 1 : -1])); /* add VkImageView to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_view = 0; + memcpy((void*)(&cmock_call_instance->Expected_layout), (void*)(&layout), + sizeof(VkImageLayout[sizeof(layout) == sizeof(VkImageLayout) ? 1 : -1])); /* add VkImageLayout to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_layout = 0; +} + +void vkBindOpticalFlowSessionImageNV_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBindOpticalFlowSessionImageNV_CALL_INSTANCE)); + CMOCK_vkBindOpticalFlowSessionImageNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindOpticalFlowSessionImageNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBindOpticalFlowSessionImageNV_CallInstance = CMock_Guts_MemChain(Mock.vkBindOpticalFlowSessionImageNV_CallInstance, cmock_guts_index); + Mock.vkBindOpticalFlowSessionImageNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkBindOpticalFlowSessionImageNV_IgnoreBool = (char)1; +} + +void vkBindOpticalFlowSessionImageNV_CMockStopIgnore(void) +{ + if(Mock.vkBindOpticalFlowSessionImageNV_IgnoreBool) + Mock.vkBindOpticalFlowSessionImageNV_CallInstance = CMock_Guts_MemNext(Mock.vkBindOpticalFlowSessionImageNV_CallInstance); + Mock.vkBindOpticalFlowSessionImageNV_IgnoreBool = (char)0; +} + +void vkBindOpticalFlowSessionImageNV_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBindOpticalFlowSessionImageNV_CALL_INSTANCE)); + CMOCK_vkBindOpticalFlowSessionImageNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindOpticalFlowSessionImageNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBindOpticalFlowSessionImageNV_CallInstance = CMock_Guts_MemChain(Mock.vkBindOpticalFlowSessionImageNV_CallInstance, cmock_guts_index); + Mock.vkBindOpticalFlowSessionImageNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkBindOpticalFlowSessionImageNV_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBindOpticalFlowSessionImageNV_CALL_INSTANCE)); + CMOCK_vkBindOpticalFlowSessionImageNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindOpticalFlowSessionImageNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBindOpticalFlowSessionImageNV_CallInstance = CMock_Guts_MemChain(Mock.vkBindOpticalFlowSessionImageNV_CallInstance, cmock_guts_index); + Mock.vkBindOpticalFlowSessionImageNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkBindOpticalFlowSessionImageNV(cmock_call_instance, device, session, bindingPoint, view, layout); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkBindOpticalFlowSessionImageNV_AddCallback(CMOCK_vkBindOpticalFlowSessionImageNV_CALLBACK Callback) +{ + Mock.vkBindOpticalFlowSessionImageNV_IgnoreBool = (char)0; + Mock.vkBindOpticalFlowSessionImageNV_CallbackBool = (char)1; + Mock.vkBindOpticalFlowSessionImageNV_CallbackFunctionPointer = Callback; +} + +void vkBindOpticalFlowSessionImageNV_Stub(CMOCK_vkBindOpticalFlowSessionImageNV_CALLBACK Callback) +{ + Mock.vkBindOpticalFlowSessionImageNV_IgnoreBool = (char)0; + Mock.vkBindOpticalFlowSessionImageNV_CallbackBool = (char)0; + Mock.vkBindOpticalFlowSessionImageNV_CallbackFunctionPointer = Callback; +} + +void vkBindOpticalFlowSessionImageNV_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindOpticalFlowSessionImageNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindOpticalFlowSessionImageNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindOpticalFlowSessionImageNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkBindOpticalFlowSessionImageNV_CMockIgnoreArg_session(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindOpticalFlowSessionImageNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindOpticalFlowSessionImageNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindOpticalFlowSessionImageNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_session = 1; +} + +void vkBindOpticalFlowSessionImageNV_CMockIgnoreArg_bindingPoint(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindOpticalFlowSessionImageNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindOpticalFlowSessionImageNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindOpticalFlowSessionImageNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_bindingPoint = 1; +} + +void vkBindOpticalFlowSessionImageNV_CMockIgnoreArg_view(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindOpticalFlowSessionImageNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindOpticalFlowSessionImageNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindOpticalFlowSessionImageNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_view = 1; +} + +void vkBindOpticalFlowSessionImageNV_CMockIgnoreArg_layout(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBindOpticalFlowSessionImageNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBindOpticalFlowSessionImageNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBindOpticalFlowSessionImageNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_layout = 1; +} + +void vkCmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdOpticalFlowExecuteNV_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdOpticalFlowExecuteNV); + cmock_call_instance = (CMOCK_vkCmdOpticalFlowExecuteNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdOpticalFlowExecuteNV_CallInstance); + Mock.vkCmdOpticalFlowExecuteNV_CallInstance = CMock_Guts_MemNext(Mock.vkCmdOpticalFlowExecuteNV_CallInstance); + if (Mock.vkCmdOpticalFlowExecuteNV_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdOpticalFlowExecuteNV_CallbackBool && + Mock.vkCmdOpticalFlowExecuteNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdOpticalFlowExecuteNV_CallbackFunctionPointer(commandBuffer, session, pExecuteInfo, Mock.vkCmdOpticalFlowExecuteNV_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdOpticalFlowExecuteNV,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_session) + { + UNITY_SET_DETAILS(CMockString_vkCmdOpticalFlowExecuteNV,CMockString_session); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_session), (void*)(&session), sizeof(VkOpticalFlowSessionNV), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pExecuteInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdOpticalFlowExecuteNV,CMockString_pExecuteInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pExecuteInfo), (void*)(pExecuteInfo), sizeof(const VkOpticalFlowExecuteInfoNV), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdOpticalFlowExecuteNV_CallbackFunctionPointer != NULL) + { + Mock.vkCmdOpticalFlowExecuteNV_CallbackFunctionPointer(commandBuffer, session, pExecuteInfo, Mock.vkCmdOpticalFlowExecuteNV_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdOpticalFlowExecuteNV(CMOCK_vkCmdOpticalFlowExecuteNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo); +void CMockExpectParameters_vkCmdOpticalFlowExecuteNV(CMOCK_vkCmdOpticalFlowExecuteNV_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_session), (void*)(&session), + sizeof(VkOpticalFlowSessionNV[sizeof(session) == sizeof(VkOpticalFlowSessionNV) ? 1 : -1])); /* add VkOpticalFlowSessionNV to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_session = 0; + cmock_call_instance->Expected_pExecuteInfo = pExecuteInfo; + cmock_call_instance->IgnoreArg_pExecuteInfo = 0; +} + +void vkCmdOpticalFlowExecuteNV_CMockIgnore(void) +{ + Mock.vkCmdOpticalFlowExecuteNV_IgnoreBool = (char)1; +} + +void vkCmdOpticalFlowExecuteNV_CMockStopIgnore(void) +{ + Mock.vkCmdOpticalFlowExecuteNV_IgnoreBool = (char)0; +} + +void vkCmdOpticalFlowExecuteNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdOpticalFlowExecuteNV_CALL_INSTANCE)); + CMOCK_vkCmdOpticalFlowExecuteNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdOpticalFlowExecuteNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdOpticalFlowExecuteNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdOpticalFlowExecuteNV_CallInstance, cmock_guts_index); + Mock.vkCmdOpticalFlowExecuteNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdOpticalFlowExecuteNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdOpticalFlowExecuteNV_CALL_INSTANCE)); + CMOCK_vkCmdOpticalFlowExecuteNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdOpticalFlowExecuteNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdOpticalFlowExecuteNV_CallInstance = CMock_Guts_MemChain(Mock.vkCmdOpticalFlowExecuteNV_CallInstance, cmock_guts_index); + Mock.vkCmdOpticalFlowExecuteNV_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdOpticalFlowExecuteNV(cmock_call_instance, commandBuffer, session, pExecuteInfo); +} + +void vkCmdOpticalFlowExecuteNV_AddCallback(CMOCK_vkCmdOpticalFlowExecuteNV_CALLBACK Callback) +{ + Mock.vkCmdOpticalFlowExecuteNV_IgnoreBool = (char)0; + Mock.vkCmdOpticalFlowExecuteNV_CallbackBool = (char)1; + Mock.vkCmdOpticalFlowExecuteNV_CallbackFunctionPointer = Callback; +} + +void vkCmdOpticalFlowExecuteNV_Stub(CMOCK_vkCmdOpticalFlowExecuteNV_CALLBACK Callback) +{ + Mock.vkCmdOpticalFlowExecuteNV_IgnoreBool = (char)0; + Mock.vkCmdOpticalFlowExecuteNV_CallbackBool = (char)0; + Mock.vkCmdOpticalFlowExecuteNV_CallbackFunctionPointer = Callback; +} + +void vkCmdOpticalFlowExecuteNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdOpticalFlowExecuteNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdOpticalFlowExecuteNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdOpticalFlowExecuteNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdOpticalFlowExecuteNV_CMockIgnoreArg_session(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdOpticalFlowExecuteNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdOpticalFlowExecuteNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdOpticalFlowExecuteNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_session = 1; +} + +void vkCmdOpticalFlowExecuteNV_CMockIgnoreArg_pExecuteInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdOpticalFlowExecuteNV_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdOpticalFlowExecuteNV_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdOpticalFlowExecuteNV_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pExecuteInfo = 1; +} + +VkResult vkCreateShadersEXT(VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateShadersEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateShadersEXT); + cmock_call_instance = (CMOCK_vkCreateShadersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateShadersEXT_CallInstance); + Mock.vkCreateShadersEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCreateShadersEXT_CallInstance); + if (Mock.vkCreateShadersEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateShadersEXT_FinalReturn; + memcpy((void*)(&Mock.vkCreateShadersEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateShadersEXT_CallbackBool && + Mock.vkCreateShadersEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateShadersEXT_CallbackFunctionPointer(device, createInfoCount, pCreateInfos, pAllocator, pShaders, Mock.vkCreateShadersEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateShadersEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_createInfoCount) + { + UNITY_SET_DETAILS(CMockString_vkCreateShadersEXT,CMockString_createInfoCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_createInfoCount, createInfoCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfos) + { + UNITY_SET_DETAILS(CMockString_vkCreateShadersEXT,CMockString_pCreateInfos); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfos), (void*)(pCreateInfos), sizeof(const VkShaderCreateInfoEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateShadersEXT,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pShaders) + { + UNITY_SET_DETAILS(CMockString_vkCreateShadersEXT,CMockString_pShaders); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pShaders), (void*)(pShaders), sizeof(VkShaderEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateShadersEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateShadersEXT_CallbackFunctionPointer(device, createInfoCount, pCreateInfos, pAllocator, pShaders, Mock.vkCreateShadersEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pShaders_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pShaders, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pShaders, (const void*)cmock_call_instance->ReturnThruPtr_pShaders_Val, + cmock_call_instance->ReturnThruPtr_pShaders_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateShadersEXT(CMOCK_vkCreateShadersEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders); +void CMockExpectParameters_vkCreateShadersEXT(CMOCK_vkCreateShadersEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_createInfoCount = createInfoCount; + cmock_call_instance->IgnoreArg_createInfoCount = 0; + cmock_call_instance->Expected_pCreateInfos = pCreateInfos; + cmock_call_instance->IgnoreArg_pCreateInfos = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pShaders = pShaders; + cmock_call_instance->IgnoreArg_pShaders = 0; + cmock_call_instance->ReturnThruPtr_pShaders_Used = 0; +} + +void vkCreateShadersEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateShadersEXT_CALL_INSTANCE)); + CMOCK_vkCreateShadersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateShadersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateShadersEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCreateShadersEXT_CallInstance, cmock_guts_index); + Mock.vkCreateShadersEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateShadersEXT_IgnoreBool = (char)1; +} + +void vkCreateShadersEXT_CMockStopIgnore(void) +{ + if(Mock.vkCreateShadersEXT_IgnoreBool) + Mock.vkCreateShadersEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCreateShadersEXT_CallInstance); + Mock.vkCreateShadersEXT_IgnoreBool = (char)0; +} + +void vkCreateShadersEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateShadersEXT_CALL_INSTANCE)); + CMOCK_vkCreateShadersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateShadersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateShadersEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCreateShadersEXT_CallInstance, cmock_guts_index); + Mock.vkCreateShadersEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateShadersEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateShadersEXT_CALL_INSTANCE)); + CMOCK_vkCreateShadersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateShadersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateShadersEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCreateShadersEXT_CallInstance, cmock_guts_index); + Mock.vkCreateShadersEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateShadersEXT(cmock_call_instance, device, createInfoCount, pCreateInfos, pAllocator, pShaders); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateShadersEXT_AddCallback(CMOCK_vkCreateShadersEXT_CALLBACK Callback) +{ + Mock.vkCreateShadersEXT_IgnoreBool = (char)0; + Mock.vkCreateShadersEXT_CallbackBool = (char)1; + Mock.vkCreateShadersEXT_CallbackFunctionPointer = Callback; +} + +void vkCreateShadersEXT_Stub(CMOCK_vkCreateShadersEXT_CALLBACK Callback) +{ + Mock.vkCreateShadersEXT_IgnoreBool = (char)0; + Mock.vkCreateShadersEXT_CallbackBool = (char)0; + Mock.vkCreateShadersEXT_CallbackFunctionPointer = Callback; +} + +void vkCreateShadersEXT_CMockReturnMemThruPtr_pShaders(UNITY_LINE_TYPE cmock_line, VkShaderEXT const* pShaders, size_t cmock_size) +{ + CMOCK_vkCreateShadersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateShadersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateShadersEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pShaders_Used = 1; + cmock_call_instance->ReturnThruPtr_pShaders_Val = pShaders; + cmock_call_instance->ReturnThruPtr_pShaders_Size = cmock_size; +} + +void vkCreateShadersEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateShadersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateShadersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateShadersEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateShadersEXT_CMockIgnoreArg_createInfoCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateShadersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateShadersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateShadersEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_createInfoCount = 1; +} + +void vkCreateShadersEXT_CMockIgnoreArg_pCreateInfos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateShadersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateShadersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateShadersEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfos = 1; +} + +void vkCreateShadersEXT_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateShadersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateShadersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateShadersEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateShadersEXT_CMockIgnoreArg_pShaders(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateShadersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateShadersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateShadersEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pShaders = 1; +} + +void vkDestroyShaderEXT(VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyShaderEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyShaderEXT); + cmock_call_instance = (CMOCK_vkDestroyShaderEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyShaderEXT_CallInstance); + Mock.vkDestroyShaderEXT_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyShaderEXT_CallInstance); + if (Mock.vkDestroyShaderEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyShaderEXT_CallbackBool && + Mock.vkDestroyShaderEXT_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyShaderEXT_CallbackFunctionPointer(device, shader, pAllocator, Mock.vkDestroyShaderEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyShaderEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_shader) + { + UNITY_SET_DETAILS(CMockString_vkDestroyShaderEXT,CMockString_shader); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_shader), (void*)(&shader), sizeof(VkShaderEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyShaderEXT,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyShaderEXT_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyShaderEXT_CallbackFunctionPointer(device, shader, pAllocator, Mock.vkDestroyShaderEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyShaderEXT(CMOCK_vkDestroyShaderEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyShaderEXT(CMOCK_vkDestroyShaderEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_shader), (void*)(&shader), + sizeof(VkShaderEXT[sizeof(shader) == sizeof(VkShaderEXT) ? 1 : -1])); /* add VkShaderEXT to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_shader = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyShaderEXT_CMockIgnore(void) +{ + Mock.vkDestroyShaderEXT_IgnoreBool = (char)1; +} + +void vkDestroyShaderEXT_CMockStopIgnore(void) +{ + Mock.vkDestroyShaderEXT_IgnoreBool = (char)0; +} + +void vkDestroyShaderEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyShaderEXT_CALL_INSTANCE)); + CMOCK_vkDestroyShaderEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyShaderEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyShaderEXT_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyShaderEXT_CallInstance, cmock_guts_index); + Mock.vkDestroyShaderEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyShaderEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyShaderEXT_CALL_INSTANCE)); + CMOCK_vkDestroyShaderEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyShaderEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyShaderEXT_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyShaderEXT_CallInstance, cmock_guts_index); + Mock.vkDestroyShaderEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyShaderEXT(cmock_call_instance, device, shader, pAllocator); +} + +void vkDestroyShaderEXT_AddCallback(CMOCK_vkDestroyShaderEXT_CALLBACK Callback) +{ + Mock.vkDestroyShaderEXT_IgnoreBool = (char)0; + Mock.vkDestroyShaderEXT_CallbackBool = (char)1; + Mock.vkDestroyShaderEXT_CallbackFunctionPointer = Callback; +} + +void vkDestroyShaderEXT_Stub(CMOCK_vkDestroyShaderEXT_CALLBACK Callback) +{ + Mock.vkDestroyShaderEXT_IgnoreBool = (char)0; + Mock.vkDestroyShaderEXT_CallbackBool = (char)0; + Mock.vkDestroyShaderEXT_CallbackFunctionPointer = Callback; +} + +void vkDestroyShaderEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyShaderEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyShaderEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyShaderEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyShaderEXT_CMockIgnoreArg_shader(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyShaderEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyShaderEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyShaderEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_shader = 1; +} + +void vkDestroyShaderEXT_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyShaderEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyShaderEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyShaderEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +VkResult vkGetShaderBinaryDataEXT(VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetShaderBinaryDataEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetShaderBinaryDataEXT); + cmock_call_instance = (CMOCK_vkGetShaderBinaryDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetShaderBinaryDataEXT_CallInstance); + Mock.vkGetShaderBinaryDataEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetShaderBinaryDataEXT_CallInstance); + if (Mock.vkGetShaderBinaryDataEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetShaderBinaryDataEXT_FinalReturn; + memcpy((void*)(&Mock.vkGetShaderBinaryDataEXT_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetShaderBinaryDataEXT_CallbackBool && + Mock.vkGetShaderBinaryDataEXT_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetShaderBinaryDataEXT_CallbackFunctionPointer(device, shader, pDataSize, pData, Mock.vkGetShaderBinaryDataEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetShaderBinaryDataEXT,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_shader) + { + UNITY_SET_DETAILS(CMockString_vkGetShaderBinaryDataEXT,CMockString_shader); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_shader), (void*)(&shader), sizeof(VkShaderEXT), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pDataSize) + { + UNITY_SET_DETAILS(CMockString_vkGetShaderBinaryDataEXT,CMockString_pDataSize); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pDataSize), (void*)(pDataSize), sizeof(size_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pData) + { + UNITY_SET_DETAILS(CMockString_vkGetShaderBinaryDataEXT,CMockString_pData); + if (cmock_call_instance->Expected_pData == NULL) + { UNITY_TEST_ASSERT_NULL(pData, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(cmock_call_instance->Expected_pData, pData, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkGetShaderBinaryDataEXT_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetShaderBinaryDataEXT_CallbackFunctionPointer(device, shader, pDataSize, pData, Mock.vkGetShaderBinaryDataEXT_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pDataSize_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pDataSize, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pDataSize, (const void*)cmock_call_instance->ReturnThruPtr_pDataSize_Val, + cmock_call_instance->ReturnThruPtr_pDataSize_Size); + } + if (cmock_call_instance->ReturnThruPtr_pData_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pData, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pData, (const void*)cmock_call_instance->ReturnThruPtr_pData_Val, + cmock_call_instance->ReturnThruPtr_pData_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetShaderBinaryDataEXT(CMOCK_vkGetShaderBinaryDataEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData); +void CMockExpectParameters_vkGetShaderBinaryDataEXT(CMOCK_vkGetShaderBinaryDataEXT_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_shader), (void*)(&shader), + sizeof(VkShaderEXT[sizeof(shader) == sizeof(VkShaderEXT) ? 1 : -1])); /* add VkShaderEXT to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_shader = 0; + cmock_call_instance->Expected_pDataSize = pDataSize; + cmock_call_instance->IgnoreArg_pDataSize = 0; + cmock_call_instance->ReturnThruPtr_pDataSize_Used = 0; + cmock_call_instance->Expected_pData = pData; + cmock_call_instance->IgnoreArg_pData = 0; + cmock_call_instance->ReturnThruPtr_pData_Used = 0; +} + +void vkGetShaderBinaryDataEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetShaderBinaryDataEXT_CALL_INSTANCE)); + CMOCK_vkGetShaderBinaryDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderBinaryDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetShaderBinaryDataEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetShaderBinaryDataEXT_CallInstance, cmock_guts_index); + Mock.vkGetShaderBinaryDataEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetShaderBinaryDataEXT_IgnoreBool = (char)1; +} + +void vkGetShaderBinaryDataEXT_CMockStopIgnore(void) +{ + if(Mock.vkGetShaderBinaryDataEXT_IgnoreBool) + Mock.vkGetShaderBinaryDataEXT_CallInstance = CMock_Guts_MemNext(Mock.vkGetShaderBinaryDataEXT_CallInstance); + Mock.vkGetShaderBinaryDataEXT_IgnoreBool = (char)0; +} + +void vkGetShaderBinaryDataEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetShaderBinaryDataEXT_CALL_INSTANCE)); + CMOCK_vkGetShaderBinaryDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderBinaryDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetShaderBinaryDataEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetShaderBinaryDataEXT_CallInstance, cmock_guts_index); + Mock.vkGetShaderBinaryDataEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetShaderBinaryDataEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetShaderBinaryDataEXT_CALL_INSTANCE)); + CMOCK_vkGetShaderBinaryDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderBinaryDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetShaderBinaryDataEXT_CallInstance = CMock_Guts_MemChain(Mock.vkGetShaderBinaryDataEXT_CallInstance, cmock_guts_index); + Mock.vkGetShaderBinaryDataEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetShaderBinaryDataEXT(cmock_call_instance, device, shader, pDataSize, pData); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetShaderBinaryDataEXT_AddCallback(CMOCK_vkGetShaderBinaryDataEXT_CALLBACK Callback) +{ + Mock.vkGetShaderBinaryDataEXT_IgnoreBool = (char)0; + Mock.vkGetShaderBinaryDataEXT_CallbackBool = (char)1; + Mock.vkGetShaderBinaryDataEXT_CallbackFunctionPointer = Callback; +} + +void vkGetShaderBinaryDataEXT_Stub(CMOCK_vkGetShaderBinaryDataEXT_CALLBACK Callback) +{ + Mock.vkGetShaderBinaryDataEXT_IgnoreBool = (char)0; + Mock.vkGetShaderBinaryDataEXT_CallbackBool = (char)0; + Mock.vkGetShaderBinaryDataEXT_CallbackFunctionPointer = Callback; +} + +void vkGetShaderBinaryDataEXT_CMockReturnMemThruPtr_pDataSize(UNITY_LINE_TYPE cmock_line, size_t const* pDataSize, size_t cmock_size) +{ + CMOCK_vkGetShaderBinaryDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderBinaryDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetShaderBinaryDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pDataSize_Used = 1; + cmock_call_instance->ReturnThruPtr_pDataSize_Val = pDataSize; + cmock_call_instance->ReturnThruPtr_pDataSize_Size = cmock_size; +} + +void vkGetShaderBinaryDataEXT_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, void const* pData, size_t cmock_size) +{ + CMOCK_vkGetShaderBinaryDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderBinaryDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetShaderBinaryDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pData_Used = 1; + cmock_call_instance->ReturnThruPtr_pData_Val = pData; + cmock_call_instance->ReturnThruPtr_pData_Size = cmock_size; +} + +void vkGetShaderBinaryDataEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetShaderBinaryDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderBinaryDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetShaderBinaryDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetShaderBinaryDataEXT_CMockIgnoreArg_shader(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetShaderBinaryDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderBinaryDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetShaderBinaryDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_shader = 1; +} + +void vkGetShaderBinaryDataEXT_CMockIgnoreArg_pDataSize(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetShaderBinaryDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderBinaryDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetShaderBinaryDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pDataSize = 1; +} + +void vkGetShaderBinaryDataEXT_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetShaderBinaryDataEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetShaderBinaryDataEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetShaderBinaryDataEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pData = 1; +} + +void vkCmdBindShadersEXT(VkCommandBuffer commandBuffer, uint32_t stageCount, const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBindShadersEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBindShadersEXT); + cmock_call_instance = (CMOCK_vkCmdBindShadersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBindShadersEXT_CallInstance); + Mock.vkCmdBindShadersEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBindShadersEXT_CallInstance); + if (Mock.vkCmdBindShadersEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBindShadersEXT_CallbackBool && + Mock.vkCmdBindShadersEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBindShadersEXT_CallbackFunctionPointer(commandBuffer, stageCount, pStages, pShaders, Mock.vkCmdBindShadersEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindShadersEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_stageCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindShadersEXT,CMockString_stageCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_stageCount, stageCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pStages) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindShadersEXT,CMockString_pStages); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pStages), (void*)(pStages), sizeof(const VkShaderStageFlagBits), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pShaders) + { + UNITY_SET_DETAILS(CMockString_vkCmdBindShadersEXT,CMockString_pShaders); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pShaders), (void*)(pShaders), sizeof(const VkShaderEXT), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdBindShadersEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBindShadersEXT_CallbackFunctionPointer(commandBuffer, stageCount, pStages, pShaders, Mock.vkCmdBindShadersEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBindShadersEXT(CMOCK_vkCmdBindShadersEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t stageCount, const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders); +void CMockExpectParameters_vkCmdBindShadersEXT(CMOCK_vkCmdBindShadersEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t stageCount, const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_stageCount = stageCount; + cmock_call_instance->IgnoreArg_stageCount = 0; + cmock_call_instance->Expected_pStages = pStages; + cmock_call_instance->IgnoreArg_pStages = 0; + cmock_call_instance->Expected_pShaders = pShaders; + cmock_call_instance->IgnoreArg_pShaders = 0; +} + +void vkCmdBindShadersEXT_CMockIgnore(void) +{ + Mock.vkCmdBindShadersEXT_IgnoreBool = (char)1; +} + +void vkCmdBindShadersEXT_CMockStopIgnore(void) +{ + Mock.vkCmdBindShadersEXT_IgnoreBool = (char)0; +} + +void vkCmdBindShadersEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBindShadersEXT_CALL_INSTANCE)); + CMOCK_vkCmdBindShadersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindShadersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBindShadersEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBindShadersEXT_CallInstance, cmock_guts_index); + Mock.vkCmdBindShadersEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBindShadersEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t stageCount, const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBindShadersEXT_CALL_INSTANCE)); + CMOCK_vkCmdBindShadersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindShadersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBindShadersEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBindShadersEXT_CallInstance, cmock_guts_index); + Mock.vkCmdBindShadersEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBindShadersEXT(cmock_call_instance, commandBuffer, stageCount, pStages, pShaders); +} + +void vkCmdBindShadersEXT_AddCallback(CMOCK_vkCmdBindShadersEXT_CALLBACK Callback) +{ + Mock.vkCmdBindShadersEXT_IgnoreBool = (char)0; + Mock.vkCmdBindShadersEXT_CallbackBool = (char)1; + Mock.vkCmdBindShadersEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdBindShadersEXT_Stub(CMOCK_vkCmdBindShadersEXT_CALLBACK Callback) +{ + Mock.vkCmdBindShadersEXT_IgnoreBool = (char)0; + Mock.vkCmdBindShadersEXT_CallbackBool = (char)0; + Mock.vkCmdBindShadersEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdBindShadersEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindShadersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindShadersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindShadersEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBindShadersEXT_CMockIgnoreArg_stageCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindShadersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindShadersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindShadersEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stageCount = 1; +} + +void vkCmdBindShadersEXT_CMockIgnoreArg_pStages(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindShadersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindShadersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindShadersEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pStages = 1; +} + +void vkCmdBindShadersEXT_CMockIgnoreArg_pShaders(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBindShadersEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBindShadersEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBindShadersEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pShaders = 1; +} + +VkResult vkGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetFramebufferTilePropertiesQCOM_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetFramebufferTilePropertiesQCOM); + cmock_call_instance = (CMOCK_vkGetFramebufferTilePropertiesQCOM_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetFramebufferTilePropertiesQCOM_CallInstance); + Mock.vkGetFramebufferTilePropertiesQCOM_CallInstance = CMock_Guts_MemNext(Mock.vkGetFramebufferTilePropertiesQCOM_CallInstance); + if (Mock.vkGetFramebufferTilePropertiesQCOM_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetFramebufferTilePropertiesQCOM_FinalReturn; + memcpy((void*)(&Mock.vkGetFramebufferTilePropertiesQCOM_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetFramebufferTilePropertiesQCOM_CallbackBool && + Mock.vkGetFramebufferTilePropertiesQCOM_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetFramebufferTilePropertiesQCOM_CallbackFunctionPointer(device, framebuffer, pPropertiesCount, pProperties, Mock.vkGetFramebufferTilePropertiesQCOM_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetFramebufferTilePropertiesQCOM,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_framebuffer) + { + UNITY_SET_DETAILS(CMockString_vkGetFramebufferTilePropertiesQCOM,CMockString_framebuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_framebuffer), (void*)(&framebuffer), sizeof(VkFramebuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPropertiesCount) + { + UNITY_SET_DETAILS(CMockString_vkGetFramebufferTilePropertiesQCOM,CMockString_pPropertiesCount); + if (cmock_call_instance->Expected_pPropertiesCount == NULL) + { UNITY_TEST_ASSERT_NULL(pPropertiesCount, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pPropertiesCount, pPropertiesCount, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetFramebufferTilePropertiesQCOM,CMockString_pProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pProperties), (void*)(pProperties), sizeof(VkTilePropertiesQCOM), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetFramebufferTilePropertiesQCOM_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetFramebufferTilePropertiesQCOM_CallbackFunctionPointer(device, framebuffer, pPropertiesCount, pProperties, Mock.vkGetFramebufferTilePropertiesQCOM_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPropertiesCount_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPropertiesCount, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPropertiesCount, (const void*)cmock_call_instance->ReturnThruPtr_pPropertiesCount_Val, + cmock_call_instance->ReturnThruPtr_pPropertiesCount_Size); + } + if (cmock_call_instance->ReturnThruPtr_pProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pProperties, (const void*)cmock_call_instance->ReturnThruPtr_pProperties_Val, + cmock_call_instance->ReturnThruPtr_pProperties_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetFramebufferTilePropertiesQCOM(CMOCK_vkGetFramebufferTilePropertiesQCOM_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties); +void CMockExpectParameters_vkGetFramebufferTilePropertiesQCOM(CMOCK_vkGetFramebufferTilePropertiesQCOM_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_framebuffer), (void*)(&framebuffer), + sizeof(VkFramebuffer[sizeof(framebuffer) == sizeof(VkFramebuffer) ? 1 : -1])); /* add VkFramebuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_framebuffer = 0; + cmock_call_instance->Expected_pPropertiesCount = pPropertiesCount; + cmock_call_instance->IgnoreArg_pPropertiesCount = 0; + cmock_call_instance->ReturnThruPtr_pPropertiesCount_Used = 0; + cmock_call_instance->Expected_pProperties = pProperties; + cmock_call_instance->IgnoreArg_pProperties = 0; + cmock_call_instance->ReturnThruPtr_pProperties_Used = 0; +} + +void vkGetFramebufferTilePropertiesQCOM_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetFramebufferTilePropertiesQCOM_CALL_INSTANCE)); + CMOCK_vkGetFramebufferTilePropertiesQCOM_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetFramebufferTilePropertiesQCOM_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetFramebufferTilePropertiesQCOM_CallInstance = CMock_Guts_MemChain(Mock.vkGetFramebufferTilePropertiesQCOM_CallInstance, cmock_guts_index); + Mock.vkGetFramebufferTilePropertiesQCOM_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetFramebufferTilePropertiesQCOM_IgnoreBool = (char)1; +} + +void vkGetFramebufferTilePropertiesQCOM_CMockStopIgnore(void) +{ + if(Mock.vkGetFramebufferTilePropertiesQCOM_IgnoreBool) + Mock.vkGetFramebufferTilePropertiesQCOM_CallInstance = CMock_Guts_MemNext(Mock.vkGetFramebufferTilePropertiesQCOM_CallInstance); + Mock.vkGetFramebufferTilePropertiesQCOM_IgnoreBool = (char)0; +} + +void vkGetFramebufferTilePropertiesQCOM_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetFramebufferTilePropertiesQCOM_CALL_INSTANCE)); + CMOCK_vkGetFramebufferTilePropertiesQCOM_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetFramebufferTilePropertiesQCOM_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetFramebufferTilePropertiesQCOM_CallInstance = CMock_Guts_MemChain(Mock.vkGetFramebufferTilePropertiesQCOM_CallInstance, cmock_guts_index); + Mock.vkGetFramebufferTilePropertiesQCOM_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetFramebufferTilePropertiesQCOM_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetFramebufferTilePropertiesQCOM_CALL_INSTANCE)); + CMOCK_vkGetFramebufferTilePropertiesQCOM_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetFramebufferTilePropertiesQCOM_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetFramebufferTilePropertiesQCOM_CallInstance = CMock_Guts_MemChain(Mock.vkGetFramebufferTilePropertiesQCOM_CallInstance, cmock_guts_index); + Mock.vkGetFramebufferTilePropertiesQCOM_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetFramebufferTilePropertiesQCOM(cmock_call_instance, device, framebuffer, pPropertiesCount, pProperties); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetFramebufferTilePropertiesQCOM_AddCallback(CMOCK_vkGetFramebufferTilePropertiesQCOM_CALLBACK Callback) +{ + Mock.vkGetFramebufferTilePropertiesQCOM_IgnoreBool = (char)0; + Mock.vkGetFramebufferTilePropertiesQCOM_CallbackBool = (char)1; + Mock.vkGetFramebufferTilePropertiesQCOM_CallbackFunctionPointer = Callback; +} + +void vkGetFramebufferTilePropertiesQCOM_Stub(CMOCK_vkGetFramebufferTilePropertiesQCOM_CALLBACK Callback) +{ + Mock.vkGetFramebufferTilePropertiesQCOM_IgnoreBool = (char)0; + Mock.vkGetFramebufferTilePropertiesQCOM_CallbackBool = (char)0; + Mock.vkGetFramebufferTilePropertiesQCOM_CallbackFunctionPointer = Callback; +} + +void vkGetFramebufferTilePropertiesQCOM_CMockReturnMemThruPtr_pPropertiesCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPropertiesCount, size_t cmock_size) +{ + CMOCK_vkGetFramebufferTilePropertiesQCOM_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetFramebufferTilePropertiesQCOM_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetFramebufferTilePropertiesQCOM_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPropertiesCount_Used = 1; + cmock_call_instance->ReturnThruPtr_pPropertiesCount_Val = pPropertiesCount; + cmock_call_instance->ReturnThruPtr_pPropertiesCount_Size = cmock_size; +} + +void vkGetFramebufferTilePropertiesQCOM_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkTilePropertiesQCOM const* pProperties, size_t cmock_size) +{ + CMOCK_vkGetFramebufferTilePropertiesQCOM_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetFramebufferTilePropertiesQCOM_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetFramebufferTilePropertiesQCOM_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pProperties_Val = pProperties; + cmock_call_instance->ReturnThruPtr_pProperties_Size = cmock_size; +} + +void vkGetFramebufferTilePropertiesQCOM_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetFramebufferTilePropertiesQCOM_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetFramebufferTilePropertiesQCOM_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetFramebufferTilePropertiesQCOM_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetFramebufferTilePropertiesQCOM_CMockIgnoreArg_framebuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetFramebufferTilePropertiesQCOM_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetFramebufferTilePropertiesQCOM_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetFramebufferTilePropertiesQCOM_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_framebuffer = 1; +} + +void vkGetFramebufferTilePropertiesQCOM_CMockIgnoreArg_pPropertiesCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetFramebufferTilePropertiesQCOM_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetFramebufferTilePropertiesQCOM_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetFramebufferTilePropertiesQCOM_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPropertiesCount = 1; +} + +void vkGetFramebufferTilePropertiesQCOM_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetFramebufferTilePropertiesQCOM_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetFramebufferTilePropertiesQCOM_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetFramebufferTilePropertiesQCOM_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pProperties = 1; +} + +VkResult vkGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDynamicRenderingTilePropertiesQCOM_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDynamicRenderingTilePropertiesQCOM); + cmock_call_instance = (CMOCK_vkGetDynamicRenderingTilePropertiesQCOM_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDynamicRenderingTilePropertiesQCOM_CallInstance); + Mock.vkGetDynamicRenderingTilePropertiesQCOM_CallInstance = CMock_Guts_MemNext(Mock.vkGetDynamicRenderingTilePropertiesQCOM_CallInstance); + if (Mock.vkGetDynamicRenderingTilePropertiesQCOM_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetDynamicRenderingTilePropertiesQCOM_FinalReturn; + memcpy((void*)(&Mock.vkGetDynamicRenderingTilePropertiesQCOM_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetDynamicRenderingTilePropertiesQCOM_CallbackBool && + Mock.vkGetDynamicRenderingTilePropertiesQCOM_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetDynamicRenderingTilePropertiesQCOM_CallbackFunctionPointer(device, pRenderingInfo, pProperties, Mock.vkGetDynamicRenderingTilePropertiesQCOM_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetDynamicRenderingTilePropertiesQCOM,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pRenderingInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetDynamicRenderingTilePropertiesQCOM,CMockString_pRenderingInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pRenderingInfo), (void*)(pRenderingInfo), sizeof(const VkRenderingInfo), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pProperties) + { + UNITY_SET_DETAILS(CMockString_vkGetDynamicRenderingTilePropertiesQCOM,CMockString_pProperties); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pProperties), (void*)(pProperties), sizeof(VkTilePropertiesQCOM), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDynamicRenderingTilePropertiesQCOM_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetDynamicRenderingTilePropertiesQCOM_CallbackFunctionPointer(device, pRenderingInfo, pProperties, Mock.vkGetDynamicRenderingTilePropertiesQCOM_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pProperties_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pProperties, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pProperties, (const void*)cmock_call_instance->ReturnThruPtr_pProperties_Val, + cmock_call_instance->ReturnThruPtr_pProperties_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetDynamicRenderingTilePropertiesQCOM(CMOCK_vkGetDynamicRenderingTilePropertiesQCOM_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties); +void CMockExpectParameters_vkGetDynamicRenderingTilePropertiesQCOM(CMOCK_vkGetDynamicRenderingTilePropertiesQCOM_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pRenderingInfo = pRenderingInfo; + cmock_call_instance->IgnoreArg_pRenderingInfo = 0; + cmock_call_instance->Expected_pProperties = pProperties; + cmock_call_instance->IgnoreArg_pProperties = 0; + cmock_call_instance->ReturnThruPtr_pProperties_Used = 0; +} + +void vkGetDynamicRenderingTilePropertiesQCOM_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDynamicRenderingTilePropertiesQCOM_CALL_INSTANCE)); + CMOCK_vkGetDynamicRenderingTilePropertiesQCOM_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDynamicRenderingTilePropertiesQCOM_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDynamicRenderingTilePropertiesQCOM_CallInstance = CMock_Guts_MemChain(Mock.vkGetDynamicRenderingTilePropertiesQCOM_CallInstance, cmock_guts_index); + Mock.vkGetDynamicRenderingTilePropertiesQCOM_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetDynamicRenderingTilePropertiesQCOM_IgnoreBool = (char)1; +} + +void vkGetDynamicRenderingTilePropertiesQCOM_CMockStopIgnore(void) +{ + if(Mock.vkGetDynamicRenderingTilePropertiesQCOM_IgnoreBool) + Mock.vkGetDynamicRenderingTilePropertiesQCOM_CallInstance = CMock_Guts_MemNext(Mock.vkGetDynamicRenderingTilePropertiesQCOM_CallInstance); + Mock.vkGetDynamicRenderingTilePropertiesQCOM_IgnoreBool = (char)0; +} + +void vkGetDynamicRenderingTilePropertiesQCOM_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDynamicRenderingTilePropertiesQCOM_CALL_INSTANCE)); + CMOCK_vkGetDynamicRenderingTilePropertiesQCOM_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDynamicRenderingTilePropertiesQCOM_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDynamicRenderingTilePropertiesQCOM_CallInstance = CMock_Guts_MemChain(Mock.vkGetDynamicRenderingTilePropertiesQCOM_CallInstance, cmock_guts_index); + Mock.vkGetDynamicRenderingTilePropertiesQCOM_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDynamicRenderingTilePropertiesQCOM_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDynamicRenderingTilePropertiesQCOM_CALL_INSTANCE)); + CMOCK_vkGetDynamicRenderingTilePropertiesQCOM_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDynamicRenderingTilePropertiesQCOM_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDynamicRenderingTilePropertiesQCOM_CallInstance = CMock_Guts_MemChain(Mock.vkGetDynamicRenderingTilePropertiesQCOM_CallInstance, cmock_guts_index); + Mock.vkGetDynamicRenderingTilePropertiesQCOM_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDynamicRenderingTilePropertiesQCOM(cmock_call_instance, device, pRenderingInfo, pProperties); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetDynamicRenderingTilePropertiesQCOM_AddCallback(CMOCK_vkGetDynamicRenderingTilePropertiesQCOM_CALLBACK Callback) +{ + Mock.vkGetDynamicRenderingTilePropertiesQCOM_IgnoreBool = (char)0; + Mock.vkGetDynamicRenderingTilePropertiesQCOM_CallbackBool = (char)1; + Mock.vkGetDynamicRenderingTilePropertiesQCOM_CallbackFunctionPointer = Callback; +} + +void vkGetDynamicRenderingTilePropertiesQCOM_Stub(CMOCK_vkGetDynamicRenderingTilePropertiesQCOM_CALLBACK Callback) +{ + Mock.vkGetDynamicRenderingTilePropertiesQCOM_IgnoreBool = (char)0; + Mock.vkGetDynamicRenderingTilePropertiesQCOM_CallbackBool = (char)0; + Mock.vkGetDynamicRenderingTilePropertiesQCOM_CallbackFunctionPointer = Callback; +} + +void vkGetDynamicRenderingTilePropertiesQCOM_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkTilePropertiesQCOM const* pProperties, size_t cmock_size) +{ + CMOCK_vkGetDynamicRenderingTilePropertiesQCOM_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDynamicRenderingTilePropertiesQCOM_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDynamicRenderingTilePropertiesQCOM_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pProperties_Used = 1; + cmock_call_instance->ReturnThruPtr_pProperties_Val = pProperties; + cmock_call_instance->ReturnThruPtr_pProperties_Size = cmock_size; +} + +void vkGetDynamicRenderingTilePropertiesQCOM_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDynamicRenderingTilePropertiesQCOM_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDynamicRenderingTilePropertiesQCOM_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDynamicRenderingTilePropertiesQCOM_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetDynamicRenderingTilePropertiesQCOM_CMockIgnoreArg_pRenderingInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDynamicRenderingTilePropertiesQCOM_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDynamicRenderingTilePropertiesQCOM_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDynamicRenderingTilePropertiesQCOM_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pRenderingInfo = 1; +} + +void vkGetDynamicRenderingTilePropertiesQCOM_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDynamicRenderingTilePropertiesQCOM_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDynamicRenderingTilePropertiesQCOM_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDynamicRenderingTilePropertiesQCOM_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pProperties = 1; +} + +void vkCmdSetAttachmentFeedbackLoopEnableEXT(VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetAttachmentFeedbackLoopEnableEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetAttachmentFeedbackLoopEnableEXT); + cmock_call_instance = (CMOCK_vkCmdSetAttachmentFeedbackLoopEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetAttachmentFeedbackLoopEnableEXT_CallInstance); + Mock.vkCmdSetAttachmentFeedbackLoopEnableEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetAttachmentFeedbackLoopEnableEXT_CallInstance); + if (Mock.vkCmdSetAttachmentFeedbackLoopEnableEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetAttachmentFeedbackLoopEnableEXT_CallbackBool && + Mock.vkCmdSetAttachmentFeedbackLoopEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetAttachmentFeedbackLoopEnableEXT_CallbackFunctionPointer(commandBuffer, aspectMask, Mock.vkCmdSetAttachmentFeedbackLoopEnableEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetAttachmentFeedbackLoopEnableEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_aspectMask) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetAttachmentFeedbackLoopEnableEXT,CMockString_aspectMask); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_aspectMask), (void*)(&aspectMask), sizeof(VkImageAspectFlags), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetAttachmentFeedbackLoopEnableEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetAttachmentFeedbackLoopEnableEXT_CallbackFunctionPointer(commandBuffer, aspectMask, Mock.vkCmdSetAttachmentFeedbackLoopEnableEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetAttachmentFeedbackLoopEnableEXT(CMOCK_vkCmdSetAttachmentFeedbackLoopEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask); +void CMockExpectParameters_vkCmdSetAttachmentFeedbackLoopEnableEXT(CMOCK_vkCmdSetAttachmentFeedbackLoopEnableEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_aspectMask), (void*)(&aspectMask), + sizeof(VkImageAspectFlags[sizeof(aspectMask) == sizeof(VkImageAspectFlags) ? 1 : -1])); /* add VkImageAspectFlags to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_aspectMask = 0; +} + +void vkCmdSetAttachmentFeedbackLoopEnableEXT_CMockIgnore(void) +{ + Mock.vkCmdSetAttachmentFeedbackLoopEnableEXT_IgnoreBool = (char)1; +} + +void vkCmdSetAttachmentFeedbackLoopEnableEXT_CMockStopIgnore(void) +{ + Mock.vkCmdSetAttachmentFeedbackLoopEnableEXT_IgnoreBool = (char)0; +} + +void vkCmdSetAttachmentFeedbackLoopEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetAttachmentFeedbackLoopEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetAttachmentFeedbackLoopEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetAttachmentFeedbackLoopEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetAttachmentFeedbackLoopEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetAttachmentFeedbackLoopEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetAttachmentFeedbackLoopEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetAttachmentFeedbackLoopEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetAttachmentFeedbackLoopEnableEXT_CALL_INSTANCE)); + CMOCK_vkCmdSetAttachmentFeedbackLoopEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetAttachmentFeedbackLoopEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetAttachmentFeedbackLoopEnableEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetAttachmentFeedbackLoopEnableEXT_CallInstance, cmock_guts_index); + Mock.vkCmdSetAttachmentFeedbackLoopEnableEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetAttachmentFeedbackLoopEnableEXT(cmock_call_instance, commandBuffer, aspectMask); +} + +void vkCmdSetAttachmentFeedbackLoopEnableEXT_AddCallback(CMOCK_vkCmdSetAttachmentFeedbackLoopEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetAttachmentFeedbackLoopEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetAttachmentFeedbackLoopEnableEXT_CallbackBool = (char)1; + Mock.vkCmdSetAttachmentFeedbackLoopEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetAttachmentFeedbackLoopEnableEXT_Stub(CMOCK_vkCmdSetAttachmentFeedbackLoopEnableEXT_CALLBACK Callback) +{ + Mock.vkCmdSetAttachmentFeedbackLoopEnableEXT_IgnoreBool = (char)0; + Mock.vkCmdSetAttachmentFeedbackLoopEnableEXT_CallbackBool = (char)0; + Mock.vkCmdSetAttachmentFeedbackLoopEnableEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdSetAttachmentFeedbackLoopEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetAttachmentFeedbackLoopEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetAttachmentFeedbackLoopEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetAttachmentFeedbackLoopEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetAttachmentFeedbackLoopEnableEXT_CMockIgnoreArg_aspectMask(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetAttachmentFeedbackLoopEnableEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetAttachmentFeedbackLoopEnableEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetAttachmentFeedbackLoopEnableEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_aspectMask = 1; +} + +VkResult vkCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateAccelerationStructureKHR); + cmock_call_instance = (CMOCK_vkCreateAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateAccelerationStructureKHR_CallInstance); + Mock.vkCreateAccelerationStructureKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCreateAccelerationStructureKHR_CallInstance); + if (Mock.vkCreateAccelerationStructureKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateAccelerationStructureKHR_FinalReturn; + memcpy((void*)(&Mock.vkCreateAccelerationStructureKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateAccelerationStructureKHR_CallbackBool && + Mock.vkCreateAccelerationStructureKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateAccelerationStructureKHR_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pAccelerationStructure, Mock.vkCreateAccelerationStructureKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateAccelerationStructureKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfo) + { + UNITY_SET_DETAILS(CMockString_vkCreateAccelerationStructureKHR,CMockString_pCreateInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfo), (void*)(pCreateInfo), sizeof(const VkAccelerationStructureCreateInfoKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateAccelerationStructureKHR,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAccelerationStructure) + { + UNITY_SET_DETAILS(CMockString_vkCreateAccelerationStructureKHR,CMockString_pAccelerationStructure); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAccelerationStructure), (void*)(pAccelerationStructure), sizeof(VkAccelerationStructureKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateAccelerationStructureKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateAccelerationStructureKHR_CallbackFunctionPointer(device, pCreateInfo, pAllocator, pAccelerationStructure, Mock.vkCreateAccelerationStructureKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pAccelerationStructure_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pAccelerationStructure, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pAccelerationStructure, (const void*)cmock_call_instance->ReturnThruPtr_pAccelerationStructure_Val, + cmock_call_instance->ReturnThruPtr_pAccelerationStructure_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateAccelerationStructureKHR(CMOCK_vkCreateAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure); +void CMockExpectParameters_vkCreateAccelerationStructureKHR(CMOCK_vkCreateAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pCreateInfo = pCreateInfo; + cmock_call_instance->IgnoreArg_pCreateInfo = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pAccelerationStructure = pAccelerationStructure; + cmock_call_instance->IgnoreArg_pAccelerationStructure = 0; + cmock_call_instance->ReturnThruPtr_pAccelerationStructure_Used = 0; +} + +void vkCreateAccelerationStructureKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateAccelerationStructureKHR_CALL_INSTANCE)); + CMOCK_vkCreateAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateAccelerationStructureKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateAccelerationStructureKHR_CallInstance, cmock_guts_index); + Mock.vkCreateAccelerationStructureKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateAccelerationStructureKHR_IgnoreBool = (char)1; +} + +void vkCreateAccelerationStructureKHR_CMockStopIgnore(void) +{ + if(Mock.vkCreateAccelerationStructureKHR_IgnoreBool) + Mock.vkCreateAccelerationStructureKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCreateAccelerationStructureKHR_CallInstance); + Mock.vkCreateAccelerationStructureKHR_IgnoreBool = (char)0; +} + +void vkCreateAccelerationStructureKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateAccelerationStructureKHR_CALL_INSTANCE)); + CMOCK_vkCreateAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateAccelerationStructureKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateAccelerationStructureKHR_CallInstance, cmock_guts_index); + Mock.vkCreateAccelerationStructureKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateAccelerationStructureKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateAccelerationStructureKHR_CALL_INSTANCE)); + CMOCK_vkCreateAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateAccelerationStructureKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateAccelerationStructureKHR_CallInstance, cmock_guts_index); + Mock.vkCreateAccelerationStructureKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateAccelerationStructureKHR(cmock_call_instance, device, pCreateInfo, pAllocator, pAccelerationStructure); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateAccelerationStructureKHR_AddCallback(CMOCK_vkCreateAccelerationStructureKHR_CALLBACK Callback) +{ + Mock.vkCreateAccelerationStructureKHR_IgnoreBool = (char)0; + Mock.vkCreateAccelerationStructureKHR_CallbackBool = (char)1; + Mock.vkCreateAccelerationStructureKHR_CallbackFunctionPointer = Callback; +} + +void vkCreateAccelerationStructureKHR_Stub(CMOCK_vkCreateAccelerationStructureKHR_CALLBACK Callback) +{ + Mock.vkCreateAccelerationStructureKHR_IgnoreBool = (char)0; + Mock.vkCreateAccelerationStructureKHR_CallbackBool = (char)0; + Mock.vkCreateAccelerationStructureKHR_CallbackFunctionPointer = Callback; +} + +void vkCreateAccelerationStructureKHR_CMockReturnMemThruPtr_pAccelerationStructure(UNITY_LINE_TYPE cmock_line, VkAccelerationStructureKHR const* pAccelerationStructure, size_t cmock_size) +{ + CMOCK_vkCreateAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateAccelerationStructureKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pAccelerationStructure_Used = 1; + cmock_call_instance->ReturnThruPtr_pAccelerationStructure_Val = pAccelerationStructure; + cmock_call_instance->ReturnThruPtr_pAccelerationStructure_Size = cmock_size; +} + +void vkCreateAccelerationStructureKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateAccelerationStructureKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateAccelerationStructureKHR_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateAccelerationStructureKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfo = 1; +} + +void vkCreateAccelerationStructureKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateAccelerationStructureKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateAccelerationStructureKHR_CMockIgnoreArg_pAccelerationStructure(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateAccelerationStructureKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAccelerationStructure = 1; +} + +void vkDestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkDestroyAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkDestroyAccelerationStructureKHR); + cmock_call_instance = (CMOCK_vkDestroyAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkDestroyAccelerationStructureKHR_CallInstance); + Mock.vkDestroyAccelerationStructureKHR_CallInstance = CMock_Guts_MemNext(Mock.vkDestroyAccelerationStructureKHR_CallInstance); + if (Mock.vkDestroyAccelerationStructureKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkDestroyAccelerationStructureKHR_CallbackBool && + Mock.vkDestroyAccelerationStructureKHR_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyAccelerationStructureKHR_CallbackFunctionPointer(device, accelerationStructure, pAllocator, Mock.vkDestroyAccelerationStructureKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkDestroyAccelerationStructureKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_accelerationStructure) + { + UNITY_SET_DETAILS(CMockString_vkDestroyAccelerationStructureKHR,CMockString_accelerationStructure); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_accelerationStructure), (void*)(&accelerationStructure), sizeof(VkAccelerationStructureKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkDestroyAccelerationStructureKHR,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkDestroyAccelerationStructureKHR_CallbackFunctionPointer != NULL) + { + Mock.vkDestroyAccelerationStructureKHR_CallbackFunctionPointer(device, accelerationStructure, pAllocator, Mock.vkDestroyAccelerationStructureKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkDestroyAccelerationStructureKHR(CMOCK_vkDestroyAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator); +void CMockExpectParameters_vkDestroyAccelerationStructureKHR(CMOCK_vkDestroyAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_accelerationStructure), (void*)(&accelerationStructure), + sizeof(VkAccelerationStructureKHR[sizeof(accelerationStructure) == sizeof(VkAccelerationStructureKHR) ? 1 : -1])); /* add VkAccelerationStructureKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_accelerationStructure = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; +} + +void vkDestroyAccelerationStructureKHR_CMockIgnore(void) +{ + Mock.vkDestroyAccelerationStructureKHR_IgnoreBool = (char)1; +} + +void vkDestroyAccelerationStructureKHR_CMockStopIgnore(void) +{ + Mock.vkDestroyAccelerationStructureKHR_IgnoreBool = (char)0; +} + +void vkDestroyAccelerationStructureKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyAccelerationStructureKHR_CALL_INSTANCE)); + CMOCK_vkDestroyAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyAccelerationStructureKHR_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyAccelerationStructureKHR_CallInstance, cmock_guts_index); + Mock.vkDestroyAccelerationStructureKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkDestroyAccelerationStructureKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkDestroyAccelerationStructureKHR_CALL_INSTANCE)); + CMOCK_vkDestroyAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkDestroyAccelerationStructureKHR_CallInstance = CMock_Guts_MemChain(Mock.vkDestroyAccelerationStructureKHR_CallInstance, cmock_guts_index); + Mock.vkDestroyAccelerationStructureKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkDestroyAccelerationStructureKHR(cmock_call_instance, device, accelerationStructure, pAllocator); +} + +void vkDestroyAccelerationStructureKHR_AddCallback(CMOCK_vkDestroyAccelerationStructureKHR_CALLBACK Callback) +{ + Mock.vkDestroyAccelerationStructureKHR_IgnoreBool = (char)0; + Mock.vkDestroyAccelerationStructureKHR_CallbackBool = (char)1; + Mock.vkDestroyAccelerationStructureKHR_CallbackFunctionPointer = Callback; +} + +void vkDestroyAccelerationStructureKHR_Stub(CMOCK_vkDestroyAccelerationStructureKHR_CALLBACK Callback) +{ + Mock.vkDestroyAccelerationStructureKHR_IgnoreBool = (char)0; + Mock.vkDestroyAccelerationStructureKHR_CallbackBool = (char)0; + Mock.vkDestroyAccelerationStructureKHR_CallbackFunctionPointer = Callback; +} + +void vkDestroyAccelerationStructureKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyAccelerationStructureKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkDestroyAccelerationStructureKHR_CMockIgnoreArg_accelerationStructure(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyAccelerationStructureKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_accelerationStructure = 1; +} + +void vkDestroyAccelerationStructureKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkDestroyAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkDestroyAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkDestroyAccelerationStructureKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBuildAccelerationStructuresKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBuildAccelerationStructuresKHR); + cmock_call_instance = (CMOCK_vkCmdBuildAccelerationStructuresKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBuildAccelerationStructuresKHR_CallInstance); + Mock.vkCmdBuildAccelerationStructuresKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBuildAccelerationStructuresKHR_CallInstance); + if (Mock.vkCmdBuildAccelerationStructuresKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBuildAccelerationStructuresKHR_CallbackBool && + Mock.vkCmdBuildAccelerationStructuresKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBuildAccelerationStructuresKHR_CallbackFunctionPointer(commandBuffer, infoCount, pInfos, ppBuildRangeInfos, Mock.vkCmdBuildAccelerationStructuresKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBuildAccelerationStructuresKHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_infoCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdBuildAccelerationStructuresKHR,CMockString_infoCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_infoCount, infoCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfos) + { + UNITY_SET_DETAILS(CMockString_vkCmdBuildAccelerationStructuresKHR,CMockString_pInfos); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfos), (void*)(pInfos), sizeof(const VkAccelerationStructureBuildGeometryInfoKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_ppBuildRangeInfos) + { + UNITY_SET_DETAILS(CMockString_vkCmdBuildAccelerationStructuresKHR,CMockString_ppBuildRangeInfos); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_ppBuildRangeInfos), (void*)(&ppBuildRangeInfos), sizeof(const VkAccelerationStructureBuildRangeInfoKHR* const), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdBuildAccelerationStructuresKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBuildAccelerationStructuresKHR_CallbackFunctionPointer(commandBuffer, infoCount, pInfos, ppBuildRangeInfos, Mock.vkCmdBuildAccelerationStructuresKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBuildAccelerationStructuresKHR(CMOCK_vkCmdBuildAccelerationStructuresKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); +void CMockExpectParameters_vkCmdBuildAccelerationStructuresKHR(CMOCK_vkCmdBuildAccelerationStructuresKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_infoCount = infoCount; + cmock_call_instance->IgnoreArg_infoCount = 0; + cmock_call_instance->Expected_pInfos = pInfos; + cmock_call_instance->IgnoreArg_pInfos = 0; + cmock_call_instance->Expected_ppBuildRangeInfos = ppBuildRangeInfos; + cmock_call_instance->IgnoreArg_ppBuildRangeInfos = 0; +} + +void vkCmdBuildAccelerationStructuresKHR_CMockIgnore(void) +{ + Mock.vkCmdBuildAccelerationStructuresKHR_IgnoreBool = (char)1; +} + +void vkCmdBuildAccelerationStructuresKHR_CMockStopIgnore(void) +{ + Mock.vkCmdBuildAccelerationStructuresKHR_IgnoreBool = (char)0; +} + +void vkCmdBuildAccelerationStructuresKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBuildAccelerationStructuresKHR_CALL_INSTANCE)); + CMOCK_vkCmdBuildAccelerationStructuresKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBuildAccelerationStructuresKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBuildAccelerationStructuresKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBuildAccelerationStructuresKHR_CallInstance, cmock_guts_index); + Mock.vkCmdBuildAccelerationStructuresKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBuildAccelerationStructuresKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBuildAccelerationStructuresKHR_CALL_INSTANCE)); + CMOCK_vkCmdBuildAccelerationStructuresKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBuildAccelerationStructuresKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBuildAccelerationStructuresKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBuildAccelerationStructuresKHR_CallInstance, cmock_guts_index); + Mock.vkCmdBuildAccelerationStructuresKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBuildAccelerationStructuresKHR(cmock_call_instance, commandBuffer, infoCount, pInfos, ppBuildRangeInfos); +} + +void vkCmdBuildAccelerationStructuresKHR_AddCallback(CMOCK_vkCmdBuildAccelerationStructuresKHR_CALLBACK Callback) +{ + Mock.vkCmdBuildAccelerationStructuresKHR_IgnoreBool = (char)0; + Mock.vkCmdBuildAccelerationStructuresKHR_CallbackBool = (char)1; + Mock.vkCmdBuildAccelerationStructuresKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdBuildAccelerationStructuresKHR_Stub(CMOCK_vkCmdBuildAccelerationStructuresKHR_CALLBACK Callback) +{ + Mock.vkCmdBuildAccelerationStructuresKHR_IgnoreBool = (char)0; + Mock.vkCmdBuildAccelerationStructuresKHR_CallbackBool = (char)0; + Mock.vkCmdBuildAccelerationStructuresKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdBuildAccelerationStructuresKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBuildAccelerationStructuresKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBuildAccelerationStructuresKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBuildAccelerationStructuresKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBuildAccelerationStructuresKHR_CMockIgnoreArg_infoCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBuildAccelerationStructuresKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBuildAccelerationStructuresKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBuildAccelerationStructuresKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_infoCount = 1; +} + +void vkCmdBuildAccelerationStructuresKHR_CMockIgnoreArg_pInfos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBuildAccelerationStructuresKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBuildAccelerationStructuresKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBuildAccelerationStructuresKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfos = 1; +} + +void vkCmdBuildAccelerationStructuresKHR_CMockIgnoreArg_ppBuildRangeInfos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBuildAccelerationStructuresKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBuildAccelerationStructuresKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBuildAccelerationStructuresKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_ppBuildRangeInfos = 1; +} + +void vkCmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdBuildAccelerationStructuresIndirectKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdBuildAccelerationStructuresIndirectKHR); + cmock_call_instance = (CMOCK_vkCmdBuildAccelerationStructuresIndirectKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdBuildAccelerationStructuresIndirectKHR_CallInstance); + Mock.vkCmdBuildAccelerationStructuresIndirectKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdBuildAccelerationStructuresIndirectKHR_CallInstance); + if (Mock.vkCmdBuildAccelerationStructuresIndirectKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdBuildAccelerationStructuresIndirectKHR_CallbackBool && + Mock.vkCmdBuildAccelerationStructuresIndirectKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBuildAccelerationStructuresIndirectKHR_CallbackFunctionPointer(commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts, Mock.vkCmdBuildAccelerationStructuresIndirectKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdBuildAccelerationStructuresIndirectKHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_infoCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdBuildAccelerationStructuresIndirectKHR,CMockString_infoCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_infoCount, infoCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfos) + { + UNITY_SET_DETAILS(CMockString_vkCmdBuildAccelerationStructuresIndirectKHR,CMockString_pInfos); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfos), (void*)(pInfos), sizeof(const VkAccelerationStructureBuildGeometryInfoKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pIndirectDeviceAddresses) + { + UNITY_SET_DETAILS(CMockString_vkCmdBuildAccelerationStructuresIndirectKHR,CMockString_pIndirectDeviceAddresses); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pIndirectDeviceAddresses), (void*)(pIndirectDeviceAddresses), sizeof(const VkDeviceAddress), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pIndirectStrides) + { + UNITY_SET_DETAILS(CMockString_vkCmdBuildAccelerationStructuresIndirectKHR,CMockString_pIndirectStrides); + if (cmock_call_instance->Expected_pIndirectStrides == NULL) + { UNITY_TEST_ASSERT_NULL(pIndirectStrides, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pIndirectStrides, pIndirectStrides, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_ppMaxPrimitiveCounts) + { + UNITY_SET_DETAILS(CMockString_vkCmdBuildAccelerationStructuresIndirectKHR,CMockString_ppMaxPrimitiveCounts); + if (*cmock_call_instance->Expected_ppMaxPrimitiveCounts == NULL) + { UNITY_TEST_ASSERT_NULL(*ppMaxPrimitiveCounts, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(*cmock_call_instance->Expected_ppMaxPrimitiveCounts, *ppMaxPrimitiveCounts, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkCmdBuildAccelerationStructuresIndirectKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdBuildAccelerationStructuresIndirectKHR_CallbackFunctionPointer(commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts, Mock.vkCmdBuildAccelerationStructuresIndirectKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdBuildAccelerationStructuresIndirectKHR(CMOCK_vkCmdBuildAccelerationStructuresIndirectKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts); +void CMockExpectParameters_vkCmdBuildAccelerationStructuresIndirectKHR(CMOCK_vkCmdBuildAccelerationStructuresIndirectKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_infoCount = infoCount; + cmock_call_instance->IgnoreArg_infoCount = 0; + cmock_call_instance->Expected_pInfos = pInfos; + cmock_call_instance->IgnoreArg_pInfos = 0; + cmock_call_instance->Expected_pIndirectDeviceAddresses = pIndirectDeviceAddresses; + cmock_call_instance->IgnoreArg_pIndirectDeviceAddresses = 0; + cmock_call_instance->Expected_pIndirectStrides = pIndirectStrides; + cmock_call_instance->IgnoreArg_pIndirectStrides = 0; + cmock_call_instance->Expected_ppMaxPrimitiveCounts = ppMaxPrimitiveCounts; + cmock_call_instance->IgnoreArg_ppMaxPrimitiveCounts = 0; +} + +void vkCmdBuildAccelerationStructuresIndirectKHR_CMockIgnore(void) +{ + Mock.vkCmdBuildAccelerationStructuresIndirectKHR_IgnoreBool = (char)1; +} + +void vkCmdBuildAccelerationStructuresIndirectKHR_CMockStopIgnore(void) +{ + Mock.vkCmdBuildAccelerationStructuresIndirectKHR_IgnoreBool = (char)0; +} + +void vkCmdBuildAccelerationStructuresIndirectKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBuildAccelerationStructuresIndirectKHR_CALL_INSTANCE)); + CMOCK_vkCmdBuildAccelerationStructuresIndirectKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBuildAccelerationStructuresIndirectKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBuildAccelerationStructuresIndirectKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBuildAccelerationStructuresIndirectKHR_CallInstance, cmock_guts_index); + Mock.vkCmdBuildAccelerationStructuresIndirectKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdBuildAccelerationStructuresIndirectKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdBuildAccelerationStructuresIndirectKHR_CALL_INSTANCE)); + CMOCK_vkCmdBuildAccelerationStructuresIndirectKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBuildAccelerationStructuresIndirectKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdBuildAccelerationStructuresIndirectKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdBuildAccelerationStructuresIndirectKHR_CallInstance, cmock_guts_index); + Mock.vkCmdBuildAccelerationStructuresIndirectKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdBuildAccelerationStructuresIndirectKHR(cmock_call_instance, commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts); +} + +void vkCmdBuildAccelerationStructuresIndirectKHR_AddCallback(CMOCK_vkCmdBuildAccelerationStructuresIndirectKHR_CALLBACK Callback) +{ + Mock.vkCmdBuildAccelerationStructuresIndirectKHR_IgnoreBool = (char)0; + Mock.vkCmdBuildAccelerationStructuresIndirectKHR_CallbackBool = (char)1; + Mock.vkCmdBuildAccelerationStructuresIndirectKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdBuildAccelerationStructuresIndirectKHR_Stub(CMOCK_vkCmdBuildAccelerationStructuresIndirectKHR_CALLBACK Callback) +{ + Mock.vkCmdBuildAccelerationStructuresIndirectKHR_IgnoreBool = (char)0; + Mock.vkCmdBuildAccelerationStructuresIndirectKHR_CallbackBool = (char)0; + Mock.vkCmdBuildAccelerationStructuresIndirectKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdBuildAccelerationStructuresIndirectKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBuildAccelerationStructuresIndirectKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBuildAccelerationStructuresIndirectKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBuildAccelerationStructuresIndirectKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdBuildAccelerationStructuresIndirectKHR_CMockIgnoreArg_infoCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBuildAccelerationStructuresIndirectKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBuildAccelerationStructuresIndirectKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBuildAccelerationStructuresIndirectKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_infoCount = 1; +} + +void vkCmdBuildAccelerationStructuresIndirectKHR_CMockIgnoreArg_pInfos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBuildAccelerationStructuresIndirectKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBuildAccelerationStructuresIndirectKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBuildAccelerationStructuresIndirectKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfos = 1; +} + +void vkCmdBuildAccelerationStructuresIndirectKHR_CMockIgnoreArg_pIndirectDeviceAddresses(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBuildAccelerationStructuresIndirectKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBuildAccelerationStructuresIndirectKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBuildAccelerationStructuresIndirectKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pIndirectDeviceAddresses = 1; +} + +void vkCmdBuildAccelerationStructuresIndirectKHR_CMockIgnoreArg_pIndirectStrides(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBuildAccelerationStructuresIndirectKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBuildAccelerationStructuresIndirectKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBuildAccelerationStructuresIndirectKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pIndirectStrides = 1; +} + +void vkCmdBuildAccelerationStructuresIndirectKHR_CMockIgnoreArg_ppMaxPrimitiveCounts(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdBuildAccelerationStructuresIndirectKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdBuildAccelerationStructuresIndirectKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdBuildAccelerationStructuresIndirectKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_ppMaxPrimitiveCounts = 1; +} + +VkResult vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkBuildAccelerationStructuresKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkBuildAccelerationStructuresKHR); + cmock_call_instance = (CMOCK_vkBuildAccelerationStructuresKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkBuildAccelerationStructuresKHR_CallInstance); + Mock.vkBuildAccelerationStructuresKHR_CallInstance = CMock_Guts_MemNext(Mock.vkBuildAccelerationStructuresKHR_CallInstance); + if (Mock.vkBuildAccelerationStructuresKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkBuildAccelerationStructuresKHR_FinalReturn; + memcpy((void*)(&Mock.vkBuildAccelerationStructuresKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkBuildAccelerationStructuresKHR_CallbackBool && + Mock.vkBuildAccelerationStructuresKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkBuildAccelerationStructuresKHR_CallbackFunctionPointer(device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos, Mock.vkBuildAccelerationStructuresKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkBuildAccelerationStructuresKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_deferredOperation) + { + UNITY_SET_DETAILS(CMockString_vkBuildAccelerationStructuresKHR,CMockString_deferredOperation); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_deferredOperation), (void*)(&deferredOperation), sizeof(VkDeferredOperationKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_infoCount) + { + UNITY_SET_DETAILS(CMockString_vkBuildAccelerationStructuresKHR,CMockString_infoCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_infoCount, infoCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfos) + { + UNITY_SET_DETAILS(CMockString_vkBuildAccelerationStructuresKHR,CMockString_pInfos); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfos), (void*)(pInfos), sizeof(const VkAccelerationStructureBuildGeometryInfoKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_ppBuildRangeInfos) + { + UNITY_SET_DETAILS(CMockString_vkBuildAccelerationStructuresKHR,CMockString_ppBuildRangeInfos); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_ppBuildRangeInfos), (void*)(&ppBuildRangeInfos), sizeof(const VkAccelerationStructureBuildRangeInfoKHR* const), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkBuildAccelerationStructuresKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkBuildAccelerationStructuresKHR_CallbackFunctionPointer(device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos, Mock.vkBuildAccelerationStructuresKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkBuildAccelerationStructuresKHR(CMOCK_vkBuildAccelerationStructuresKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); +void CMockExpectParameters_vkBuildAccelerationStructuresKHR(CMOCK_vkBuildAccelerationStructuresKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_deferredOperation), (void*)(&deferredOperation), + sizeof(VkDeferredOperationKHR[sizeof(deferredOperation) == sizeof(VkDeferredOperationKHR) ? 1 : -1])); /* add VkDeferredOperationKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_deferredOperation = 0; + cmock_call_instance->Expected_infoCount = infoCount; + cmock_call_instance->IgnoreArg_infoCount = 0; + cmock_call_instance->Expected_pInfos = pInfos; + cmock_call_instance->IgnoreArg_pInfos = 0; + cmock_call_instance->Expected_ppBuildRangeInfos = ppBuildRangeInfos; + cmock_call_instance->IgnoreArg_ppBuildRangeInfos = 0; +} + +void vkBuildAccelerationStructuresKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBuildAccelerationStructuresKHR_CALL_INSTANCE)); + CMOCK_vkBuildAccelerationStructuresKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBuildAccelerationStructuresKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBuildAccelerationStructuresKHR_CallInstance = CMock_Guts_MemChain(Mock.vkBuildAccelerationStructuresKHR_CallInstance, cmock_guts_index); + Mock.vkBuildAccelerationStructuresKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkBuildAccelerationStructuresKHR_IgnoreBool = (char)1; +} + +void vkBuildAccelerationStructuresKHR_CMockStopIgnore(void) +{ + if(Mock.vkBuildAccelerationStructuresKHR_IgnoreBool) + Mock.vkBuildAccelerationStructuresKHR_CallInstance = CMock_Guts_MemNext(Mock.vkBuildAccelerationStructuresKHR_CallInstance); + Mock.vkBuildAccelerationStructuresKHR_IgnoreBool = (char)0; +} + +void vkBuildAccelerationStructuresKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBuildAccelerationStructuresKHR_CALL_INSTANCE)); + CMOCK_vkBuildAccelerationStructuresKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBuildAccelerationStructuresKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBuildAccelerationStructuresKHR_CallInstance = CMock_Guts_MemChain(Mock.vkBuildAccelerationStructuresKHR_CallInstance, cmock_guts_index); + Mock.vkBuildAccelerationStructuresKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkBuildAccelerationStructuresKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkBuildAccelerationStructuresKHR_CALL_INSTANCE)); + CMOCK_vkBuildAccelerationStructuresKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBuildAccelerationStructuresKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkBuildAccelerationStructuresKHR_CallInstance = CMock_Guts_MemChain(Mock.vkBuildAccelerationStructuresKHR_CallInstance, cmock_guts_index); + Mock.vkBuildAccelerationStructuresKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkBuildAccelerationStructuresKHR(cmock_call_instance, device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkBuildAccelerationStructuresKHR_AddCallback(CMOCK_vkBuildAccelerationStructuresKHR_CALLBACK Callback) +{ + Mock.vkBuildAccelerationStructuresKHR_IgnoreBool = (char)0; + Mock.vkBuildAccelerationStructuresKHR_CallbackBool = (char)1; + Mock.vkBuildAccelerationStructuresKHR_CallbackFunctionPointer = Callback; +} + +void vkBuildAccelerationStructuresKHR_Stub(CMOCK_vkBuildAccelerationStructuresKHR_CALLBACK Callback) +{ + Mock.vkBuildAccelerationStructuresKHR_IgnoreBool = (char)0; + Mock.vkBuildAccelerationStructuresKHR_CallbackBool = (char)0; + Mock.vkBuildAccelerationStructuresKHR_CallbackFunctionPointer = Callback; +} + +void vkBuildAccelerationStructuresKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBuildAccelerationStructuresKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBuildAccelerationStructuresKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBuildAccelerationStructuresKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkBuildAccelerationStructuresKHR_CMockIgnoreArg_deferredOperation(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBuildAccelerationStructuresKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBuildAccelerationStructuresKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBuildAccelerationStructuresKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_deferredOperation = 1; +} + +void vkBuildAccelerationStructuresKHR_CMockIgnoreArg_infoCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBuildAccelerationStructuresKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBuildAccelerationStructuresKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBuildAccelerationStructuresKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_infoCount = 1; +} + +void vkBuildAccelerationStructuresKHR_CMockIgnoreArg_pInfos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBuildAccelerationStructuresKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBuildAccelerationStructuresKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBuildAccelerationStructuresKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfos = 1; +} + +void vkBuildAccelerationStructuresKHR_CMockIgnoreArg_ppBuildRangeInfos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkBuildAccelerationStructuresKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkBuildAccelerationStructuresKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkBuildAccelerationStructuresKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_ppBuildRangeInfos = 1; +} + +VkResult vkCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCopyAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCopyAccelerationStructureKHR); + cmock_call_instance = (CMOCK_vkCopyAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCopyAccelerationStructureKHR_CallInstance); + Mock.vkCopyAccelerationStructureKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCopyAccelerationStructureKHR_CallInstance); + if (Mock.vkCopyAccelerationStructureKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCopyAccelerationStructureKHR_FinalReturn; + memcpy((void*)(&Mock.vkCopyAccelerationStructureKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCopyAccelerationStructureKHR_CallbackBool && + Mock.vkCopyAccelerationStructureKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCopyAccelerationStructureKHR_CallbackFunctionPointer(device, deferredOperation, pInfo, Mock.vkCopyAccelerationStructureKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCopyAccelerationStructureKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_deferredOperation) + { + UNITY_SET_DETAILS(CMockString_vkCopyAccelerationStructureKHR,CMockString_deferredOperation); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_deferredOperation), (void*)(&deferredOperation), sizeof(VkDeferredOperationKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkCopyAccelerationStructureKHR,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkCopyAccelerationStructureInfoKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCopyAccelerationStructureKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCopyAccelerationStructureKHR_CallbackFunctionPointer(device, deferredOperation, pInfo, Mock.vkCopyAccelerationStructureKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCopyAccelerationStructureKHR(CMOCK_vkCopyAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo); +void CMockExpectParameters_vkCopyAccelerationStructureKHR(CMOCK_vkCopyAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_deferredOperation), (void*)(&deferredOperation), + sizeof(VkDeferredOperationKHR[sizeof(deferredOperation) == sizeof(VkDeferredOperationKHR) ? 1 : -1])); /* add VkDeferredOperationKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_deferredOperation = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; +} + +void vkCopyAccelerationStructureKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCopyAccelerationStructureKHR_CALL_INSTANCE)); + CMOCK_vkCopyAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCopyAccelerationStructureKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCopyAccelerationStructureKHR_CallInstance, cmock_guts_index); + Mock.vkCopyAccelerationStructureKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCopyAccelerationStructureKHR_IgnoreBool = (char)1; +} + +void vkCopyAccelerationStructureKHR_CMockStopIgnore(void) +{ + if(Mock.vkCopyAccelerationStructureKHR_IgnoreBool) + Mock.vkCopyAccelerationStructureKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCopyAccelerationStructureKHR_CallInstance); + Mock.vkCopyAccelerationStructureKHR_IgnoreBool = (char)0; +} + +void vkCopyAccelerationStructureKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCopyAccelerationStructureKHR_CALL_INSTANCE)); + CMOCK_vkCopyAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCopyAccelerationStructureKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCopyAccelerationStructureKHR_CallInstance, cmock_guts_index); + Mock.vkCopyAccelerationStructureKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCopyAccelerationStructureKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCopyAccelerationStructureKHR_CALL_INSTANCE)); + CMOCK_vkCopyAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCopyAccelerationStructureKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCopyAccelerationStructureKHR_CallInstance, cmock_guts_index); + Mock.vkCopyAccelerationStructureKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCopyAccelerationStructureKHR(cmock_call_instance, device, deferredOperation, pInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCopyAccelerationStructureKHR_AddCallback(CMOCK_vkCopyAccelerationStructureKHR_CALLBACK Callback) +{ + Mock.vkCopyAccelerationStructureKHR_IgnoreBool = (char)0; + Mock.vkCopyAccelerationStructureKHR_CallbackBool = (char)1; + Mock.vkCopyAccelerationStructureKHR_CallbackFunctionPointer = Callback; +} + +void vkCopyAccelerationStructureKHR_Stub(CMOCK_vkCopyAccelerationStructureKHR_CALLBACK Callback) +{ + Mock.vkCopyAccelerationStructureKHR_IgnoreBool = (char)0; + Mock.vkCopyAccelerationStructureKHR_CallbackBool = (char)0; + Mock.vkCopyAccelerationStructureKHR_CallbackFunctionPointer = Callback; +} + +void vkCopyAccelerationStructureKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCopyAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCopyAccelerationStructureKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCopyAccelerationStructureKHR_CMockIgnoreArg_deferredOperation(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCopyAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCopyAccelerationStructureKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_deferredOperation = 1; +} + +void vkCopyAccelerationStructureKHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCopyAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCopyAccelerationStructureKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +VkResult vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCopyAccelerationStructureToMemoryKHR); + cmock_call_instance = (CMOCK_vkCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCopyAccelerationStructureToMemoryKHR_CallInstance); + Mock.vkCopyAccelerationStructureToMemoryKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCopyAccelerationStructureToMemoryKHR_CallInstance); + if (Mock.vkCopyAccelerationStructureToMemoryKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCopyAccelerationStructureToMemoryKHR_FinalReturn; + memcpy((void*)(&Mock.vkCopyAccelerationStructureToMemoryKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCopyAccelerationStructureToMemoryKHR_CallbackBool && + Mock.vkCopyAccelerationStructureToMemoryKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCopyAccelerationStructureToMemoryKHR_CallbackFunctionPointer(device, deferredOperation, pInfo, Mock.vkCopyAccelerationStructureToMemoryKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCopyAccelerationStructureToMemoryKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_deferredOperation) + { + UNITY_SET_DETAILS(CMockString_vkCopyAccelerationStructureToMemoryKHR,CMockString_deferredOperation); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_deferredOperation), (void*)(&deferredOperation), sizeof(VkDeferredOperationKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkCopyAccelerationStructureToMemoryKHR,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkCopyAccelerationStructureToMemoryInfoKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCopyAccelerationStructureToMemoryKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCopyAccelerationStructureToMemoryKHR_CallbackFunctionPointer(device, deferredOperation, pInfo, Mock.vkCopyAccelerationStructureToMemoryKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCopyAccelerationStructureToMemoryKHR(CMOCK_vkCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); +void CMockExpectParameters_vkCopyAccelerationStructureToMemoryKHR(CMOCK_vkCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_deferredOperation), (void*)(&deferredOperation), + sizeof(VkDeferredOperationKHR[sizeof(deferredOperation) == sizeof(VkDeferredOperationKHR) ? 1 : -1])); /* add VkDeferredOperationKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_deferredOperation = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; +} + +void vkCopyAccelerationStructureToMemoryKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE)); + CMOCK_vkCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCopyAccelerationStructureToMemoryKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCopyAccelerationStructureToMemoryKHR_CallInstance, cmock_guts_index); + Mock.vkCopyAccelerationStructureToMemoryKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCopyAccelerationStructureToMemoryKHR_IgnoreBool = (char)1; +} + +void vkCopyAccelerationStructureToMemoryKHR_CMockStopIgnore(void) +{ + if(Mock.vkCopyAccelerationStructureToMemoryKHR_IgnoreBool) + Mock.vkCopyAccelerationStructureToMemoryKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCopyAccelerationStructureToMemoryKHR_CallInstance); + Mock.vkCopyAccelerationStructureToMemoryKHR_IgnoreBool = (char)0; +} + +void vkCopyAccelerationStructureToMemoryKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE)); + CMOCK_vkCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCopyAccelerationStructureToMemoryKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCopyAccelerationStructureToMemoryKHR_CallInstance, cmock_guts_index); + Mock.vkCopyAccelerationStructureToMemoryKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCopyAccelerationStructureToMemoryKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE)); + CMOCK_vkCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCopyAccelerationStructureToMemoryKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCopyAccelerationStructureToMemoryKHR_CallInstance, cmock_guts_index); + Mock.vkCopyAccelerationStructureToMemoryKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCopyAccelerationStructureToMemoryKHR(cmock_call_instance, device, deferredOperation, pInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCopyAccelerationStructureToMemoryKHR_AddCallback(CMOCK_vkCopyAccelerationStructureToMemoryKHR_CALLBACK Callback) +{ + Mock.vkCopyAccelerationStructureToMemoryKHR_IgnoreBool = (char)0; + Mock.vkCopyAccelerationStructureToMemoryKHR_CallbackBool = (char)1; + Mock.vkCopyAccelerationStructureToMemoryKHR_CallbackFunctionPointer = Callback; +} + +void vkCopyAccelerationStructureToMemoryKHR_Stub(CMOCK_vkCopyAccelerationStructureToMemoryKHR_CALLBACK Callback) +{ + Mock.vkCopyAccelerationStructureToMemoryKHR_IgnoreBool = (char)0; + Mock.vkCopyAccelerationStructureToMemoryKHR_CallbackBool = (char)0; + Mock.vkCopyAccelerationStructureToMemoryKHR_CallbackFunctionPointer = Callback; +} + +void vkCopyAccelerationStructureToMemoryKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCopyAccelerationStructureToMemoryKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCopyAccelerationStructureToMemoryKHR_CMockIgnoreArg_deferredOperation(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCopyAccelerationStructureToMemoryKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_deferredOperation = 1; +} + +void vkCopyAccelerationStructureToMemoryKHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCopyAccelerationStructureToMemoryKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +VkResult vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCopyMemoryToAccelerationStructureKHR); + cmock_call_instance = (CMOCK_vkCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCopyMemoryToAccelerationStructureKHR_CallInstance); + Mock.vkCopyMemoryToAccelerationStructureKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCopyMemoryToAccelerationStructureKHR_CallInstance); + if (Mock.vkCopyMemoryToAccelerationStructureKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCopyMemoryToAccelerationStructureKHR_FinalReturn; + memcpy((void*)(&Mock.vkCopyMemoryToAccelerationStructureKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCopyMemoryToAccelerationStructureKHR_CallbackBool && + Mock.vkCopyMemoryToAccelerationStructureKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCopyMemoryToAccelerationStructureKHR_CallbackFunctionPointer(device, deferredOperation, pInfo, Mock.vkCopyMemoryToAccelerationStructureKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCopyMemoryToAccelerationStructureKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_deferredOperation) + { + UNITY_SET_DETAILS(CMockString_vkCopyMemoryToAccelerationStructureKHR,CMockString_deferredOperation); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_deferredOperation), (void*)(&deferredOperation), sizeof(VkDeferredOperationKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkCopyMemoryToAccelerationStructureKHR,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkCopyMemoryToAccelerationStructureInfoKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCopyMemoryToAccelerationStructureKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCopyMemoryToAccelerationStructureKHR_CallbackFunctionPointer(device, deferredOperation, pInfo, Mock.vkCopyMemoryToAccelerationStructureKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCopyMemoryToAccelerationStructureKHR(CMOCK_vkCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); +void CMockExpectParameters_vkCopyMemoryToAccelerationStructureKHR(CMOCK_vkCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_deferredOperation), (void*)(&deferredOperation), + sizeof(VkDeferredOperationKHR[sizeof(deferredOperation) == sizeof(VkDeferredOperationKHR) ? 1 : -1])); /* add VkDeferredOperationKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_deferredOperation = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; +} + +void vkCopyMemoryToAccelerationStructureKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE)); + CMOCK_vkCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCopyMemoryToAccelerationStructureKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCopyMemoryToAccelerationStructureKHR_CallInstance, cmock_guts_index); + Mock.vkCopyMemoryToAccelerationStructureKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCopyMemoryToAccelerationStructureKHR_IgnoreBool = (char)1; +} + +void vkCopyMemoryToAccelerationStructureKHR_CMockStopIgnore(void) +{ + if(Mock.vkCopyMemoryToAccelerationStructureKHR_IgnoreBool) + Mock.vkCopyMemoryToAccelerationStructureKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCopyMemoryToAccelerationStructureKHR_CallInstance); + Mock.vkCopyMemoryToAccelerationStructureKHR_IgnoreBool = (char)0; +} + +void vkCopyMemoryToAccelerationStructureKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE)); + CMOCK_vkCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCopyMemoryToAccelerationStructureKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCopyMemoryToAccelerationStructureKHR_CallInstance, cmock_guts_index); + Mock.vkCopyMemoryToAccelerationStructureKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCopyMemoryToAccelerationStructureKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE)); + CMOCK_vkCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCopyMemoryToAccelerationStructureKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCopyMemoryToAccelerationStructureKHR_CallInstance, cmock_guts_index); + Mock.vkCopyMemoryToAccelerationStructureKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCopyMemoryToAccelerationStructureKHR(cmock_call_instance, device, deferredOperation, pInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCopyMemoryToAccelerationStructureKHR_AddCallback(CMOCK_vkCopyMemoryToAccelerationStructureKHR_CALLBACK Callback) +{ + Mock.vkCopyMemoryToAccelerationStructureKHR_IgnoreBool = (char)0; + Mock.vkCopyMemoryToAccelerationStructureKHR_CallbackBool = (char)1; + Mock.vkCopyMemoryToAccelerationStructureKHR_CallbackFunctionPointer = Callback; +} + +void vkCopyMemoryToAccelerationStructureKHR_Stub(CMOCK_vkCopyMemoryToAccelerationStructureKHR_CALLBACK Callback) +{ + Mock.vkCopyMemoryToAccelerationStructureKHR_IgnoreBool = (char)0; + Mock.vkCopyMemoryToAccelerationStructureKHR_CallbackBool = (char)0; + Mock.vkCopyMemoryToAccelerationStructureKHR_CallbackFunctionPointer = Callback; +} + +void vkCopyMemoryToAccelerationStructureKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCopyMemoryToAccelerationStructureKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCopyMemoryToAccelerationStructureKHR_CMockIgnoreArg_deferredOperation(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCopyMemoryToAccelerationStructureKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_deferredOperation = 1; +} + +void vkCopyMemoryToAccelerationStructureKHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCopyMemoryToAccelerationStructureKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +VkResult vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkWriteAccelerationStructuresPropertiesKHR); + cmock_call_instance = (CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkWriteAccelerationStructuresPropertiesKHR_CallInstance); + Mock.vkWriteAccelerationStructuresPropertiesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkWriteAccelerationStructuresPropertiesKHR_CallInstance); + if (Mock.vkWriteAccelerationStructuresPropertiesKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkWriteAccelerationStructuresPropertiesKHR_FinalReturn; + memcpy((void*)(&Mock.vkWriteAccelerationStructuresPropertiesKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkWriteAccelerationStructuresPropertiesKHR_CallbackBool && + Mock.vkWriteAccelerationStructuresPropertiesKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkWriteAccelerationStructuresPropertiesKHR_CallbackFunctionPointer(device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride, Mock.vkWriteAccelerationStructuresPropertiesKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkWriteAccelerationStructuresPropertiesKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_accelerationStructureCount) + { + UNITY_SET_DETAILS(CMockString_vkWriteAccelerationStructuresPropertiesKHR,CMockString_accelerationStructureCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_accelerationStructureCount, accelerationStructureCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAccelerationStructures) + { + UNITY_SET_DETAILS(CMockString_vkWriteAccelerationStructuresPropertiesKHR,CMockString_pAccelerationStructures); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAccelerationStructures), (void*)(pAccelerationStructures), sizeof(const VkAccelerationStructureKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queryType) + { + UNITY_SET_DETAILS(CMockString_vkWriteAccelerationStructuresPropertiesKHR,CMockString_queryType); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queryType), (void*)(&queryType), sizeof(VkQueryType), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dataSize) + { + UNITY_SET_DETAILS(CMockString_vkWriteAccelerationStructuresPropertiesKHR,CMockString_dataSize); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dataSize), (void*)(&dataSize), sizeof(size_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pData) + { + UNITY_SET_DETAILS(CMockString_vkWriteAccelerationStructuresPropertiesKHR,CMockString_pData); + if (cmock_call_instance->Expected_pData == NULL) + { UNITY_TEST_ASSERT_NULL(pData, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(cmock_call_instance->Expected_pData, pData, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_stride) + { + UNITY_SET_DETAILS(CMockString_vkWriteAccelerationStructuresPropertiesKHR,CMockString_stride); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_stride), (void*)(&stride), sizeof(size_t), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkWriteAccelerationStructuresPropertiesKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkWriteAccelerationStructuresPropertiesKHR_CallbackFunctionPointer(device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride, Mock.vkWriteAccelerationStructuresPropertiesKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pData_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pData, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pData, (const void*)cmock_call_instance->ReturnThruPtr_pData_Val, + cmock_call_instance->ReturnThruPtr_pData_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkWriteAccelerationStructuresPropertiesKHR(CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride); +void CMockExpectParameters_vkWriteAccelerationStructuresPropertiesKHR(CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_accelerationStructureCount = accelerationStructureCount; + cmock_call_instance->IgnoreArg_accelerationStructureCount = 0; + cmock_call_instance->Expected_pAccelerationStructures = pAccelerationStructures; + cmock_call_instance->IgnoreArg_pAccelerationStructures = 0; + memcpy((void*)(&cmock_call_instance->Expected_queryType), (void*)(&queryType), + sizeof(VkQueryType[sizeof(queryType) == sizeof(VkQueryType) ? 1 : -1])); /* add VkQueryType to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queryType = 0; + memcpy((void*)(&cmock_call_instance->Expected_dataSize), (void*)(&dataSize), + sizeof(size_t[sizeof(dataSize) == sizeof(size_t) ? 1 : -1])); /* add size_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dataSize = 0; + cmock_call_instance->Expected_pData = pData; + cmock_call_instance->IgnoreArg_pData = 0; + cmock_call_instance->ReturnThruPtr_pData_Used = 0; + memcpy((void*)(&cmock_call_instance->Expected_stride), (void*)(&stride), + sizeof(size_t[sizeof(stride) == sizeof(size_t) ? 1 : -1])); /* add size_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_stride = 0; +} + +void vkWriteAccelerationStructuresPropertiesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE)); + CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkWriteAccelerationStructuresPropertiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkWriteAccelerationStructuresPropertiesKHR_CallInstance, cmock_guts_index); + Mock.vkWriteAccelerationStructuresPropertiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkWriteAccelerationStructuresPropertiesKHR_IgnoreBool = (char)1; +} + +void vkWriteAccelerationStructuresPropertiesKHR_CMockStopIgnore(void) +{ + if(Mock.vkWriteAccelerationStructuresPropertiesKHR_IgnoreBool) + Mock.vkWriteAccelerationStructuresPropertiesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkWriteAccelerationStructuresPropertiesKHR_CallInstance); + Mock.vkWriteAccelerationStructuresPropertiesKHR_IgnoreBool = (char)0; +} + +void vkWriteAccelerationStructuresPropertiesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE)); + CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkWriteAccelerationStructuresPropertiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkWriteAccelerationStructuresPropertiesKHR_CallInstance, cmock_guts_index); + Mock.vkWriteAccelerationStructuresPropertiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkWriteAccelerationStructuresPropertiesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE)); + CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkWriteAccelerationStructuresPropertiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkWriteAccelerationStructuresPropertiesKHR_CallInstance, cmock_guts_index); + Mock.vkWriteAccelerationStructuresPropertiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkWriteAccelerationStructuresPropertiesKHR(cmock_call_instance, device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkWriteAccelerationStructuresPropertiesKHR_AddCallback(CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALLBACK Callback) +{ + Mock.vkWriteAccelerationStructuresPropertiesKHR_IgnoreBool = (char)0; + Mock.vkWriteAccelerationStructuresPropertiesKHR_CallbackBool = (char)1; + Mock.vkWriteAccelerationStructuresPropertiesKHR_CallbackFunctionPointer = Callback; +} + +void vkWriteAccelerationStructuresPropertiesKHR_Stub(CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALLBACK Callback) +{ + Mock.vkWriteAccelerationStructuresPropertiesKHR_IgnoreBool = (char)0; + Mock.vkWriteAccelerationStructuresPropertiesKHR_CallbackBool = (char)0; + Mock.vkWriteAccelerationStructuresPropertiesKHR_CallbackFunctionPointer = Callback; +} + +void vkWriteAccelerationStructuresPropertiesKHR_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, void const* pData, size_t cmock_size) +{ + CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWriteAccelerationStructuresPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pData_Used = 1; + cmock_call_instance->ReturnThruPtr_pData_Val = pData; + cmock_call_instance->ReturnThruPtr_pData_Size = cmock_size; +} + +void vkWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWriteAccelerationStructuresPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_accelerationStructureCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWriteAccelerationStructuresPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_accelerationStructureCount = 1; +} + +void vkWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_pAccelerationStructures(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWriteAccelerationStructuresPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAccelerationStructures = 1; +} + +void vkWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_queryType(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWriteAccelerationStructuresPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queryType = 1; +} + +void vkWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_dataSize(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWriteAccelerationStructuresPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dataSize = 1; +} + +void vkWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWriteAccelerationStructuresPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pData = 1; +} + +void vkWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkWriteAccelerationStructuresPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stride = 1; +} + +void vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdCopyAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdCopyAccelerationStructureKHR); + cmock_call_instance = (CMOCK_vkCmdCopyAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdCopyAccelerationStructureKHR_CallInstance); + Mock.vkCmdCopyAccelerationStructureKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdCopyAccelerationStructureKHR_CallInstance); + if (Mock.vkCmdCopyAccelerationStructureKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdCopyAccelerationStructureKHR_CallbackBool && + Mock.vkCmdCopyAccelerationStructureKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyAccelerationStructureKHR_CallbackFunctionPointer(commandBuffer, pInfo, Mock.vkCmdCopyAccelerationStructureKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyAccelerationStructureKHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyAccelerationStructureKHR,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkCopyAccelerationStructureInfoKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdCopyAccelerationStructureKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyAccelerationStructureKHR_CallbackFunctionPointer(commandBuffer, pInfo, Mock.vkCmdCopyAccelerationStructureKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdCopyAccelerationStructureKHR(CMOCK_vkCmdCopyAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo); +void CMockExpectParameters_vkCmdCopyAccelerationStructureKHR(CMOCK_vkCmdCopyAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; +} + +void vkCmdCopyAccelerationStructureKHR_CMockIgnore(void) +{ + Mock.vkCmdCopyAccelerationStructureKHR_IgnoreBool = (char)1; +} + +void vkCmdCopyAccelerationStructureKHR_CMockStopIgnore(void) +{ + Mock.vkCmdCopyAccelerationStructureKHR_IgnoreBool = (char)0; +} + +void vkCmdCopyAccelerationStructureKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyAccelerationStructureKHR_CALL_INSTANCE)); + CMOCK_vkCmdCopyAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyAccelerationStructureKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyAccelerationStructureKHR_CallInstance, cmock_guts_index); + Mock.vkCmdCopyAccelerationStructureKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdCopyAccelerationStructureKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyAccelerationStructureKHR_CALL_INSTANCE)); + CMOCK_vkCmdCopyAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyAccelerationStructureKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyAccelerationStructureKHR_CallInstance, cmock_guts_index); + Mock.vkCmdCopyAccelerationStructureKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdCopyAccelerationStructureKHR(cmock_call_instance, commandBuffer, pInfo); +} + +void vkCmdCopyAccelerationStructureKHR_AddCallback(CMOCK_vkCmdCopyAccelerationStructureKHR_CALLBACK Callback) +{ + Mock.vkCmdCopyAccelerationStructureKHR_IgnoreBool = (char)0; + Mock.vkCmdCopyAccelerationStructureKHR_CallbackBool = (char)1; + Mock.vkCmdCopyAccelerationStructureKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyAccelerationStructureKHR_Stub(CMOCK_vkCmdCopyAccelerationStructureKHR_CALLBACK Callback) +{ + Mock.vkCmdCopyAccelerationStructureKHR_IgnoreBool = (char)0; + Mock.vkCmdCopyAccelerationStructureKHR_CallbackBool = (char)0; + Mock.vkCmdCopyAccelerationStructureKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyAccelerationStructureKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyAccelerationStructureKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdCopyAccelerationStructureKHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyAccelerationStructureKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +void vkCmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdCopyAccelerationStructureToMemoryKHR); + cmock_call_instance = (CMOCK_vkCmdCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdCopyAccelerationStructureToMemoryKHR_CallInstance); + Mock.vkCmdCopyAccelerationStructureToMemoryKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdCopyAccelerationStructureToMemoryKHR_CallInstance); + if (Mock.vkCmdCopyAccelerationStructureToMemoryKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdCopyAccelerationStructureToMemoryKHR_CallbackBool && + Mock.vkCmdCopyAccelerationStructureToMemoryKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyAccelerationStructureToMemoryKHR_CallbackFunctionPointer(commandBuffer, pInfo, Mock.vkCmdCopyAccelerationStructureToMemoryKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyAccelerationStructureToMemoryKHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyAccelerationStructureToMemoryKHR,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkCopyAccelerationStructureToMemoryInfoKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdCopyAccelerationStructureToMemoryKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyAccelerationStructureToMemoryKHR_CallbackFunctionPointer(commandBuffer, pInfo, Mock.vkCmdCopyAccelerationStructureToMemoryKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdCopyAccelerationStructureToMemoryKHR(CMOCK_vkCmdCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); +void CMockExpectParameters_vkCmdCopyAccelerationStructureToMemoryKHR(CMOCK_vkCmdCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; +} + +void vkCmdCopyAccelerationStructureToMemoryKHR_CMockIgnore(void) +{ + Mock.vkCmdCopyAccelerationStructureToMemoryKHR_IgnoreBool = (char)1; +} + +void vkCmdCopyAccelerationStructureToMemoryKHR_CMockStopIgnore(void) +{ + Mock.vkCmdCopyAccelerationStructureToMemoryKHR_IgnoreBool = (char)0; +} + +void vkCmdCopyAccelerationStructureToMemoryKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE)); + CMOCK_vkCmdCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyAccelerationStructureToMemoryKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyAccelerationStructureToMemoryKHR_CallInstance, cmock_guts_index); + Mock.vkCmdCopyAccelerationStructureToMemoryKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdCopyAccelerationStructureToMemoryKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE)); + CMOCK_vkCmdCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyAccelerationStructureToMemoryKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyAccelerationStructureToMemoryKHR_CallInstance, cmock_guts_index); + Mock.vkCmdCopyAccelerationStructureToMemoryKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdCopyAccelerationStructureToMemoryKHR(cmock_call_instance, commandBuffer, pInfo); +} + +void vkCmdCopyAccelerationStructureToMemoryKHR_AddCallback(CMOCK_vkCmdCopyAccelerationStructureToMemoryKHR_CALLBACK Callback) +{ + Mock.vkCmdCopyAccelerationStructureToMemoryKHR_IgnoreBool = (char)0; + Mock.vkCmdCopyAccelerationStructureToMemoryKHR_CallbackBool = (char)1; + Mock.vkCmdCopyAccelerationStructureToMemoryKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyAccelerationStructureToMemoryKHR_Stub(CMOCK_vkCmdCopyAccelerationStructureToMemoryKHR_CALLBACK Callback) +{ + Mock.vkCmdCopyAccelerationStructureToMemoryKHR_IgnoreBool = (char)0; + Mock.vkCmdCopyAccelerationStructureToMemoryKHR_CallbackBool = (char)0; + Mock.vkCmdCopyAccelerationStructureToMemoryKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyAccelerationStructureToMemoryKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyAccelerationStructureToMemoryKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdCopyAccelerationStructureToMemoryKHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyAccelerationStructureToMemoryKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyAccelerationStructureToMemoryKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +void vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdCopyMemoryToAccelerationStructureKHR); + cmock_call_instance = (CMOCK_vkCmdCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdCopyMemoryToAccelerationStructureKHR_CallInstance); + Mock.vkCmdCopyMemoryToAccelerationStructureKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdCopyMemoryToAccelerationStructureKHR_CallInstance); + if (Mock.vkCmdCopyMemoryToAccelerationStructureKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdCopyMemoryToAccelerationStructureKHR_CallbackBool && + Mock.vkCmdCopyMemoryToAccelerationStructureKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyMemoryToAccelerationStructureKHR_CallbackFunctionPointer(commandBuffer, pInfo, Mock.vkCmdCopyMemoryToAccelerationStructureKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyMemoryToAccelerationStructureKHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkCmdCopyMemoryToAccelerationStructureKHR,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkCopyMemoryToAccelerationStructureInfoKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdCopyMemoryToAccelerationStructureKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdCopyMemoryToAccelerationStructureKHR_CallbackFunctionPointer(commandBuffer, pInfo, Mock.vkCmdCopyMemoryToAccelerationStructureKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdCopyMemoryToAccelerationStructureKHR(CMOCK_vkCmdCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); +void CMockExpectParameters_vkCmdCopyMemoryToAccelerationStructureKHR(CMOCK_vkCmdCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; +} + +void vkCmdCopyMemoryToAccelerationStructureKHR_CMockIgnore(void) +{ + Mock.vkCmdCopyMemoryToAccelerationStructureKHR_IgnoreBool = (char)1; +} + +void vkCmdCopyMemoryToAccelerationStructureKHR_CMockStopIgnore(void) +{ + Mock.vkCmdCopyMemoryToAccelerationStructureKHR_IgnoreBool = (char)0; +} + +void vkCmdCopyMemoryToAccelerationStructureKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE)); + CMOCK_vkCmdCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyMemoryToAccelerationStructureKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyMemoryToAccelerationStructureKHR_CallInstance, cmock_guts_index); + Mock.vkCmdCopyMemoryToAccelerationStructureKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdCopyMemoryToAccelerationStructureKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE)); + CMOCK_vkCmdCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdCopyMemoryToAccelerationStructureKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdCopyMemoryToAccelerationStructureKHR_CallInstance, cmock_guts_index); + Mock.vkCmdCopyMemoryToAccelerationStructureKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdCopyMemoryToAccelerationStructureKHR(cmock_call_instance, commandBuffer, pInfo); +} + +void vkCmdCopyMemoryToAccelerationStructureKHR_AddCallback(CMOCK_vkCmdCopyMemoryToAccelerationStructureKHR_CALLBACK Callback) +{ + Mock.vkCmdCopyMemoryToAccelerationStructureKHR_IgnoreBool = (char)0; + Mock.vkCmdCopyMemoryToAccelerationStructureKHR_CallbackBool = (char)1; + Mock.vkCmdCopyMemoryToAccelerationStructureKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyMemoryToAccelerationStructureKHR_Stub(CMOCK_vkCmdCopyMemoryToAccelerationStructureKHR_CALLBACK Callback) +{ + Mock.vkCmdCopyMemoryToAccelerationStructureKHR_IgnoreBool = (char)0; + Mock.vkCmdCopyMemoryToAccelerationStructureKHR_CallbackBool = (char)0; + Mock.vkCmdCopyMemoryToAccelerationStructureKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdCopyMemoryToAccelerationStructureKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyMemoryToAccelerationStructureKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdCopyMemoryToAccelerationStructureKHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdCopyMemoryToAccelerationStructureKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdCopyMemoryToAccelerationStructureKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetAccelerationStructureDeviceAddressKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetAccelerationStructureDeviceAddressKHR); + cmock_call_instance = (CMOCK_vkGetAccelerationStructureDeviceAddressKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetAccelerationStructureDeviceAddressKHR_CallInstance); + Mock.vkGetAccelerationStructureDeviceAddressKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetAccelerationStructureDeviceAddressKHR_CallInstance); + if (Mock.vkGetAccelerationStructureDeviceAddressKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetAccelerationStructureDeviceAddressKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetAccelerationStructureDeviceAddressKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkDeviceAddress[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkDeviceAddress) ? 1 : -1])); /* add VkDeviceAddress to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetAccelerationStructureDeviceAddressKHR_CallbackBool && + Mock.vkGetAccelerationStructureDeviceAddressKHR_CallbackFunctionPointer != NULL) + { + VkDeviceAddress cmock_cb_ret = Mock.vkGetAccelerationStructureDeviceAddressKHR_CallbackFunctionPointer(device, pInfo, Mock.vkGetAccelerationStructureDeviceAddressKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetAccelerationStructureDeviceAddressKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetAccelerationStructureDeviceAddressKHR,CMockString_pInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pInfo), (void*)(pInfo), sizeof(const VkAccelerationStructureDeviceAddressInfoKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetAccelerationStructureDeviceAddressKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetAccelerationStructureDeviceAddressKHR_CallbackFunctionPointer(device, pInfo, Mock.vkGetAccelerationStructureDeviceAddressKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetAccelerationStructureDeviceAddressKHR(CMOCK_vkGetAccelerationStructureDeviceAddressKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo); +void CMockExpectParameters_vkGetAccelerationStructureDeviceAddressKHR(CMOCK_vkGetAccelerationStructureDeviceAddressKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pInfo = pInfo; + cmock_call_instance->IgnoreArg_pInfo = 0; +} + +void vkGetAccelerationStructureDeviceAddressKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkDeviceAddress cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetAccelerationStructureDeviceAddressKHR_CALL_INSTANCE)); + CMOCK_vkGetAccelerationStructureDeviceAddressKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureDeviceAddressKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetAccelerationStructureDeviceAddressKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetAccelerationStructureDeviceAddressKHR_CallInstance, cmock_guts_index); + Mock.vkGetAccelerationStructureDeviceAddressKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetAccelerationStructureDeviceAddressKHR_IgnoreBool = (char)1; +} + +void vkGetAccelerationStructureDeviceAddressKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetAccelerationStructureDeviceAddressKHR_IgnoreBool) + Mock.vkGetAccelerationStructureDeviceAddressKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetAccelerationStructureDeviceAddressKHR_CallInstance); + Mock.vkGetAccelerationStructureDeviceAddressKHR_IgnoreBool = (char)0; +} + +void vkGetAccelerationStructureDeviceAddressKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkDeviceAddress cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetAccelerationStructureDeviceAddressKHR_CALL_INSTANCE)); + CMOCK_vkGetAccelerationStructureDeviceAddressKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureDeviceAddressKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetAccelerationStructureDeviceAddressKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetAccelerationStructureDeviceAddressKHR_CallInstance, cmock_guts_index); + Mock.vkGetAccelerationStructureDeviceAddressKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetAccelerationStructureDeviceAddressKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo, VkDeviceAddress cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetAccelerationStructureDeviceAddressKHR_CALL_INSTANCE)); + CMOCK_vkGetAccelerationStructureDeviceAddressKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureDeviceAddressKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetAccelerationStructureDeviceAddressKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetAccelerationStructureDeviceAddressKHR_CallInstance, cmock_guts_index); + Mock.vkGetAccelerationStructureDeviceAddressKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetAccelerationStructureDeviceAddressKHR(cmock_call_instance, device, pInfo); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkDeviceAddress[sizeof(cmock_to_return) == sizeof(VkDeviceAddress) ? 1 : -1])); /* add VkDeviceAddress to :treat_as_array if this causes an error */ +} + +void vkGetAccelerationStructureDeviceAddressKHR_AddCallback(CMOCK_vkGetAccelerationStructureDeviceAddressKHR_CALLBACK Callback) +{ + Mock.vkGetAccelerationStructureDeviceAddressKHR_IgnoreBool = (char)0; + Mock.vkGetAccelerationStructureDeviceAddressKHR_CallbackBool = (char)1; + Mock.vkGetAccelerationStructureDeviceAddressKHR_CallbackFunctionPointer = Callback; +} + +void vkGetAccelerationStructureDeviceAddressKHR_Stub(CMOCK_vkGetAccelerationStructureDeviceAddressKHR_CALLBACK Callback) +{ + Mock.vkGetAccelerationStructureDeviceAddressKHR_IgnoreBool = (char)0; + Mock.vkGetAccelerationStructureDeviceAddressKHR_CallbackBool = (char)0; + Mock.vkGetAccelerationStructureDeviceAddressKHR_CallbackFunctionPointer = Callback; +} + +void vkGetAccelerationStructureDeviceAddressKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetAccelerationStructureDeviceAddressKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureDeviceAddressKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetAccelerationStructureDeviceAddressKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetAccelerationStructureDeviceAddressKHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetAccelerationStructureDeviceAddressKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureDeviceAddressKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetAccelerationStructureDeviceAddressKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pInfo = 1; +} + +void vkCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdWriteAccelerationStructuresPropertiesKHR); + cmock_call_instance = (CMOCK_vkCmdWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_CallInstance); + Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_CallInstance); + if (Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_CallbackBool && + Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_CallbackFunctionPointer(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery, Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteAccelerationStructuresPropertiesKHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_accelerationStructureCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteAccelerationStructuresPropertiesKHR,CMockString_accelerationStructureCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_accelerationStructureCount, accelerationStructureCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAccelerationStructures) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteAccelerationStructuresPropertiesKHR,CMockString_pAccelerationStructures); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAccelerationStructures), (void*)(pAccelerationStructures), sizeof(const VkAccelerationStructureKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queryType) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteAccelerationStructuresPropertiesKHR,CMockString_queryType); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queryType), (void*)(&queryType), sizeof(VkQueryType), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_queryPool) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteAccelerationStructuresPropertiesKHR,CMockString_queryPool); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), sizeof(VkQueryPool), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstQuery) + { + UNITY_SET_DETAILS(CMockString_vkCmdWriteAccelerationStructuresPropertiesKHR,CMockString_firstQuery); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstQuery, firstQuery, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_CallbackFunctionPointer(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery, Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdWriteAccelerationStructuresPropertiesKHR(CMOCK_vkCmdWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); +void CMockExpectParameters_vkCmdWriteAccelerationStructuresPropertiesKHR(CMOCK_vkCmdWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_accelerationStructureCount = accelerationStructureCount; + cmock_call_instance->IgnoreArg_accelerationStructureCount = 0; + cmock_call_instance->Expected_pAccelerationStructures = pAccelerationStructures; + cmock_call_instance->IgnoreArg_pAccelerationStructures = 0; + memcpy((void*)(&cmock_call_instance->Expected_queryType), (void*)(&queryType), + sizeof(VkQueryType[sizeof(queryType) == sizeof(VkQueryType) ? 1 : -1])); /* add VkQueryType to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queryType = 0; + memcpy((void*)(&cmock_call_instance->Expected_queryPool), (void*)(&queryPool), + sizeof(VkQueryPool[sizeof(queryPool) == sizeof(VkQueryPool) ? 1 : -1])); /* add VkQueryPool to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_queryPool = 0; + cmock_call_instance->Expected_firstQuery = firstQuery; + cmock_call_instance->IgnoreArg_firstQuery = 0; +} + +void vkCmdWriteAccelerationStructuresPropertiesKHR_CMockIgnore(void) +{ + Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_IgnoreBool = (char)1; +} + +void vkCmdWriteAccelerationStructuresPropertiesKHR_CMockStopIgnore(void) +{ + Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_IgnoreBool = (char)0; +} + +void vkCmdWriteAccelerationStructuresPropertiesKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE)); + CMOCK_vkCmdWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_CallInstance, cmock_guts_index); + Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdWriteAccelerationStructuresPropertiesKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE)); + CMOCK_vkCmdWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_CallInstance, cmock_guts_index); + Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdWriteAccelerationStructuresPropertiesKHR(cmock_call_instance, commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); +} + +void vkCmdWriteAccelerationStructuresPropertiesKHR_AddCallback(CMOCK_vkCmdWriteAccelerationStructuresPropertiesKHR_CALLBACK Callback) +{ + Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_IgnoreBool = (char)0; + Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_CallbackBool = (char)1; + Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdWriteAccelerationStructuresPropertiesKHR_Stub(CMOCK_vkCmdWriteAccelerationStructuresPropertiesKHR_CALLBACK Callback) +{ + Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_IgnoreBool = (char)0; + Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_CallbackBool = (char)0; + Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_accelerationStructureCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_accelerationStructureCount = 1; +} + +void vkCmdWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_pAccelerationStructures(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAccelerationStructures = 1; +} + +void vkCmdWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_queryType(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queryType = 1; +} + +void vkCmdWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_queryPool = 1; +} + +void vkCmdWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_firstQuery(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdWriteAccelerationStructuresPropertiesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdWriteAccelerationStructuresPropertiesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstQuery = 1; +} + +void vkGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetDeviceAccelerationStructureCompatibilityKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetDeviceAccelerationStructureCompatibilityKHR); + cmock_call_instance = (CMOCK_vkGetDeviceAccelerationStructureCompatibilityKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_CallInstance); + Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_CallInstance); + if (Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_CallbackBool && + Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_CallbackFunctionPointer(device, pVersionInfo, pCompatibility, Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceAccelerationStructureCompatibilityKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pVersionInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceAccelerationStructureCompatibilityKHR,CMockString_pVersionInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pVersionInfo), (void*)(pVersionInfo), sizeof(const VkAccelerationStructureVersionInfoKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCompatibility) + { + UNITY_SET_DETAILS(CMockString_vkGetDeviceAccelerationStructureCompatibilityKHR,CMockString_pCompatibility); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCompatibility), (void*)(pCompatibility), sizeof(VkAccelerationStructureCompatibilityKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_CallbackFunctionPointer(device, pVersionInfo, pCompatibility, Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pCompatibility_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pCompatibility, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pCompatibility, (const void*)cmock_call_instance->ReturnThruPtr_pCompatibility_Val, + cmock_call_instance->ReturnThruPtr_pCompatibility_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetDeviceAccelerationStructureCompatibilityKHR(CMOCK_vkGetDeviceAccelerationStructureCompatibilityKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility); +void CMockExpectParameters_vkGetDeviceAccelerationStructureCompatibilityKHR(CMOCK_vkGetDeviceAccelerationStructureCompatibilityKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + cmock_call_instance->Expected_pVersionInfo = pVersionInfo; + cmock_call_instance->IgnoreArg_pVersionInfo = 0; + cmock_call_instance->Expected_pCompatibility = pCompatibility; + cmock_call_instance->IgnoreArg_pCompatibility = 0; + cmock_call_instance->ReturnThruPtr_pCompatibility_Used = 0; +} + +void vkGetDeviceAccelerationStructureCompatibilityKHR_CMockIgnore(void) +{ + Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_IgnoreBool = (char)1; +} + +void vkGetDeviceAccelerationStructureCompatibilityKHR_CMockStopIgnore(void) +{ + Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_IgnoreBool = (char)0; +} + +void vkGetDeviceAccelerationStructureCompatibilityKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceAccelerationStructureCompatibilityKHR_CALL_INSTANCE)); + CMOCK_vkGetDeviceAccelerationStructureCompatibilityKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceAccelerationStructureCompatibilityKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_CallInstance, cmock_guts_index); + Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetDeviceAccelerationStructureCompatibilityKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetDeviceAccelerationStructureCompatibilityKHR_CALL_INSTANCE)); + CMOCK_vkGetDeviceAccelerationStructureCompatibilityKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceAccelerationStructureCompatibilityKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_CallInstance, cmock_guts_index); + Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetDeviceAccelerationStructureCompatibilityKHR(cmock_call_instance, device, pVersionInfo, pCompatibility); +} + +void vkGetDeviceAccelerationStructureCompatibilityKHR_AddCallback(CMOCK_vkGetDeviceAccelerationStructureCompatibilityKHR_CALLBACK Callback) +{ + Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_IgnoreBool = (char)0; + Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_CallbackBool = (char)1; + Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceAccelerationStructureCompatibilityKHR_Stub(CMOCK_vkGetDeviceAccelerationStructureCompatibilityKHR_CALLBACK Callback) +{ + Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_IgnoreBool = (char)0; + Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_CallbackBool = (char)0; + Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_CallbackFunctionPointer = Callback; +} + +void vkGetDeviceAccelerationStructureCompatibilityKHR_CMockReturnMemThruPtr_pCompatibility(UNITY_LINE_TYPE cmock_line, VkAccelerationStructureCompatibilityKHR const* pCompatibility, size_t cmock_size) +{ + CMOCK_vkGetDeviceAccelerationStructureCompatibilityKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceAccelerationStructureCompatibilityKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pCompatibility_Used = 1; + cmock_call_instance->ReturnThruPtr_pCompatibility_Val = pCompatibility; + cmock_call_instance->ReturnThruPtr_pCompatibility_Size = cmock_size; +} + +void vkGetDeviceAccelerationStructureCompatibilityKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceAccelerationStructureCompatibilityKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceAccelerationStructureCompatibilityKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetDeviceAccelerationStructureCompatibilityKHR_CMockIgnoreArg_pVersionInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceAccelerationStructureCompatibilityKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceAccelerationStructureCompatibilityKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pVersionInfo = 1; +} + +void vkGetDeviceAccelerationStructureCompatibilityKHR_CMockIgnoreArg_pCompatibility(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetDeviceAccelerationStructureCompatibilityKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetDeviceAccelerationStructureCompatibilityKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetDeviceAccelerationStructureCompatibilityKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCompatibility = 1; +} + +void vkGetAccelerationStructureBuildSizesKHR(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetAccelerationStructureBuildSizesKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetAccelerationStructureBuildSizesKHR); + cmock_call_instance = (CMOCK_vkGetAccelerationStructureBuildSizesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetAccelerationStructureBuildSizesKHR_CallInstance); + Mock.vkGetAccelerationStructureBuildSizesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetAccelerationStructureBuildSizesKHR_CallInstance); + if (Mock.vkGetAccelerationStructureBuildSizesKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkGetAccelerationStructureBuildSizesKHR_CallbackBool && + Mock.vkGetAccelerationStructureBuildSizesKHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetAccelerationStructureBuildSizesKHR_CallbackFunctionPointer(device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo, Mock.vkGetAccelerationStructureBuildSizesKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetAccelerationStructureBuildSizesKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_buildType) + { + UNITY_SET_DETAILS(CMockString_vkGetAccelerationStructureBuildSizesKHR,CMockString_buildType); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_buildType), (void*)(&buildType), sizeof(VkAccelerationStructureBuildTypeKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pBuildInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetAccelerationStructureBuildSizesKHR,CMockString_pBuildInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pBuildInfo), (void*)(pBuildInfo), sizeof(const VkAccelerationStructureBuildGeometryInfoKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMaxPrimitiveCounts) + { + UNITY_SET_DETAILS(CMockString_vkGetAccelerationStructureBuildSizesKHR,CMockString_pMaxPrimitiveCounts); + if (cmock_call_instance->Expected_pMaxPrimitiveCounts == NULL) + { UNITY_TEST_ASSERT_NULL(pMaxPrimitiveCounts, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pMaxPrimitiveCounts, pMaxPrimitiveCounts, 1, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pSizeInfo) + { + UNITY_SET_DETAILS(CMockString_vkGetAccelerationStructureBuildSizesKHR,CMockString_pSizeInfo); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pSizeInfo), (void*)(pSizeInfo), sizeof(VkAccelerationStructureBuildSizesInfoKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetAccelerationStructureBuildSizesKHR_CallbackFunctionPointer != NULL) + { + Mock.vkGetAccelerationStructureBuildSizesKHR_CallbackFunctionPointer(device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo, Mock.vkGetAccelerationStructureBuildSizesKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pSizeInfo_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pSizeInfo, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pSizeInfo, (const void*)cmock_call_instance->ReturnThruPtr_pSizeInfo_Val, + cmock_call_instance->ReturnThruPtr_pSizeInfo_Size); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkGetAccelerationStructureBuildSizesKHR(CMOCK_vkGetAccelerationStructureBuildSizesKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo); +void CMockExpectParameters_vkGetAccelerationStructureBuildSizesKHR(CMOCK_vkGetAccelerationStructureBuildSizesKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_buildType), (void*)(&buildType), + sizeof(VkAccelerationStructureBuildTypeKHR[sizeof(buildType) == sizeof(VkAccelerationStructureBuildTypeKHR) ? 1 : -1])); /* add VkAccelerationStructureBuildTypeKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_buildType = 0; + cmock_call_instance->Expected_pBuildInfo = pBuildInfo; + cmock_call_instance->IgnoreArg_pBuildInfo = 0; + cmock_call_instance->Expected_pMaxPrimitiveCounts = pMaxPrimitiveCounts; + cmock_call_instance->IgnoreArg_pMaxPrimitiveCounts = 0; + cmock_call_instance->Expected_pSizeInfo = pSizeInfo; + cmock_call_instance->IgnoreArg_pSizeInfo = 0; + cmock_call_instance->ReturnThruPtr_pSizeInfo_Used = 0; +} + +void vkGetAccelerationStructureBuildSizesKHR_CMockIgnore(void) +{ + Mock.vkGetAccelerationStructureBuildSizesKHR_IgnoreBool = (char)1; +} + +void vkGetAccelerationStructureBuildSizesKHR_CMockStopIgnore(void) +{ + Mock.vkGetAccelerationStructureBuildSizesKHR_IgnoreBool = (char)0; +} + +void vkGetAccelerationStructureBuildSizesKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetAccelerationStructureBuildSizesKHR_CALL_INSTANCE)); + CMOCK_vkGetAccelerationStructureBuildSizesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureBuildSizesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetAccelerationStructureBuildSizesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetAccelerationStructureBuildSizesKHR_CallInstance, cmock_guts_index); + Mock.vkGetAccelerationStructureBuildSizesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetAccelerationStructureBuildSizesKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetAccelerationStructureBuildSizesKHR_CALL_INSTANCE)); + CMOCK_vkGetAccelerationStructureBuildSizesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureBuildSizesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetAccelerationStructureBuildSizesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetAccelerationStructureBuildSizesKHR_CallInstance, cmock_guts_index); + Mock.vkGetAccelerationStructureBuildSizesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetAccelerationStructureBuildSizesKHR(cmock_call_instance, device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo); +} + +void vkGetAccelerationStructureBuildSizesKHR_AddCallback(CMOCK_vkGetAccelerationStructureBuildSizesKHR_CALLBACK Callback) +{ + Mock.vkGetAccelerationStructureBuildSizesKHR_IgnoreBool = (char)0; + Mock.vkGetAccelerationStructureBuildSizesKHR_CallbackBool = (char)1; + Mock.vkGetAccelerationStructureBuildSizesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetAccelerationStructureBuildSizesKHR_Stub(CMOCK_vkGetAccelerationStructureBuildSizesKHR_CALLBACK Callback) +{ + Mock.vkGetAccelerationStructureBuildSizesKHR_IgnoreBool = (char)0; + Mock.vkGetAccelerationStructureBuildSizesKHR_CallbackBool = (char)0; + Mock.vkGetAccelerationStructureBuildSizesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetAccelerationStructureBuildSizesKHR_CMockReturnMemThruPtr_pSizeInfo(UNITY_LINE_TYPE cmock_line, VkAccelerationStructureBuildSizesInfoKHR const* pSizeInfo, size_t cmock_size) +{ + CMOCK_vkGetAccelerationStructureBuildSizesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureBuildSizesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetAccelerationStructureBuildSizesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pSizeInfo_Used = 1; + cmock_call_instance->ReturnThruPtr_pSizeInfo_Val = pSizeInfo; + cmock_call_instance->ReturnThruPtr_pSizeInfo_Size = cmock_size; +} + +void vkGetAccelerationStructureBuildSizesKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetAccelerationStructureBuildSizesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureBuildSizesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetAccelerationStructureBuildSizesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetAccelerationStructureBuildSizesKHR_CMockIgnoreArg_buildType(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetAccelerationStructureBuildSizesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureBuildSizesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetAccelerationStructureBuildSizesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_buildType = 1; +} + +void vkGetAccelerationStructureBuildSizesKHR_CMockIgnoreArg_pBuildInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetAccelerationStructureBuildSizesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureBuildSizesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetAccelerationStructureBuildSizesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pBuildInfo = 1; +} + +void vkGetAccelerationStructureBuildSizesKHR_CMockIgnoreArg_pMaxPrimitiveCounts(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetAccelerationStructureBuildSizesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureBuildSizesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetAccelerationStructureBuildSizesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMaxPrimitiveCounts = 1; +} + +void vkGetAccelerationStructureBuildSizesKHR_CMockIgnoreArg_pSizeInfo(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetAccelerationStructureBuildSizesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetAccelerationStructureBuildSizesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetAccelerationStructureBuildSizesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pSizeInfo = 1; +} + +void vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdTraceRaysKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdTraceRaysKHR); + cmock_call_instance = (CMOCK_vkCmdTraceRaysKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdTraceRaysKHR_CallInstance); + Mock.vkCmdTraceRaysKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdTraceRaysKHR_CallInstance); + if (Mock.vkCmdTraceRaysKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdTraceRaysKHR_CallbackBool && + Mock.vkCmdTraceRaysKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdTraceRaysKHR_CallbackFunctionPointer(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth, Mock.vkCmdTraceRaysKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysKHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pRaygenShaderBindingTable) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysKHR,CMockString_pRaygenShaderBindingTable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pRaygenShaderBindingTable), (void*)(pRaygenShaderBindingTable), sizeof(const VkStridedDeviceAddressRegionKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMissShaderBindingTable) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysKHR,CMockString_pMissShaderBindingTable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMissShaderBindingTable), (void*)(pMissShaderBindingTable), sizeof(const VkStridedDeviceAddressRegionKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pHitShaderBindingTable) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysKHR,CMockString_pHitShaderBindingTable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pHitShaderBindingTable), (void*)(pHitShaderBindingTable), sizeof(const VkStridedDeviceAddressRegionKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCallableShaderBindingTable) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysKHR,CMockString_pCallableShaderBindingTable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCallableShaderBindingTable), (void*)(pCallableShaderBindingTable), sizeof(const VkStridedDeviceAddressRegionKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_width) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysKHR,CMockString_width); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_width, width, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_height) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysKHR,CMockString_height); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_height, height, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_depth) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysKHR,CMockString_depth); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_depth, depth, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdTraceRaysKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdTraceRaysKHR_CallbackFunctionPointer(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth, Mock.vkCmdTraceRaysKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdTraceRaysKHR(CMOCK_vkCmdTraceRaysKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth); +void CMockExpectParameters_vkCmdTraceRaysKHR(CMOCK_vkCmdTraceRaysKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pRaygenShaderBindingTable = pRaygenShaderBindingTable; + cmock_call_instance->IgnoreArg_pRaygenShaderBindingTable = 0; + cmock_call_instance->Expected_pMissShaderBindingTable = pMissShaderBindingTable; + cmock_call_instance->IgnoreArg_pMissShaderBindingTable = 0; + cmock_call_instance->Expected_pHitShaderBindingTable = pHitShaderBindingTable; + cmock_call_instance->IgnoreArg_pHitShaderBindingTable = 0; + cmock_call_instance->Expected_pCallableShaderBindingTable = pCallableShaderBindingTable; + cmock_call_instance->IgnoreArg_pCallableShaderBindingTable = 0; + cmock_call_instance->Expected_width = width; + cmock_call_instance->IgnoreArg_width = 0; + cmock_call_instance->Expected_height = height; + cmock_call_instance->IgnoreArg_height = 0; + cmock_call_instance->Expected_depth = depth; + cmock_call_instance->IgnoreArg_depth = 0; +} + +void vkCmdTraceRaysKHR_CMockIgnore(void) +{ + Mock.vkCmdTraceRaysKHR_IgnoreBool = (char)1; +} + +void vkCmdTraceRaysKHR_CMockStopIgnore(void) +{ + Mock.vkCmdTraceRaysKHR_IgnoreBool = (char)0; +} + +void vkCmdTraceRaysKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdTraceRaysKHR_CALL_INSTANCE)); + CMOCK_vkCmdTraceRaysKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdTraceRaysKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdTraceRaysKHR_CallInstance, cmock_guts_index); + Mock.vkCmdTraceRaysKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdTraceRaysKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdTraceRaysKHR_CALL_INSTANCE)); + CMOCK_vkCmdTraceRaysKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdTraceRaysKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdTraceRaysKHR_CallInstance, cmock_guts_index); + Mock.vkCmdTraceRaysKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdTraceRaysKHR(cmock_call_instance, commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth); +} + +void vkCmdTraceRaysKHR_AddCallback(CMOCK_vkCmdTraceRaysKHR_CALLBACK Callback) +{ + Mock.vkCmdTraceRaysKHR_IgnoreBool = (char)0; + Mock.vkCmdTraceRaysKHR_CallbackBool = (char)1; + Mock.vkCmdTraceRaysKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdTraceRaysKHR_Stub(CMOCK_vkCmdTraceRaysKHR_CALLBACK Callback) +{ + Mock.vkCmdTraceRaysKHR_IgnoreBool = (char)0; + Mock.vkCmdTraceRaysKHR_CallbackBool = (char)0; + Mock.vkCmdTraceRaysKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdTraceRaysKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdTraceRaysKHR_CMockIgnoreArg_pRaygenShaderBindingTable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pRaygenShaderBindingTable = 1; +} + +void vkCmdTraceRaysKHR_CMockIgnoreArg_pMissShaderBindingTable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMissShaderBindingTable = 1; +} + +void vkCmdTraceRaysKHR_CMockIgnoreArg_pHitShaderBindingTable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pHitShaderBindingTable = 1; +} + +void vkCmdTraceRaysKHR_CMockIgnoreArg_pCallableShaderBindingTable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCallableShaderBindingTable = 1; +} + +void vkCmdTraceRaysKHR_CMockIgnoreArg_width(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_width = 1; +} + +void vkCmdTraceRaysKHR_CMockIgnoreArg_height(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_height = 1; +} + +void vkCmdTraceRaysKHR_CMockIgnoreArg_depth(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_depth = 1; +} + +VkResult vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCreateRayTracingPipelinesKHR); + cmock_call_instance = (CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCreateRayTracingPipelinesKHR_CallInstance); + Mock.vkCreateRayTracingPipelinesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCreateRayTracingPipelinesKHR_CallInstance); + if (Mock.vkCreateRayTracingPipelinesKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkCreateRayTracingPipelinesKHR_FinalReturn; + memcpy((void*)(&Mock.vkCreateRayTracingPipelinesKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkCreateRayTracingPipelinesKHR_CallbackBool && + Mock.vkCreateRayTracingPipelinesKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkCreateRayTracingPipelinesKHR_CallbackFunctionPointer(device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, Mock.vkCreateRayTracingPipelinesKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkCreateRayTracingPipelinesKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_deferredOperation) + { + UNITY_SET_DETAILS(CMockString_vkCreateRayTracingPipelinesKHR,CMockString_deferredOperation); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_deferredOperation), (void*)(&deferredOperation), sizeof(VkDeferredOperationKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pipelineCache) + { + UNITY_SET_DETAILS(CMockString_vkCreateRayTracingPipelinesKHR,CMockString_pipelineCache); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_pipelineCache), (void*)(&pipelineCache), sizeof(VkPipelineCache), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_createInfoCount) + { + UNITY_SET_DETAILS(CMockString_vkCreateRayTracingPipelinesKHR,CMockString_createInfoCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_createInfoCount, createInfoCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCreateInfos) + { + UNITY_SET_DETAILS(CMockString_vkCreateRayTracingPipelinesKHR,CMockString_pCreateInfos); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCreateInfos), (void*)(pCreateInfos), sizeof(const VkRayTracingPipelineCreateInfoKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pAllocator) + { + UNITY_SET_DETAILS(CMockString_vkCreateRayTracingPipelinesKHR,CMockString_pAllocator); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pAllocator), (void*)(pAllocator), sizeof(const VkAllocationCallbacks), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pPipelines) + { + UNITY_SET_DETAILS(CMockString_vkCreateRayTracingPipelinesKHR,CMockString_pPipelines); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pPipelines), (void*)(pPipelines), sizeof(VkPipeline), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCreateRayTracingPipelinesKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkCreateRayTracingPipelinesKHR_CallbackFunctionPointer(device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, Mock.vkCreateRayTracingPipelinesKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pPipelines_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pPipelines, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pPipelines, (const void*)cmock_call_instance->ReturnThruPtr_pPipelines_Val, + cmock_call_instance->ReturnThruPtr_pPipelines_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkCreateRayTracingPipelinesKHR(CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +void CMockExpectParameters_vkCreateRayTracingPipelinesKHR(CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_deferredOperation), (void*)(&deferredOperation), + sizeof(VkDeferredOperationKHR[sizeof(deferredOperation) == sizeof(VkDeferredOperationKHR) ? 1 : -1])); /* add VkDeferredOperationKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_deferredOperation = 0; + memcpy((void*)(&cmock_call_instance->Expected_pipelineCache), (void*)(&pipelineCache), + sizeof(VkPipelineCache[sizeof(pipelineCache) == sizeof(VkPipelineCache) ? 1 : -1])); /* add VkPipelineCache to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_pipelineCache = 0; + cmock_call_instance->Expected_createInfoCount = createInfoCount; + cmock_call_instance->IgnoreArg_createInfoCount = 0; + cmock_call_instance->Expected_pCreateInfos = pCreateInfos; + cmock_call_instance->IgnoreArg_pCreateInfos = 0; + cmock_call_instance->Expected_pAllocator = pAllocator; + cmock_call_instance->IgnoreArg_pAllocator = 0; + cmock_call_instance->Expected_pPipelines = pPipelines; + cmock_call_instance->IgnoreArg_pPipelines = 0; + cmock_call_instance->ReturnThruPtr_pPipelines_Used = 0; +} + +void vkCreateRayTracingPipelinesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE)); + CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateRayTracingPipelinesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateRayTracingPipelinesKHR_CallInstance, cmock_guts_index); + Mock.vkCreateRayTracingPipelinesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkCreateRayTracingPipelinesKHR_IgnoreBool = (char)1; +} + +void vkCreateRayTracingPipelinesKHR_CMockStopIgnore(void) +{ + if(Mock.vkCreateRayTracingPipelinesKHR_IgnoreBool) + Mock.vkCreateRayTracingPipelinesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCreateRayTracingPipelinesKHR_CallInstance); + Mock.vkCreateRayTracingPipelinesKHR_IgnoreBool = (char)0; +} + +void vkCreateRayTracingPipelinesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE)); + CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateRayTracingPipelinesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateRayTracingPipelinesKHR_CallInstance, cmock_guts_index); + Mock.vkCreateRayTracingPipelinesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCreateRayTracingPipelinesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE)); + CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCreateRayTracingPipelinesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCreateRayTracingPipelinesKHR_CallInstance, cmock_guts_index); + Mock.vkCreateRayTracingPipelinesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCreateRayTracingPipelinesKHR(cmock_call_instance, device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkCreateRayTracingPipelinesKHR_AddCallback(CMOCK_vkCreateRayTracingPipelinesKHR_CALLBACK Callback) +{ + Mock.vkCreateRayTracingPipelinesKHR_IgnoreBool = (char)0; + Mock.vkCreateRayTracingPipelinesKHR_CallbackBool = (char)1; + Mock.vkCreateRayTracingPipelinesKHR_CallbackFunctionPointer = Callback; +} + +void vkCreateRayTracingPipelinesKHR_Stub(CMOCK_vkCreateRayTracingPipelinesKHR_CALLBACK Callback) +{ + Mock.vkCreateRayTracingPipelinesKHR_IgnoreBool = (char)0; + Mock.vkCreateRayTracingPipelinesKHR_CallbackBool = (char)0; + Mock.vkCreateRayTracingPipelinesKHR_CallbackFunctionPointer = Callback; +} + +void vkCreateRayTracingPipelinesKHR_CMockReturnMemThruPtr_pPipelines(UNITY_LINE_TYPE cmock_line, VkPipeline const* pPipelines, size_t cmock_size) +{ + CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateRayTracingPipelinesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pPipelines_Used = 1; + cmock_call_instance->ReturnThruPtr_pPipelines_Val = pPipelines; + cmock_call_instance->ReturnThruPtr_pPipelines_Size = cmock_size; +} + +void vkCreateRayTracingPipelinesKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateRayTracingPipelinesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkCreateRayTracingPipelinesKHR_CMockIgnoreArg_deferredOperation(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateRayTracingPipelinesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_deferredOperation = 1; +} + +void vkCreateRayTracingPipelinesKHR_CMockIgnoreArg_pipelineCache(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateRayTracingPipelinesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pipelineCache = 1; +} + +void vkCreateRayTracingPipelinesKHR_CMockIgnoreArg_createInfoCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateRayTracingPipelinesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_createInfoCount = 1; +} + +void vkCreateRayTracingPipelinesKHR_CMockIgnoreArg_pCreateInfos(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateRayTracingPipelinesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCreateInfos = 1; +} + +void vkCreateRayTracingPipelinesKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateRayTracingPipelinesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pAllocator = 1; +} + +void vkCreateRayTracingPipelinesKHR_CMockIgnoreArg_pPipelines(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCreateRayTracingPipelinesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCreateRayTracingPipelinesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pPipelines = 1; +} + +VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR); + cmock_call_instance = (CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallInstance); + Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallInstance); + if (Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkResult[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallbackBool && + Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallbackFunctionPointer != NULL) + { + VkResult cmock_cb_ret = Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallbackFunctionPointer(device, pipeline, firstGroup, groupCount, dataSize, pData, Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pipeline) + { + UNITY_SET_DETAILS(CMockString_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,CMockString_pipeline); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_pipeline), (void*)(&pipeline), sizeof(VkPipeline), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_firstGroup) + { + UNITY_SET_DETAILS(CMockString_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,CMockString_firstGroup); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_firstGroup, firstGroup, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_groupCount) + { + UNITY_SET_DETAILS(CMockString_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,CMockString_groupCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_groupCount, groupCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_dataSize) + { + UNITY_SET_DETAILS(CMockString_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,CMockString_dataSize); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_dataSize), (void*)(&dataSize), sizeof(size_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pData) + { + UNITY_SET_DETAILS(CMockString_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,CMockString_pData); + if (cmock_call_instance->Expected_pData == NULL) + { UNITY_TEST_ASSERT_NULL(pData, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(cmock_call_instance->Expected_pData, pData, 1, cmock_line, CMockStringMismatch); } + } + } + if (Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallbackFunctionPointer(device, pipeline, firstGroup, groupCount, dataSize, pData, Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pData_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pData, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pData, (const void*)cmock_call_instance->ReturnThruPtr_pData_Val, + cmock_call_instance->ReturnThruPtr_pData_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData); +void CMockExpectParameters_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_pipeline), (void*)(&pipeline), + sizeof(VkPipeline[sizeof(pipeline) == sizeof(VkPipeline) ? 1 : -1])); /* add VkPipeline to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_pipeline = 0; + cmock_call_instance->Expected_firstGroup = firstGroup; + cmock_call_instance->IgnoreArg_firstGroup = 0; + cmock_call_instance->Expected_groupCount = groupCount; + cmock_call_instance->IgnoreArg_groupCount = 0; + memcpy((void*)(&cmock_call_instance->Expected_dataSize), (void*)(&dataSize), + sizeof(size_t[sizeof(dataSize) == sizeof(size_t) ? 1 : -1])); /* add size_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_dataSize = 0; + cmock_call_instance->Expected_pData = pData; + cmock_call_instance->IgnoreArg_pData = 0; + cmock_call_instance->ReturnThruPtr_pData_Used = 0; +} + +void vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALL_INSTANCE)); + CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallInstance, cmock_guts_index); + Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_IgnoreBool = (char)1; +} + +void vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_IgnoreBool) + Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallInstance); + Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_IgnoreBool = (char)0; +} + +void vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALL_INSTANCE)); + CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallInstance, cmock_guts_index); + Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, VkResult cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALL_INSTANCE)); + CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallInstance, cmock_guts_index); + Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(cmock_call_instance, device, pipeline, firstGroup, groupCount, dataSize, pData); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkResult[sizeof(cmock_to_return) == sizeof(VkResult) ? 1 : -1])); /* add VkResult to :treat_as_array if this causes an error */ +} + +void vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_AddCallback(CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALLBACK Callback) +{ + Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_IgnoreBool = (char)0; + Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallbackBool = (char)1; + Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_Stub(CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALLBACK Callback) +{ + Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_IgnoreBool = (char)0; + Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallbackBool = (char)0; + Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallbackFunctionPointer = Callback; +} + +void vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, void const* pData, size_t cmock_size) +{ + CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pData_Used = 1; + cmock_call_instance->ReturnThruPtr_pData_Val = pData; + cmock_call_instance->ReturnThruPtr_pData_Size = cmock_size; +} + +void vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockIgnoreArg_pipeline(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pipeline = 1; +} + +void vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockIgnoreArg_firstGroup(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_firstGroup = 1; +} + +void vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockIgnoreArg_groupCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_groupCount = 1; +} + +void vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockIgnoreArg_dataSize(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_dataSize = 1; +} + +void vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pData = 1; +} + +void vkCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdTraceRaysIndirectKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdTraceRaysIndirectKHR); + cmock_call_instance = (CMOCK_vkCmdTraceRaysIndirectKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdTraceRaysIndirectKHR_CallInstance); + Mock.vkCmdTraceRaysIndirectKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdTraceRaysIndirectKHR_CallInstance); + if (Mock.vkCmdTraceRaysIndirectKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdTraceRaysIndirectKHR_CallbackBool && + Mock.vkCmdTraceRaysIndirectKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdTraceRaysIndirectKHR_CallbackFunctionPointer(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress, Mock.vkCmdTraceRaysIndirectKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysIndirectKHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pRaygenShaderBindingTable) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysIndirectKHR,CMockString_pRaygenShaderBindingTable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pRaygenShaderBindingTable), (void*)(pRaygenShaderBindingTable), sizeof(const VkStridedDeviceAddressRegionKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pMissShaderBindingTable) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysIndirectKHR,CMockString_pMissShaderBindingTable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pMissShaderBindingTable), (void*)(pMissShaderBindingTable), sizeof(const VkStridedDeviceAddressRegionKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pHitShaderBindingTable) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysIndirectKHR,CMockString_pHitShaderBindingTable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pHitShaderBindingTable), (void*)(pHitShaderBindingTable), sizeof(const VkStridedDeviceAddressRegionKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pCallableShaderBindingTable) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysIndirectKHR,CMockString_pCallableShaderBindingTable); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(cmock_call_instance->Expected_pCallableShaderBindingTable), (void*)(pCallableShaderBindingTable), sizeof(const VkStridedDeviceAddressRegionKHR), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_indirectDeviceAddress) + { + UNITY_SET_DETAILS(CMockString_vkCmdTraceRaysIndirectKHR,CMockString_indirectDeviceAddress); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_indirectDeviceAddress), (void*)(&indirectDeviceAddress), sizeof(VkDeviceAddress), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdTraceRaysIndirectKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdTraceRaysIndirectKHR_CallbackFunctionPointer(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress, Mock.vkCmdTraceRaysIndirectKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdTraceRaysIndirectKHR(CMOCK_vkCmdTraceRaysIndirectKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress); +void CMockExpectParameters_vkCmdTraceRaysIndirectKHR(CMOCK_vkCmdTraceRaysIndirectKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pRaygenShaderBindingTable = pRaygenShaderBindingTable; + cmock_call_instance->IgnoreArg_pRaygenShaderBindingTable = 0; + cmock_call_instance->Expected_pMissShaderBindingTable = pMissShaderBindingTable; + cmock_call_instance->IgnoreArg_pMissShaderBindingTable = 0; + cmock_call_instance->Expected_pHitShaderBindingTable = pHitShaderBindingTable; + cmock_call_instance->IgnoreArg_pHitShaderBindingTable = 0; + cmock_call_instance->Expected_pCallableShaderBindingTable = pCallableShaderBindingTable; + cmock_call_instance->IgnoreArg_pCallableShaderBindingTable = 0; + memcpy((void*)(&cmock_call_instance->Expected_indirectDeviceAddress), (void*)(&indirectDeviceAddress), + sizeof(VkDeviceAddress[sizeof(indirectDeviceAddress) == sizeof(VkDeviceAddress) ? 1 : -1])); /* add VkDeviceAddress to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_indirectDeviceAddress = 0; +} + +void vkCmdTraceRaysIndirectKHR_CMockIgnore(void) +{ + Mock.vkCmdTraceRaysIndirectKHR_IgnoreBool = (char)1; +} + +void vkCmdTraceRaysIndirectKHR_CMockStopIgnore(void) +{ + Mock.vkCmdTraceRaysIndirectKHR_IgnoreBool = (char)0; +} + +void vkCmdTraceRaysIndirectKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdTraceRaysIndirectKHR_CALL_INSTANCE)); + CMOCK_vkCmdTraceRaysIndirectKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysIndirectKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdTraceRaysIndirectKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdTraceRaysIndirectKHR_CallInstance, cmock_guts_index); + Mock.vkCmdTraceRaysIndirectKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdTraceRaysIndirectKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdTraceRaysIndirectKHR_CALL_INSTANCE)); + CMOCK_vkCmdTraceRaysIndirectKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysIndirectKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdTraceRaysIndirectKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdTraceRaysIndirectKHR_CallInstance, cmock_guts_index); + Mock.vkCmdTraceRaysIndirectKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdTraceRaysIndirectKHR(cmock_call_instance, commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress); +} + +void vkCmdTraceRaysIndirectKHR_AddCallback(CMOCK_vkCmdTraceRaysIndirectKHR_CALLBACK Callback) +{ + Mock.vkCmdTraceRaysIndirectKHR_IgnoreBool = (char)0; + Mock.vkCmdTraceRaysIndirectKHR_CallbackBool = (char)1; + Mock.vkCmdTraceRaysIndirectKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdTraceRaysIndirectKHR_Stub(CMOCK_vkCmdTraceRaysIndirectKHR_CALLBACK Callback) +{ + Mock.vkCmdTraceRaysIndirectKHR_IgnoreBool = (char)0; + Mock.vkCmdTraceRaysIndirectKHR_CallbackBool = (char)0; + Mock.vkCmdTraceRaysIndirectKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdTraceRaysIndirectKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysIndirectKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysIndirectKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysIndirectKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdTraceRaysIndirectKHR_CMockIgnoreArg_pRaygenShaderBindingTable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysIndirectKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysIndirectKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysIndirectKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pRaygenShaderBindingTable = 1; +} + +void vkCmdTraceRaysIndirectKHR_CMockIgnoreArg_pMissShaderBindingTable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysIndirectKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysIndirectKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysIndirectKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pMissShaderBindingTable = 1; +} + +void vkCmdTraceRaysIndirectKHR_CMockIgnoreArg_pHitShaderBindingTable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysIndirectKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysIndirectKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysIndirectKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pHitShaderBindingTable = 1; +} + +void vkCmdTraceRaysIndirectKHR_CMockIgnoreArg_pCallableShaderBindingTable(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysIndirectKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysIndirectKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysIndirectKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pCallableShaderBindingTable = 1; +} + +void vkCmdTraceRaysIndirectKHR_CMockIgnoreArg_indirectDeviceAddress(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdTraceRaysIndirectKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdTraceRaysIndirectKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdTraceRaysIndirectKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_indirectDeviceAddress = 1; +} + +VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkGetRayTracingShaderGroupStackSizeKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkGetRayTracingShaderGroupStackSizeKHR); + cmock_call_instance = (CMOCK_vkGetRayTracingShaderGroupStackSizeKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkGetRayTracingShaderGroupStackSizeKHR_CallInstance); + Mock.vkGetRayTracingShaderGroupStackSizeKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetRayTracingShaderGroupStackSizeKHR_CallInstance); + if (Mock.vkGetRayTracingShaderGroupStackSizeKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.vkGetRayTracingShaderGroupStackSizeKHR_FinalReturn; + memcpy((void*)(&Mock.vkGetRayTracingShaderGroupStackSizeKHR_FinalReturn), (void*)(&cmock_call_instance->ReturnVal), + sizeof(VkDeviceSize[sizeof(cmock_call_instance->ReturnVal) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + return cmock_call_instance->ReturnVal; + } + if (!Mock.vkGetRayTracingShaderGroupStackSizeKHR_CallbackBool && + Mock.vkGetRayTracingShaderGroupStackSizeKHR_CallbackFunctionPointer != NULL) + { + VkDeviceSize cmock_cb_ret = Mock.vkGetRayTracingShaderGroupStackSizeKHR_CallbackFunctionPointer(device, pipeline, group, groupShader, Mock.vkGetRayTracingShaderGroupStackSizeKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_device) + { + UNITY_SET_DETAILS(CMockString_vkGetRayTracingShaderGroupStackSizeKHR,CMockString_device); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device), (void*)(&device), sizeof(VkDevice), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pipeline) + { + UNITY_SET_DETAILS(CMockString_vkGetRayTracingShaderGroupStackSizeKHR,CMockString_pipeline); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_pipeline), (void*)(&pipeline), sizeof(VkPipeline), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_group) + { + UNITY_SET_DETAILS(CMockString_vkGetRayTracingShaderGroupStackSizeKHR,CMockString_group); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_group, group, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_groupShader) + { + UNITY_SET_DETAILS(CMockString_vkGetRayTracingShaderGroupStackSizeKHR,CMockString_groupShader); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_groupShader), (void*)(&groupShader), sizeof(VkShaderGroupShaderKHR), cmock_line, CMockStringMismatch); + } + } + if (Mock.vkGetRayTracingShaderGroupStackSizeKHR_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.vkGetRayTracingShaderGroupStackSizeKHR_CallbackFunctionPointer(device, pipeline, group, groupShader, Mock.vkGetRayTracingShaderGroupStackSizeKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_vkGetRayTracingShaderGroupStackSizeKHR(CMOCK_vkGetRayTracingShaderGroupStackSizeKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader); +void CMockExpectParameters_vkGetRayTracingShaderGroupStackSizeKHR(CMOCK_vkGetRayTracingShaderGroupStackSizeKHR_CALL_INSTANCE* cmock_call_instance, VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader) +{ + memcpy((void*)(&cmock_call_instance->Expected_device), (void*)(&device), + sizeof(VkDevice[sizeof(device) == sizeof(VkDevice) ? 1 : -1])); /* add VkDevice to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device = 0; + memcpy((void*)(&cmock_call_instance->Expected_pipeline), (void*)(&pipeline), + sizeof(VkPipeline[sizeof(pipeline) == sizeof(VkPipeline) ? 1 : -1])); /* add VkPipeline to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_pipeline = 0; + cmock_call_instance->Expected_group = group; + cmock_call_instance->IgnoreArg_group = 0; + memcpy((void*)(&cmock_call_instance->Expected_groupShader), (void*)(&groupShader), + sizeof(VkShaderGroupShaderKHR[sizeof(groupShader) == sizeof(VkShaderGroupShaderKHR) ? 1 : -1])); /* add VkShaderGroupShaderKHR to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_groupShader = 0; +} + +void vkGetRayTracingShaderGroupStackSizeKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkDeviceSize cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetRayTracingShaderGroupStackSizeKHR_CALL_INSTANCE)); + CMOCK_vkGetRayTracingShaderGroupStackSizeKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingShaderGroupStackSizeKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetRayTracingShaderGroupStackSizeKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetRayTracingShaderGroupStackSizeKHR_CallInstance, cmock_guts_index); + Mock.vkGetRayTracingShaderGroupStackSizeKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.vkGetRayTracingShaderGroupStackSizeKHR_IgnoreBool = (char)1; +} + +void vkGetRayTracingShaderGroupStackSizeKHR_CMockStopIgnore(void) +{ + if(Mock.vkGetRayTracingShaderGroupStackSizeKHR_IgnoreBool) + Mock.vkGetRayTracingShaderGroupStackSizeKHR_CallInstance = CMock_Guts_MemNext(Mock.vkGetRayTracingShaderGroupStackSizeKHR_CallInstance); + Mock.vkGetRayTracingShaderGroupStackSizeKHR_IgnoreBool = (char)0; +} + +void vkGetRayTracingShaderGroupStackSizeKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkDeviceSize cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetRayTracingShaderGroupStackSizeKHR_CALL_INSTANCE)); + CMOCK_vkGetRayTracingShaderGroupStackSizeKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingShaderGroupStackSizeKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetRayTracingShaderGroupStackSizeKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetRayTracingShaderGroupStackSizeKHR_CallInstance, cmock_guts_index); + Mock.vkGetRayTracingShaderGroupStackSizeKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkGetRayTracingShaderGroupStackSizeKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader, VkDeviceSize cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkGetRayTracingShaderGroupStackSizeKHR_CALL_INSTANCE)); + CMOCK_vkGetRayTracingShaderGroupStackSizeKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingShaderGroupStackSizeKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkGetRayTracingShaderGroupStackSizeKHR_CallInstance = CMock_Guts_MemChain(Mock.vkGetRayTracingShaderGroupStackSizeKHR_CallInstance, cmock_guts_index); + Mock.vkGetRayTracingShaderGroupStackSizeKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkGetRayTracingShaderGroupStackSizeKHR(cmock_call_instance, device, pipeline, group, groupShader); + memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return), + sizeof(VkDeviceSize[sizeof(cmock_to_return) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ +} + +void vkGetRayTracingShaderGroupStackSizeKHR_AddCallback(CMOCK_vkGetRayTracingShaderGroupStackSizeKHR_CALLBACK Callback) +{ + Mock.vkGetRayTracingShaderGroupStackSizeKHR_IgnoreBool = (char)0; + Mock.vkGetRayTracingShaderGroupStackSizeKHR_CallbackBool = (char)1; + Mock.vkGetRayTracingShaderGroupStackSizeKHR_CallbackFunctionPointer = Callback; +} + +void vkGetRayTracingShaderGroupStackSizeKHR_Stub(CMOCK_vkGetRayTracingShaderGroupStackSizeKHR_CALLBACK Callback) +{ + Mock.vkGetRayTracingShaderGroupStackSizeKHR_IgnoreBool = (char)0; + Mock.vkGetRayTracingShaderGroupStackSizeKHR_CallbackBool = (char)0; + Mock.vkGetRayTracingShaderGroupStackSizeKHR_CallbackFunctionPointer = Callback; +} + +void vkGetRayTracingShaderGroupStackSizeKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetRayTracingShaderGroupStackSizeKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingShaderGroupStackSizeKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRayTracingShaderGroupStackSizeKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device = 1; +} + +void vkGetRayTracingShaderGroupStackSizeKHR_CMockIgnoreArg_pipeline(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetRayTracingShaderGroupStackSizeKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingShaderGroupStackSizeKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRayTracingShaderGroupStackSizeKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pipeline = 1; +} + +void vkGetRayTracingShaderGroupStackSizeKHR_CMockIgnoreArg_group(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetRayTracingShaderGroupStackSizeKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingShaderGroupStackSizeKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRayTracingShaderGroupStackSizeKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_group = 1; +} + +void vkGetRayTracingShaderGroupStackSizeKHR_CMockIgnoreArg_groupShader(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkGetRayTracingShaderGroupStackSizeKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkGetRayTracingShaderGroupStackSizeKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkGetRayTracingShaderGroupStackSizeKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_groupShader = 1; +} + +void vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdSetRayTracingPipelineStackSizeKHR_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdSetRayTracingPipelineStackSizeKHR); + cmock_call_instance = (CMOCK_vkCmdSetRayTracingPipelineStackSizeKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdSetRayTracingPipelineStackSizeKHR_CallInstance); + Mock.vkCmdSetRayTracingPipelineStackSizeKHR_CallInstance = CMock_Guts_MemNext(Mock.vkCmdSetRayTracingPipelineStackSizeKHR_CallInstance); + if (Mock.vkCmdSetRayTracingPipelineStackSizeKHR_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdSetRayTracingPipelineStackSizeKHR_CallbackBool && + Mock.vkCmdSetRayTracingPipelineStackSizeKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetRayTracingPipelineStackSizeKHR_CallbackFunctionPointer(commandBuffer, pipelineStackSize, Mock.vkCmdSetRayTracingPipelineStackSizeKHR_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetRayTracingPipelineStackSizeKHR,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pipelineStackSize) + { + UNITY_SET_DETAILS(CMockString_vkCmdSetRayTracingPipelineStackSizeKHR,CMockString_pipelineStackSize); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_pipelineStackSize, pipelineStackSize, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdSetRayTracingPipelineStackSizeKHR_CallbackFunctionPointer != NULL) + { + Mock.vkCmdSetRayTracingPipelineStackSizeKHR_CallbackFunctionPointer(commandBuffer, pipelineStackSize, Mock.vkCmdSetRayTracingPipelineStackSizeKHR_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdSetRayTracingPipelineStackSizeKHR(CMOCK_vkCmdSetRayTracingPipelineStackSizeKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t pipelineStackSize); +void CMockExpectParameters_vkCmdSetRayTracingPipelineStackSizeKHR(CMOCK_vkCmdSetRayTracingPipelineStackSizeKHR_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t pipelineStackSize) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_pipelineStackSize = pipelineStackSize; + cmock_call_instance->IgnoreArg_pipelineStackSize = 0; +} + +void vkCmdSetRayTracingPipelineStackSizeKHR_CMockIgnore(void) +{ + Mock.vkCmdSetRayTracingPipelineStackSizeKHR_IgnoreBool = (char)1; +} + +void vkCmdSetRayTracingPipelineStackSizeKHR_CMockStopIgnore(void) +{ + Mock.vkCmdSetRayTracingPipelineStackSizeKHR_IgnoreBool = (char)0; +} + +void vkCmdSetRayTracingPipelineStackSizeKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetRayTracingPipelineStackSizeKHR_CALL_INSTANCE)); + CMOCK_vkCmdSetRayTracingPipelineStackSizeKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetRayTracingPipelineStackSizeKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetRayTracingPipelineStackSizeKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetRayTracingPipelineStackSizeKHR_CallInstance, cmock_guts_index); + Mock.vkCmdSetRayTracingPipelineStackSizeKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdSetRayTracingPipelineStackSizeKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t pipelineStackSize) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdSetRayTracingPipelineStackSizeKHR_CALL_INSTANCE)); + CMOCK_vkCmdSetRayTracingPipelineStackSizeKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetRayTracingPipelineStackSizeKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdSetRayTracingPipelineStackSizeKHR_CallInstance = CMock_Guts_MemChain(Mock.vkCmdSetRayTracingPipelineStackSizeKHR_CallInstance, cmock_guts_index); + Mock.vkCmdSetRayTracingPipelineStackSizeKHR_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdSetRayTracingPipelineStackSizeKHR(cmock_call_instance, commandBuffer, pipelineStackSize); +} + +void vkCmdSetRayTracingPipelineStackSizeKHR_AddCallback(CMOCK_vkCmdSetRayTracingPipelineStackSizeKHR_CALLBACK Callback) +{ + Mock.vkCmdSetRayTracingPipelineStackSizeKHR_IgnoreBool = (char)0; + Mock.vkCmdSetRayTracingPipelineStackSizeKHR_CallbackBool = (char)1; + Mock.vkCmdSetRayTracingPipelineStackSizeKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdSetRayTracingPipelineStackSizeKHR_Stub(CMOCK_vkCmdSetRayTracingPipelineStackSizeKHR_CALLBACK Callback) +{ + Mock.vkCmdSetRayTracingPipelineStackSizeKHR_IgnoreBool = (char)0; + Mock.vkCmdSetRayTracingPipelineStackSizeKHR_CallbackBool = (char)0; + Mock.vkCmdSetRayTracingPipelineStackSizeKHR_CallbackFunctionPointer = Callback; +} + +void vkCmdSetRayTracingPipelineStackSizeKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetRayTracingPipelineStackSizeKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetRayTracingPipelineStackSizeKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetRayTracingPipelineStackSizeKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdSetRayTracingPipelineStackSizeKHR_CMockIgnoreArg_pipelineStackSize(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdSetRayTracingPipelineStackSizeKHR_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdSetRayTracingPipelineStackSizeKHR_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdSetRayTracingPipelineStackSizeKHR_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pipelineStackSize = 1; +} + +void vkCmdDrawMeshTasksEXT(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDrawMeshTasksEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDrawMeshTasksEXT); + cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDrawMeshTasksEXT_CallInstance); + Mock.vkCmdDrawMeshTasksEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDrawMeshTasksEXT_CallInstance); + if (Mock.vkCmdDrawMeshTasksEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDrawMeshTasksEXT_CallbackBool && + Mock.vkCmdDrawMeshTasksEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawMeshTasksEXT_CallbackFunctionPointer(commandBuffer, groupCountX, groupCountY, groupCountZ, Mock.vkCmdDrawMeshTasksEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_groupCountX) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksEXT,CMockString_groupCountX); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_groupCountX, groupCountX, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_groupCountY) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksEXT,CMockString_groupCountY); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_groupCountY, groupCountY, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_groupCountZ) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksEXT,CMockString_groupCountZ); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_groupCountZ, groupCountZ, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdDrawMeshTasksEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawMeshTasksEXT_CallbackFunctionPointer(commandBuffer, groupCountX, groupCountY, groupCountZ, Mock.vkCmdDrawMeshTasksEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDrawMeshTasksEXT(CMOCK_vkCmdDrawMeshTasksEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +void CMockExpectParameters_vkCmdDrawMeshTasksEXT(CMOCK_vkCmdDrawMeshTasksEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + cmock_call_instance->Expected_groupCountX = groupCountX; + cmock_call_instance->IgnoreArg_groupCountX = 0; + cmock_call_instance->Expected_groupCountY = groupCountY; + cmock_call_instance->IgnoreArg_groupCountY = 0; + cmock_call_instance->Expected_groupCountZ = groupCountZ; + cmock_call_instance->IgnoreArg_groupCountZ = 0; +} + +void vkCmdDrawMeshTasksEXT_CMockIgnore(void) +{ + Mock.vkCmdDrawMeshTasksEXT_IgnoreBool = (char)1; +} + +void vkCmdDrawMeshTasksEXT_CMockStopIgnore(void) +{ + Mock.vkCmdDrawMeshTasksEXT_IgnoreBool = (char)0; +} + +void vkCmdDrawMeshTasksEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawMeshTasksEXT_CALL_INSTANCE)); + CMOCK_vkCmdDrawMeshTasksEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawMeshTasksEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawMeshTasksEXT_CallInstance, cmock_guts_index); + Mock.vkCmdDrawMeshTasksEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDrawMeshTasksEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawMeshTasksEXT_CALL_INSTANCE)); + CMOCK_vkCmdDrawMeshTasksEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawMeshTasksEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawMeshTasksEXT_CallInstance, cmock_guts_index); + Mock.vkCmdDrawMeshTasksEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDrawMeshTasksEXT(cmock_call_instance, commandBuffer, groupCountX, groupCountY, groupCountZ); +} + +void vkCmdDrawMeshTasksEXT_AddCallback(CMOCK_vkCmdDrawMeshTasksEXT_CALLBACK Callback) +{ + Mock.vkCmdDrawMeshTasksEXT_IgnoreBool = (char)0; + Mock.vkCmdDrawMeshTasksEXT_CallbackBool = (char)1; + Mock.vkCmdDrawMeshTasksEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawMeshTasksEXT_Stub(CMOCK_vkCmdDrawMeshTasksEXT_CALLBACK Callback) +{ + Mock.vkCmdDrawMeshTasksEXT_IgnoreBool = (char)0; + Mock.vkCmdDrawMeshTasksEXT_CallbackBool = (char)0; + Mock.vkCmdDrawMeshTasksEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawMeshTasksEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDrawMeshTasksEXT_CMockIgnoreArg_groupCountX(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_groupCountX = 1; +} + +void vkCmdDrawMeshTasksEXT_CMockIgnoreArg_groupCountY(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_groupCountY = 1; +} + +void vkCmdDrawMeshTasksEXT_CMockIgnoreArg_groupCountZ(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_groupCountZ = 1; +} + +void vkCmdDrawMeshTasksIndirectEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDrawMeshTasksIndirectEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDrawMeshTasksIndirectEXT); + cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDrawMeshTasksIndirectEXT_CallInstance); + Mock.vkCmdDrawMeshTasksIndirectEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDrawMeshTasksIndirectEXT_CallInstance); + if (Mock.vkCmdDrawMeshTasksIndirectEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDrawMeshTasksIndirectEXT_CallbackBool && + Mock.vkCmdDrawMeshTasksIndirectEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawMeshTasksIndirectEXT_CallbackFunctionPointer(commandBuffer, buffer, offset, drawCount, stride, Mock.vkCmdDrawMeshTasksIndirectEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksIndirectEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_buffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksIndirectEXT,CMockString_buffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_offset) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksIndirectEXT,CMockString_offset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_drawCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksIndirectEXT,CMockString_drawCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_drawCount, drawCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_stride) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksIndirectEXT,CMockString_stride); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_stride, stride, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdDrawMeshTasksIndirectEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawMeshTasksIndirectEXT_CallbackFunctionPointer(commandBuffer, buffer, offset, drawCount, stride, Mock.vkCmdDrawMeshTasksIndirectEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDrawMeshTasksIndirectEXT(CMOCK_vkCmdDrawMeshTasksIndirectEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +void CMockExpectParameters_vkCmdDrawMeshTasksIndirectEXT(CMOCK_vkCmdDrawMeshTasksIndirectEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), + sizeof(VkBuffer[sizeof(buffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_buffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), + sizeof(VkDeviceSize[sizeof(offset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_offset = 0; + cmock_call_instance->Expected_drawCount = drawCount; + cmock_call_instance->IgnoreArg_drawCount = 0; + cmock_call_instance->Expected_stride = stride; + cmock_call_instance->IgnoreArg_stride = 0; +} + +void vkCmdDrawMeshTasksIndirectEXT_CMockIgnore(void) +{ + Mock.vkCmdDrawMeshTasksIndirectEXT_IgnoreBool = (char)1; +} + +void vkCmdDrawMeshTasksIndirectEXT_CMockStopIgnore(void) +{ + Mock.vkCmdDrawMeshTasksIndirectEXT_IgnoreBool = (char)0; +} + +void vkCmdDrawMeshTasksIndirectEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawMeshTasksIndirectEXT_CALL_INSTANCE)); + CMOCK_vkCmdDrawMeshTasksIndirectEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawMeshTasksIndirectEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawMeshTasksIndirectEXT_CallInstance, cmock_guts_index); + Mock.vkCmdDrawMeshTasksIndirectEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDrawMeshTasksIndirectEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawMeshTasksIndirectEXT_CALL_INSTANCE)); + CMOCK_vkCmdDrawMeshTasksIndirectEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawMeshTasksIndirectEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawMeshTasksIndirectEXT_CallInstance, cmock_guts_index); + Mock.vkCmdDrawMeshTasksIndirectEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDrawMeshTasksIndirectEXT(cmock_call_instance, commandBuffer, buffer, offset, drawCount, stride); +} + +void vkCmdDrawMeshTasksIndirectEXT_AddCallback(CMOCK_vkCmdDrawMeshTasksIndirectEXT_CALLBACK Callback) +{ + Mock.vkCmdDrawMeshTasksIndirectEXT_IgnoreBool = (char)0; + Mock.vkCmdDrawMeshTasksIndirectEXT_CallbackBool = (char)1; + Mock.vkCmdDrawMeshTasksIndirectEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawMeshTasksIndirectEXT_Stub(CMOCK_vkCmdDrawMeshTasksIndirectEXT_CALLBACK Callback) +{ + Mock.vkCmdDrawMeshTasksIndirectEXT_IgnoreBool = (char)0; + Mock.vkCmdDrawMeshTasksIndirectEXT_CallbackBool = (char)0; + Mock.vkCmdDrawMeshTasksIndirectEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawMeshTasksIndirectEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksIndirectEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksIndirectEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDrawMeshTasksIndirectEXT_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksIndirectEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksIndirectEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_buffer = 1; +} + +void vkCmdDrawMeshTasksIndirectEXT_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksIndirectEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksIndirectEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_offset = 1; +} + +void vkCmdDrawMeshTasksIndirectEXT_CMockIgnoreArg_drawCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksIndirectEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksIndirectEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_drawCount = 1; +} + +void vkCmdDrawMeshTasksIndirectEXT_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksIndirectEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksIndirectEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stride = 1; +} + +void vkCmdDrawMeshTasksIndirectCountEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_vkCmdDrawMeshTasksIndirectCountEXT); + cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.vkCmdDrawMeshTasksIndirectCountEXT_CallInstance); + Mock.vkCmdDrawMeshTasksIndirectCountEXT_CallInstance = CMock_Guts_MemNext(Mock.vkCmdDrawMeshTasksIndirectCountEXT_CallInstance); + if (Mock.vkCmdDrawMeshTasksIndirectCountEXT_IgnoreBool) + { + UNITY_CLR_DETAILS(); + return; + } + if (!Mock.vkCmdDrawMeshTasksIndirectCountEXT_CallbackBool && + Mock.vkCmdDrawMeshTasksIndirectCountEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawMeshTasksIndirectCountEXT_CallbackFunctionPointer(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, Mock.vkCmdDrawMeshTasksIndirectCountEXT_CallbackCalls++); + UNITY_CLR_DETAILS(); + return; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_commandBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksIndirectCountEXT,CMockString_commandBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), sizeof(VkCommandBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_buffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksIndirectCountEXT,CMockString_buffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_offset) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksIndirectCountEXT,CMockString_offset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_countBuffer) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksIndirectCountEXT,CMockString_countBuffer); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_countBuffer), (void*)(&countBuffer), sizeof(VkBuffer), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_countBufferOffset) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksIndirectCountEXT,CMockString_countBufferOffset); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_countBufferOffset), (void*)(&countBufferOffset), sizeof(VkDeviceSize), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_maxDrawCount) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksIndirectCountEXT,CMockString_maxDrawCount); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_maxDrawCount, maxDrawCount, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_stride) + { + UNITY_SET_DETAILS(CMockString_vkCmdDrawMeshTasksIndirectCountEXT,CMockString_stride); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_stride, stride, cmock_line, CMockStringMismatch); + } + } + if (Mock.vkCmdDrawMeshTasksIndirectCountEXT_CallbackFunctionPointer != NULL) + { + Mock.vkCmdDrawMeshTasksIndirectCountEXT_CallbackFunctionPointer(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride, Mock.vkCmdDrawMeshTasksIndirectCountEXT_CallbackCalls++); + } + UNITY_CLR_DETAILS(); +} + +void CMockExpectParameters_vkCmdDrawMeshTasksIndirectCountEXT(CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +void CMockExpectParameters_vkCmdDrawMeshTasksIndirectCountEXT(CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALL_INSTANCE* cmock_call_instance, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + memcpy((void*)(&cmock_call_instance->Expected_commandBuffer), (void*)(&commandBuffer), + sizeof(VkCommandBuffer[sizeof(commandBuffer) == sizeof(VkCommandBuffer) ? 1 : -1])); /* add VkCommandBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_commandBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_buffer), (void*)(&buffer), + sizeof(VkBuffer[sizeof(buffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_buffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_offset), (void*)(&offset), + sizeof(VkDeviceSize[sizeof(offset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_offset = 0; + memcpy((void*)(&cmock_call_instance->Expected_countBuffer), (void*)(&countBuffer), + sizeof(VkBuffer[sizeof(countBuffer) == sizeof(VkBuffer) ? 1 : -1])); /* add VkBuffer to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_countBuffer = 0; + memcpy((void*)(&cmock_call_instance->Expected_countBufferOffset), (void*)(&countBufferOffset), + sizeof(VkDeviceSize[sizeof(countBufferOffset) == sizeof(VkDeviceSize) ? 1 : -1])); /* add VkDeviceSize to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_countBufferOffset = 0; + cmock_call_instance->Expected_maxDrawCount = maxDrawCount; + cmock_call_instance->IgnoreArg_maxDrawCount = 0; + cmock_call_instance->Expected_stride = stride; + cmock_call_instance->IgnoreArg_stride = 0; +} + +void vkCmdDrawMeshTasksIndirectCountEXT_CMockIgnore(void) +{ + Mock.vkCmdDrawMeshTasksIndirectCountEXT_IgnoreBool = (char)1; +} + +void vkCmdDrawMeshTasksIndirectCountEXT_CMockStopIgnore(void) +{ + Mock.vkCmdDrawMeshTasksIndirectCountEXT_IgnoreBool = (char)0; +} + +void vkCmdDrawMeshTasksIndirectCountEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALL_INSTANCE)); + CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawMeshTasksIndirectCountEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawMeshTasksIndirectCountEXT_CallInstance, cmock_guts_index); + Mock.vkCmdDrawMeshTasksIndirectCountEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void vkCmdDrawMeshTasksIndirectCountEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALL_INSTANCE)); + CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.vkCmdDrawMeshTasksIndirectCountEXT_CallInstance = CMock_Guts_MemChain(Mock.vkCmdDrawMeshTasksIndirectCountEXT_CallInstance, cmock_guts_index); + Mock.vkCmdDrawMeshTasksIndirectCountEXT_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_vkCmdDrawMeshTasksIndirectCountEXT(cmock_call_instance, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); +} + +void vkCmdDrawMeshTasksIndirectCountEXT_AddCallback(CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALLBACK Callback) +{ + Mock.vkCmdDrawMeshTasksIndirectCountEXT_IgnoreBool = (char)0; + Mock.vkCmdDrawMeshTasksIndirectCountEXT_CallbackBool = (char)1; + Mock.vkCmdDrawMeshTasksIndirectCountEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawMeshTasksIndirectCountEXT_Stub(CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALLBACK Callback) +{ + Mock.vkCmdDrawMeshTasksIndirectCountEXT_IgnoreBool = (char)0; + Mock.vkCmdDrawMeshTasksIndirectCountEXT_CallbackBool = (char)0; + Mock.vkCmdDrawMeshTasksIndirectCountEXT_CallbackFunctionPointer = Callback; +} + +void vkCmdDrawMeshTasksIndirectCountEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksIndirectCountEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_commandBuffer = 1; +} + +void vkCmdDrawMeshTasksIndirectCountEXT_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksIndirectCountEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_buffer = 1; +} + +void vkCmdDrawMeshTasksIndirectCountEXT_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksIndirectCountEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_offset = 1; +} + +void vkCmdDrawMeshTasksIndirectCountEXT_CMockIgnoreArg_countBuffer(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksIndirectCountEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_countBuffer = 1; +} + +void vkCmdDrawMeshTasksIndirectCountEXT_CMockIgnoreArg_countBufferOffset(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksIndirectCountEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_countBufferOffset = 1; +} + +void vkCmdDrawMeshTasksIndirectCountEXT_CMockIgnoreArg_maxDrawCount(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksIndirectCountEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_maxDrawCount = 1; +} + +void vkCmdDrawMeshTasksIndirectCountEXT_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALL_INSTANCE* cmock_call_instance = (CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.vkCmdDrawMeshTasksIndirectCountEXT_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_stride = 1; +} + diff --git a/tests/src/mocks/vulkan/Mockvulkan_core.h b/tests/src/mocks/vulkan/Mockvulkan_core.h new file mode 100644 index 00000000..5fd477e1 --- /dev/null +++ b/tests/src/mocks/vulkan/Mockvulkan_core.h @@ -0,0 +1,12208 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ +#ifndef _MOCKVULKAN_CORE_H +#define _MOCKVULKAN_CORE_H + +#include "unity.h" +#include "vulkan/vulkan_core.h" + +/* Ignore the following warnings, since we are copying code */ +#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__) +#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0))) +#pragma GCC diagnostic push +#endif +#if !defined(__clang__) +#pragma GCC diagnostic ignored "-Wpragmas" +#endif +#pragma GCC diagnostic ignored "-Wunknown-pragmas" +#pragma GCC diagnostic ignored "-Wduplicate-decl-specifier" +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +void Mockvulkan_core_Init(void); +void Mockvulkan_core_Destroy(void); +void Mockvulkan_core_Verify(void); + + + + +#define vkCreateInstance_IgnoreAndReturn(cmock_retval) vkCreateInstance_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateInstance_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateInstance_StopIgnore() vkCreateInstance_CMockStopIgnore() +void vkCreateInstance_CMockStopIgnore(void); +#define vkCreateInstance_ExpectAnyArgsAndReturn(cmock_retval) vkCreateInstance_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateInstance_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateInstance_ExpectAndReturn(pCreateInfo, pAllocator, pInstance, cmock_retval) vkCreateInstance_CMockExpectAndReturn(__LINE__, pCreateInfo, pAllocator, pInstance, cmock_retval) +void vkCreateInstance_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateInstance_CALLBACK)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance, int cmock_num_calls); +void vkCreateInstance_AddCallback(CMOCK_vkCreateInstance_CALLBACK Callback); +void vkCreateInstance_Stub(CMOCK_vkCreateInstance_CALLBACK Callback); +#define vkCreateInstance_StubWithCallback vkCreateInstance_AddCallback +#define vkCreateInstance_ReturnThruPtr_pInstance(pInstance) vkCreateInstance_CMockReturnMemThruPtr_pInstance(__LINE__, pInstance, sizeof(VkInstance)) +#define vkCreateInstance_ReturnArrayThruPtr_pInstance(pInstance, cmock_len) vkCreateInstance_CMockReturnMemThruPtr_pInstance(__LINE__, pInstance, cmock_len * sizeof(*pInstance)) +#define vkCreateInstance_ReturnMemThruPtr_pInstance(pInstance, cmock_size) vkCreateInstance_CMockReturnMemThruPtr_pInstance(__LINE__, pInstance, cmock_size) +void vkCreateInstance_CMockReturnMemThruPtr_pInstance(UNITY_LINE_TYPE cmock_line, VkInstance const* pInstance, size_t cmock_size); +#define vkCreateInstance_IgnoreArg_pCreateInfo() vkCreateInstance_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateInstance_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateInstance_IgnoreArg_pAllocator() vkCreateInstance_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateInstance_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateInstance_IgnoreArg_pInstance() vkCreateInstance_CMockIgnoreArg_pInstance(__LINE__) +void vkCreateInstance_CMockIgnoreArg_pInstance(UNITY_LINE_TYPE cmock_line); +#define vkDestroyInstance_Ignore() vkDestroyInstance_CMockIgnore() +void vkDestroyInstance_CMockIgnore(void); +#define vkDestroyInstance_StopIgnore() vkDestroyInstance_CMockStopIgnore() +void vkDestroyInstance_CMockStopIgnore(void); +#define vkDestroyInstance_ExpectAnyArgs() vkDestroyInstance_CMockExpectAnyArgs(__LINE__) +void vkDestroyInstance_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyInstance_Expect(instance, pAllocator) vkDestroyInstance_CMockExpect(__LINE__, instance, pAllocator) +void vkDestroyInstance_CMockExpect(UNITY_LINE_TYPE cmock_line, VkInstance instance, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyInstance_CALLBACK)(VkInstance instance, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyInstance_AddCallback(CMOCK_vkDestroyInstance_CALLBACK Callback); +void vkDestroyInstance_Stub(CMOCK_vkDestroyInstance_CALLBACK Callback); +#define vkDestroyInstance_StubWithCallback vkDestroyInstance_AddCallback +#define vkDestroyInstance_IgnoreArg_instance() vkDestroyInstance_CMockIgnoreArg_instance(__LINE__) +void vkDestroyInstance_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line); +#define vkDestroyInstance_IgnoreArg_pAllocator() vkDestroyInstance_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyInstance_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkEnumeratePhysicalDevices_IgnoreAndReturn(cmock_retval) vkEnumeratePhysicalDevices_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkEnumeratePhysicalDevices_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkEnumeratePhysicalDevices_StopIgnore() vkEnumeratePhysicalDevices_CMockStopIgnore() +void vkEnumeratePhysicalDevices_CMockStopIgnore(void); +#define vkEnumeratePhysicalDevices_ExpectAnyArgsAndReturn(cmock_retval) vkEnumeratePhysicalDevices_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkEnumeratePhysicalDevices_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkEnumeratePhysicalDevices_ExpectAndReturn(instance, pPhysicalDeviceCount, pPhysicalDevices, cmock_retval) vkEnumeratePhysicalDevices_CMockExpectAndReturn(__LINE__, instance, pPhysicalDeviceCount, pPhysicalDevices, cmock_retval) +void vkEnumeratePhysicalDevices_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkEnumeratePhysicalDevices_CALLBACK)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices, int cmock_num_calls); +void vkEnumeratePhysicalDevices_AddCallback(CMOCK_vkEnumeratePhysicalDevices_CALLBACK Callback); +void vkEnumeratePhysicalDevices_Stub(CMOCK_vkEnumeratePhysicalDevices_CALLBACK Callback); +#define vkEnumeratePhysicalDevices_StubWithCallback vkEnumeratePhysicalDevices_AddCallback +#define vkEnumeratePhysicalDevices_ReturnThruPtr_pPhysicalDeviceCount(pPhysicalDeviceCount) vkEnumeratePhysicalDevices_CMockReturnMemThruPtr_pPhysicalDeviceCount(__LINE__, pPhysicalDeviceCount, sizeof(uint32_t)) +#define vkEnumeratePhysicalDevices_ReturnArrayThruPtr_pPhysicalDeviceCount(pPhysicalDeviceCount, cmock_len) vkEnumeratePhysicalDevices_CMockReturnMemThruPtr_pPhysicalDeviceCount(__LINE__, pPhysicalDeviceCount, cmock_len * sizeof(*pPhysicalDeviceCount)) +#define vkEnumeratePhysicalDevices_ReturnMemThruPtr_pPhysicalDeviceCount(pPhysicalDeviceCount, cmock_size) vkEnumeratePhysicalDevices_CMockReturnMemThruPtr_pPhysicalDeviceCount(__LINE__, pPhysicalDeviceCount, cmock_size) +void vkEnumeratePhysicalDevices_CMockReturnMemThruPtr_pPhysicalDeviceCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPhysicalDeviceCount, size_t cmock_size); +#define vkEnumeratePhysicalDevices_ReturnThruPtr_pPhysicalDevices(pPhysicalDevices) vkEnumeratePhysicalDevices_CMockReturnMemThruPtr_pPhysicalDevices(__LINE__, pPhysicalDevices, sizeof(VkPhysicalDevice)) +#define vkEnumeratePhysicalDevices_ReturnArrayThruPtr_pPhysicalDevices(pPhysicalDevices, cmock_len) vkEnumeratePhysicalDevices_CMockReturnMemThruPtr_pPhysicalDevices(__LINE__, pPhysicalDevices, cmock_len * sizeof(*pPhysicalDevices)) +#define vkEnumeratePhysicalDevices_ReturnMemThruPtr_pPhysicalDevices(pPhysicalDevices, cmock_size) vkEnumeratePhysicalDevices_CMockReturnMemThruPtr_pPhysicalDevices(__LINE__, pPhysicalDevices, cmock_size) +void vkEnumeratePhysicalDevices_CMockReturnMemThruPtr_pPhysicalDevices(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice const* pPhysicalDevices, size_t cmock_size); +#define vkEnumeratePhysicalDevices_IgnoreArg_instance() vkEnumeratePhysicalDevices_CMockIgnoreArg_instance(__LINE__) +void vkEnumeratePhysicalDevices_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line); +#define vkEnumeratePhysicalDevices_IgnoreArg_pPhysicalDeviceCount() vkEnumeratePhysicalDevices_CMockIgnoreArg_pPhysicalDeviceCount(__LINE__) +void vkEnumeratePhysicalDevices_CMockIgnoreArg_pPhysicalDeviceCount(UNITY_LINE_TYPE cmock_line); +#define vkEnumeratePhysicalDevices_IgnoreArg_pPhysicalDevices() vkEnumeratePhysicalDevices_CMockIgnoreArg_pPhysicalDevices(__LINE__) +void vkEnumeratePhysicalDevices_CMockIgnoreArg_pPhysicalDevices(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceFeatures_Ignore() vkGetPhysicalDeviceFeatures_CMockIgnore() +void vkGetPhysicalDeviceFeatures_CMockIgnore(void); +#define vkGetPhysicalDeviceFeatures_StopIgnore() vkGetPhysicalDeviceFeatures_CMockStopIgnore() +void vkGetPhysicalDeviceFeatures_CMockStopIgnore(void); +#define vkGetPhysicalDeviceFeatures_ExpectAnyArgs() vkGetPhysicalDeviceFeatures_CMockExpectAnyArgs(__LINE__) +void vkGetPhysicalDeviceFeatures_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceFeatures_Expect(physicalDevice, pFeatures) vkGetPhysicalDeviceFeatures_CMockExpect(__LINE__, physicalDevice, pFeatures) +void vkGetPhysicalDeviceFeatures_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); +typedef void (* CMOCK_vkGetPhysicalDeviceFeatures_CALLBACK)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures, int cmock_num_calls); +void vkGetPhysicalDeviceFeatures_AddCallback(CMOCK_vkGetPhysicalDeviceFeatures_CALLBACK Callback); +void vkGetPhysicalDeviceFeatures_Stub(CMOCK_vkGetPhysicalDeviceFeatures_CALLBACK Callback); +#define vkGetPhysicalDeviceFeatures_StubWithCallback vkGetPhysicalDeviceFeatures_AddCallback +#define vkGetPhysicalDeviceFeatures_ReturnThruPtr_pFeatures(pFeatures) vkGetPhysicalDeviceFeatures_CMockReturnMemThruPtr_pFeatures(__LINE__, pFeatures, sizeof(VkPhysicalDeviceFeatures)) +#define vkGetPhysicalDeviceFeatures_ReturnArrayThruPtr_pFeatures(pFeatures, cmock_len) vkGetPhysicalDeviceFeatures_CMockReturnMemThruPtr_pFeatures(__LINE__, pFeatures, cmock_len * sizeof(*pFeatures)) +#define vkGetPhysicalDeviceFeatures_ReturnMemThruPtr_pFeatures(pFeatures, cmock_size) vkGetPhysicalDeviceFeatures_CMockReturnMemThruPtr_pFeatures(__LINE__, pFeatures, cmock_size) +void vkGetPhysicalDeviceFeatures_CMockReturnMemThruPtr_pFeatures(UNITY_LINE_TYPE cmock_line, VkPhysicalDeviceFeatures const* pFeatures, size_t cmock_size); +#define vkGetPhysicalDeviceFeatures_IgnoreArg_physicalDevice() vkGetPhysicalDeviceFeatures_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceFeatures_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceFeatures_IgnoreArg_pFeatures() vkGetPhysicalDeviceFeatures_CMockIgnoreArg_pFeatures(__LINE__) +void vkGetPhysicalDeviceFeatures_CMockIgnoreArg_pFeatures(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceFormatProperties_Ignore() vkGetPhysicalDeviceFormatProperties_CMockIgnore() +void vkGetPhysicalDeviceFormatProperties_CMockIgnore(void); +#define vkGetPhysicalDeviceFormatProperties_StopIgnore() vkGetPhysicalDeviceFormatProperties_CMockStopIgnore() +void vkGetPhysicalDeviceFormatProperties_CMockStopIgnore(void); +#define vkGetPhysicalDeviceFormatProperties_ExpectAnyArgs() vkGetPhysicalDeviceFormatProperties_CMockExpectAnyArgs(__LINE__) +void vkGetPhysicalDeviceFormatProperties_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceFormatProperties_Expect(physicalDevice, format, pFormatProperties) vkGetPhysicalDeviceFormatProperties_CMockExpect(__LINE__, physicalDevice, format, pFormatProperties) +void vkGetPhysicalDeviceFormatProperties_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); +typedef void (* CMOCK_vkGetPhysicalDeviceFormatProperties_CALLBACK)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties, int cmock_num_calls); +void vkGetPhysicalDeviceFormatProperties_AddCallback(CMOCK_vkGetPhysicalDeviceFormatProperties_CALLBACK Callback); +void vkGetPhysicalDeviceFormatProperties_Stub(CMOCK_vkGetPhysicalDeviceFormatProperties_CALLBACK Callback); +#define vkGetPhysicalDeviceFormatProperties_StubWithCallback vkGetPhysicalDeviceFormatProperties_AddCallback +#define vkGetPhysicalDeviceFormatProperties_ReturnThruPtr_pFormatProperties(pFormatProperties) vkGetPhysicalDeviceFormatProperties_CMockReturnMemThruPtr_pFormatProperties(__LINE__, pFormatProperties, sizeof(VkFormatProperties)) +#define vkGetPhysicalDeviceFormatProperties_ReturnArrayThruPtr_pFormatProperties(pFormatProperties, cmock_len) vkGetPhysicalDeviceFormatProperties_CMockReturnMemThruPtr_pFormatProperties(__LINE__, pFormatProperties, cmock_len * sizeof(*pFormatProperties)) +#define vkGetPhysicalDeviceFormatProperties_ReturnMemThruPtr_pFormatProperties(pFormatProperties, cmock_size) vkGetPhysicalDeviceFormatProperties_CMockReturnMemThruPtr_pFormatProperties(__LINE__, pFormatProperties, cmock_size) +void vkGetPhysicalDeviceFormatProperties_CMockReturnMemThruPtr_pFormatProperties(UNITY_LINE_TYPE cmock_line, VkFormatProperties const* pFormatProperties, size_t cmock_size); +#define vkGetPhysicalDeviceFormatProperties_IgnoreArg_physicalDevice() vkGetPhysicalDeviceFormatProperties_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceFormatProperties_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceFormatProperties_IgnoreArg_format() vkGetPhysicalDeviceFormatProperties_CMockIgnoreArg_format(__LINE__) +void vkGetPhysicalDeviceFormatProperties_CMockIgnoreArg_format(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceFormatProperties_IgnoreArg_pFormatProperties() vkGetPhysicalDeviceFormatProperties_CMockIgnoreArg_pFormatProperties(__LINE__) +void vkGetPhysicalDeviceFormatProperties_CMockIgnoreArg_pFormatProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceImageFormatProperties_IgnoreAndReturn(cmock_retval) vkGetPhysicalDeviceImageFormatProperties_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceImageFormatProperties_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceImageFormatProperties_StopIgnore() vkGetPhysicalDeviceImageFormatProperties_CMockStopIgnore() +void vkGetPhysicalDeviceImageFormatProperties_CMockStopIgnore(void); +#define vkGetPhysicalDeviceImageFormatProperties_ExpectAnyArgsAndReturn(cmock_retval) vkGetPhysicalDeviceImageFormatProperties_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceImageFormatProperties_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceImageFormatProperties_ExpectAndReturn(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties, cmock_retval) vkGetPhysicalDeviceImageFormatProperties_CMockExpectAndReturn(__LINE__, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties, cmock_retval) +void vkGetPhysicalDeviceImageFormatProperties_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALLBACK)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties, int cmock_num_calls); +void vkGetPhysicalDeviceImageFormatProperties_AddCallback(CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALLBACK Callback); +void vkGetPhysicalDeviceImageFormatProperties_Stub(CMOCK_vkGetPhysicalDeviceImageFormatProperties_CALLBACK Callback); +#define vkGetPhysicalDeviceImageFormatProperties_StubWithCallback vkGetPhysicalDeviceImageFormatProperties_AddCallback +#define vkGetPhysicalDeviceImageFormatProperties_ReturnThruPtr_pImageFormatProperties(pImageFormatProperties) vkGetPhysicalDeviceImageFormatProperties_CMockReturnMemThruPtr_pImageFormatProperties(__LINE__, pImageFormatProperties, sizeof(VkImageFormatProperties)) +#define vkGetPhysicalDeviceImageFormatProperties_ReturnArrayThruPtr_pImageFormatProperties(pImageFormatProperties, cmock_len) vkGetPhysicalDeviceImageFormatProperties_CMockReturnMemThruPtr_pImageFormatProperties(__LINE__, pImageFormatProperties, cmock_len * sizeof(*pImageFormatProperties)) +#define vkGetPhysicalDeviceImageFormatProperties_ReturnMemThruPtr_pImageFormatProperties(pImageFormatProperties, cmock_size) vkGetPhysicalDeviceImageFormatProperties_CMockReturnMemThruPtr_pImageFormatProperties(__LINE__, pImageFormatProperties, cmock_size) +void vkGetPhysicalDeviceImageFormatProperties_CMockReturnMemThruPtr_pImageFormatProperties(UNITY_LINE_TYPE cmock_line, VkImageFormatProperties const* pImageFormatProperties, size_t cmock_size); +#define vkGetPhysicalDeviceImageFormatProperties_IgnoreArg_physicalDevice() vkGetPhysicalDeviceImageFormatProperties_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceImageFormatProperties_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceImageFormatProperties_IgnoreArg_format() vkGetPhysicalDeviceImageFormatProperties_CMockIgnoreArg_format(__LINE__) +void vkGetPhysicalDeviceImageFormatProperties_CMockIgnoreArg_format(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceImageFormatProperties_IgnoreArg_type() vkGetPhysicalDeviceImageFormatProperties_CMockIgnoreArg_type(__LINE__) +void vkGetPhysicalDeviceImageFormatProperties_CMockIgnoreArg_type(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceImageFormatProperties_IgnoreArg_tiling() vkGetPhysicalDeviceImageFormatProperties_CMockIgnoreArg_tiling(__LINE__) +void vkGetPhysicalDeviceImageFormatProperties_CMockIgnoreArg_tiling(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceImageFormatProperties_IgnoreArg_usage() vkGetPhysicalDeviceImageFormatProperties_CMockIgnoreArg_usage(__LINE__) +void vkGetPhysicalDeviceImageFormatProperties_CMockIgnoreArg_usage(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceImageFormatProperties_IgnoreArg_flags() vkGetPhysicalDeviceImageFormatProperties_CMockIgnoreArg_flags(__LINE__) +void vkGetPhysicalDeviceImageFormatProperties_CMockIgnoreArg_flags(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceImageFormatProperties_IgnoreArg_pImageFormatProperties() vkGetPhysicalDeviceImageFormatProperties_CMockIgnoreArg_pImageFormatProperties(__LINE__) +void vkGetPhysicalDeviceImageFormatProperties_CMockIgnoreArg_pImageFormatProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceProperties_Ignore() vkGetPhysicalDeviceProperties_CMockIgnore() +void vkGetPhysicalDeviceProperties_CMockIgnore(void); +#define vkGetPhysicalDeviceProperties_StopIgnore() vkGetPhysicalDeviceProperties_CMockStopIgnore() +void vkGetPhysicalDeviceProperties_CMockStopIgnore(void); +#define vkGetPhysicalDeviceProperties_ExpectAnyArgs() vkGetPhysicalDeviceProperties_CMockExpectAnyArgs(__LINE__) +void vkGetPhysicalDeviceProperties_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceProperties_Expect(physicalDevice, pProperties) vkGetPhysicalDeviceProperties_CMockExpect(__LINE__, physicalDevice, pProperties) +void vkGetPhysicalDeviceProperties_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); +typedef void (* CMOCK_vkGetPhysicalDeviceProperties_CALLBACK)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties, int cmock_num_calls); +void vkGetPhysicalDeviceProperties_AddCallback(CMOCK_vkGetPhysicalDeviceProperties_CALLBACK Callback); +void vkGetPhysicalDeviceProperties_Stub(CMOCK_vkGetPhysicalDeviceProperties_CALLBACK Callback); +#define vkGetPhysicalDeviceProperties_StubWithCallback vkGetPhysicalDeviceProperties_AddCallback +#define vkGetPhysicalDeviceProperties_ReturnThruPtr_pProperties(pProperties) vkGetPhysicalDeviceProperties_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, sizeof(VkPhysicalDeviceProperties)) +#define vkGetPhysicalDeviceProperties_ReturnArrayThruPtr_pProperties(pProperties, cmock_len) vkGetPhysicalDeviceProperties_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_len * sizeof(*pProperties)) +#define vkGetPhysicalDeviceProperties_ReturnMemThruPtr_pProperties(pProperties, cmock_size) vkGetPhysicalDeviceProperties_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_size) +void vkGetPhysicalDeviceProperties_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkPhysicalDeviceProperties const* pProperties, size_t cmock_size); +#define vkGetPhysicalDeviceProperties_IgnoreArg_physicalDevice() vkGetPhysicalDeviceProperties_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceProperties_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceProperties_IgnoreArg_pProperties() vkGetPhysicalDeviceProperties_CMockIgnoreArg_pProperties(__LINE__) +void vkGetPhysicalDeviceProperties_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceQueueFamilyProperties_Ignore() vkGetPhysicalDeviceQueueFamilyProperties_CMockIgnore() +void vkGetPhysicalDeviceQueueFamilyProperties_CMockIgnore(void); +#define vkGetPhysicalDeviceQueueFamilyProperties_StopIgnore() vkGetPhysicalDeviceQueueFamilyProperties_CMockStopIgnore() +void vkGetPhysicalDeviceQueueFamilyProperties_CMockStopIgnore(void); +#define vkGetPhysicalDeviceQueueFamilyProperties_ExpectAnyArgs() vkGetPhysicalDeviceQueueFamilyProperties_CMockExpectAnyArgs(__LINE__) +void vkGetPhysicalDeviceQueueFamilyProperties_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceQueueFamilyProperties_Expect(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties) vkGetPhysicalDeviceQueueFamilyProperties_CMockExpect(__LINE__, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties) +void vkGetPhysicalDeviceQueueFamilyProperties_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties); +typedef void (* CMOCK_vkGetPhysicalDeviceQueueFamilyProperties_CALLBACK)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties, int cmock_num_calls); +void vkGetPhysicalDeviceQueueFamilyProperties_AddCallback(CMOCK_vkGetPhysicalDeviceQueueFamilyProperties_CALLBACK Callback); +void vkGetPhysicalDeviceQueueFamilyProperties_Stub(CMOCK_vkGetPhysicalDeviceQueueFamilyProperties_CALLBACK Callback); +#define vkGetPhysicalDeviceQueueFamilyProperties_StubWithCallback vkGetPhysicalDeviceQueueFamilyProperties_AddCallback +#define vkGetPhysicalDeviceQueueFamilyProperties_ReturnThruPtr_pQueueFamilyPropertyCount(pQueueFamilyPropertyCount) vkGetPhysicalDeviceQueueFamilyProperties_CMockReturnMemThruPtr_pQueueFamilyPropertyCount(__LINE__, pQueueFamilyPropertyCount, sizeof(uint32_t)) +#define vkGetPhysicalDeviceQueueFamilyProperties_ReturnArrayThruPtr_pQueueFamilyPropertyCount(pQueueFamilyPropertyCount, cmock_len) vkGetPhysicalDeviceQueueFamilyProperties_CMockReturnMemThruPtr_pQueueFamilyPropertyCount(__LINE__, pQueueFamilyPropertyCount, cmock_len * sizeof(*pQueueFamilyPropertyCount)) +#define vkGetPhysicalDeviceQueueFamilyProperties_ReturnMemThruPtr_pQueueFamilyPropertyCount(pQueueFamilyPropertyCount, cmock_size) vkGetPhysicalDeviceQueueFamilyProperties_CMockReturnMemThruPtr_pQueueFamilyPropertyCount(__LINE__, pQueueFamilyPropertyCount, cmock_size) +void vkGetPhysicalDeviceQueueFamilyProperties_CMockReturnMemThruPtr_pQueueFamilyPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pQueueFamilyPropertyCount, size_t cmock_size); +#define vkGetPhysicalDeviceQueueFamilyProperties_ReturnThruPtr_pQueueFamilyProperties(pQueueFamilyProperties) vkGetPhysicalDeviceQueueFamilyProperties_CMockReturnMemThruPtr_pQueueFamilyProperties(__LINE__, pQueueFamilyProperties, sizeof(VkQueueFamilyProperties)) +#define vkGetPhysicalDeviceQueueFamilyProperties_ReturnArrayThruPtr_pQueueFamilyProperties(pQueueFamilyProperties, cmock_len) vkGetPhysicalDeviceQueueFamilyProperties_CMockReturnMemThruPtr_pQueueFamilyProperties(__LINE__, pQueueFamilyProperties, cmock_len * sizeof(*pQueueFamilyProperties)) +#define vkGetPhysicalDeviceQueueFamilyProperties_ReturnMemThruPtr_pQueueFamilyProperties(pQueueFamilyProperties, cmock_size) vkGetPhysicalDeviceQueueFamilyProperties_CMockReturnMemThruPtr_pQueueFamilyProperties(__LINE__, pQueueFamilyProperties, cmock_size) +void vkGetPhysicalDeviceQueueFamilyProperties_CMockReturnMemThruPtr_pQueueFamilyProperties(UNITY_LINE_TYPE cmock_line, VkQueueFamilyProperties const* pQueueFamilyProperties, size_t cmock_size); +#define vkGetPhysicalDeviceQueueFamilyProperties_IgnoreArg_physicalDevice() vkGetPhysicalDeviceQueueFamilyProperties_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceQueueFamilyProperties_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceQueueFamilyProperties_IgnoreArg_pQueueFamilyPropertyCount() vkGetPhysicalDeviceQueueFamilyProperties_CMockIgnoreArg_pQueueFamilyPropertyCount(__LINE__) +void vkGetPhysicalDeviceQueueFamilyProperties_CMockIgnoreArg_pQueueFamilyPropertyCount(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceQueueFamilyProperties_IgnoreArg_pQueueFamilyProperties() vkGetPhysicalDeviceQueueFamilyProperties_CMockIgnoreArg_pQueueFamilyProperties(__LINE__) +void vkGetPhysicalDeviceQueueFamilyProperties_CMockIgnoreArg_pQueueFamilyProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceMemoryProperties_Ignore() vkGetPhysicalDeviceMemoryProperties_CMockIgnore() +void vkGetPhysicalDeviceMemoryProperties_CMockIgnore(void); +#define vkGetPhysicalDeviceMemoryProperties_StopIgnore() vkGetPhysicalDeviceMemoryProperties_CMockStopIgnore() +void vkGetPhysicalDeviceMemoryProperties_CMockStopIgnore(void); +#define vkGetPhysicalDeviceMemoryProperties_ExpectAnyArgs() vkGetPhysicalDeviceMemoryProperties_CMockExpectAnyArgs(__LINE__) +void vkGetPhysicalDeviceMemoryProperties_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceMemoryProperties_Expect(physicalDevice, pMemoryProperties) vkGetPhysicalDeviceMemoryProperties_CMockExpect(__LINE__, physicalDevice, pMemoryProperties) +void vkGetPhysicalDeviceMemoryProperties_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); +typedef void (* CMOCK_vkGetPhysicalDeviceMemoryProperties_CALLBACK)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties, int cmock_num_calls); +void vkGetPhysicalDeviceMemoryProperties_AddCallback(CMOCK_vkGetPhysicalDeviceMemoryProperties_CALLBACK Callback); +void vkGetPhysicalDeviceMemoryProperties_Stub(CMOCK_vkGetPhysicalDeviceMemoryProperties_CALLBACK Callback); +#define vkGetPhysicalDeviceMemoryProperties_StubWithCallback vkGetPhysicalDeviceMemoryProperties_AddCallback +#define vkGetPhysicalDeviceMemoryProperties_ReturnThruPtr_pMemoryProperties(pMemoryProperties) vkGetPhysicalDeviceMemoryProperties_CMockReturnMemThruPtr_pMemoryProperties(__LINE__, pMemoryProperties, sizeof(VkPhysicalDeviceMemoryProperties)) +#define vkGetPhysicalDeviceMemoryProperties_ReturnArrayThruPtr_pMemoryProperties(pMemoryProperties, cmock_len) vkGetPhysicalDeviceMemoryProperties_CMockReturnMemThruPtr_pMemoryProperties(__LINE__, pMemoryProperties, cmock_len * sizeof(*pMemoryProperties)) +#define vkGetPhysicalDeviceMemoryProperties_ReturnMemThruPtr_pMemoryProperties(pMemoryProperties, cmock_size) vkGetPhysicalDeviceMemoryProperties_CMockReturnMemThruPtr_pMemoryProperties(__LINE__, pMemoryProperties, cmock_size) +void vkGetPhysicalDeviceMemoryProperties_CMockReturnMemThruPtr_pMemoryProperties(UNITY_LINE_TYPE cmock_line, VkPhysicalDeviceMemoryProperties const* pMemoryProperties, size_t cmock_size); +#define vkGetPhysicalDeviceMemoryProperties_IgnoreArg_physicalDevice() vkGetPhysicalDeviceMemoryProperties_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceMemoryProperties_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceMemoryProperties_IgnoreArg_pMemoryProperties() vkGetPhysicalDeviceMemoryProperties_CMockIgnoreArg_pMemoryProperties(__LINE__) +void vkGetPhysicalDeviceMemoryProperties_CMockIgnoreArg_pMemoryProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetInstanceProcAddr_IgnoreAndReturn(cmock_retval) vkGetInstanceProcAddr_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetInstanceProcAddr_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, PFN_vkVoidFunction cmock_to_return); +#define vkGetInstanceProcAddr_StopIgnore() vkGetInstanceProcAddr_CMockStopIgnore() +void vkGetInstanceProcAddr_CMockStopIgnore(void); +#define vkGetInstanceProcAddr_ExpectAnyArgsAndReturn(cmock_retval) vkGetInstanceProcAddr_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetInstanceProcAddr_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, PFN_vkVoidFunction cmock_to_return); +#define vkGetInstanceProcAddr_ExpectAndReturn(instance, pName, cmock_retval) vkGetInstanceProcAddr_CMockExpectAndReturn(__LINE__, instance, pName, cmock_retval) +void vkGetInstanceProcAddr_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkInstance instance, const char* pName, PFN_vkVoidFunction cmock_to_return); +typedef PFN_vkVoidFunction (* CMOCK_vkGetInstanceProcAddr_CALLBACK)(VkInstance instance, const char* pName, int cmock_num_calls); +void vkGetInstanceProcAddr_AddCallback(CMOCK_vkGetInstanceProcAddr_CALLBACK Callback); +void vkGetInstanceProcAddr_Stub(CMOCK_vkGetInstanceProcAddr_CALLBACK Callback); +#define vkGetInstanceProcAddr_StubWithCallback vkGetInstanceProcAddr_AddCallback +#define vkGetInstanceProcAddr_IgnoreArg_instance() vkGetInstanceProcAddr_CMockIgnoreArg_instance(__LINE__) +void vkGetInstanceProcAddr_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line); +#define vkGetInstanceProcAddr_IgnoreArg_pName() vkGetInstanceProcAddr_CMockIgnoreArg_pName(__LINE__) +void vkGetInstanceProcAddr_CMockIgnoreArg_pName(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceProcAddr_IgnoreAndReturn(cmock_retval) vkGetDeviceProcAddr_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetDeviceProcAddr_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, PFN_vkVoidFunction cmock_to_return); +#define vkGetDeviceProcAddr_StopIgnore() vkGetDeviceProcAddr_CMockStopIgnore() +void vkGetDeviceProcAddr_CMockStopIgnore(void); +#define vkGetDeviceProcAddr_ExpectAnyArgsAndReturn(cmock_retval) vkGetDeviceProcAddr_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetDeviceProcAddr_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, PFN_vkVoidFunction cmock_to_return); +#define vkGetDeviceProcAddr_ExpectAndReturn(device, pName, cmock_retval) vkGetDeviceProcAddr_CMockExpectAndReturn(__LINE__, device, pName, cmock_retval) +void vkGetDeviceProcAddr_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const char* pName, PFN_vkVoidFunction cmock_to_return); +typedef PFN_vkVoidFunction (* CMOCK_vkGetDeviceProcAddr_CALLBACK)(VkDevice device, const char* pName, int cmock_num_calls); +void vkGetDeviceProcAddr_AddCallback(CMOCK_vkGetDeviceProcAddr_CALLBACK Callback); +void vkGetDeviceProcAddr_Stub(CMOCK_vkGetDeviceProcAddr_CALLBACK Callback); +#define vkGetDeviceProcAddr_StubWithCallback vkGetDeviceProcAddr_AddCallback +#define vkGetDeviceProcAddr_IgnoreArg_device() vkGetDeviceProcAddr_CMockIgnoreArg_device(__LINE__) +void vkGetDeviceProcAddr_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceProcAddr_IgnoreArg_pName() vkGetDeviceProcAddr_CMockIgnoreArg_pName(__LINE__) +void vkGetDeviceProcAddr_CMockIgnoreArg_pName(UNITY_LINE_TYPE cmock_line); +#define vkCreateDevice_IgnoreAndReturn(cmock_retval) vkCreateDevice_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateDevice_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateDevice_StopIgnore() vkCreateDevice_CMockStopIgnore() +void vkCreateDevice_CMockStopIgnore(void); +#define vkCreateDevice_ExpectAnyArgsAndReturn(cmock_retval) vkCreateDevice_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateDevice_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateDevice_ExpectAndReturn(physicalDevice, pCreateInfo, pAllocator, pDevice, cmock_retval) vkCreateDevice_CMockExpectAndReturn(__LINE__, physicalDevice, pCreateInfo, pAllocator, pDevice, cmock_retval) +void vkCreateDevice_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateDevice_CALLBACK)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice, int cmock_num_calls); +void vkCreateDevice_AddCallback(CMOCK_vkCreateDevice_CALLBACK Callback); +void vkCreateDevice_Stub(CMOCK_vkCreateDevice_CALLBACK Callback); +#define vkCreateDevice_StubWithCallback vkCreateDevice_AddCallback +#define vkCreateDevice_ReturnThruPtr_pDevice(pDevice) vkCreateDevice_CMockReturnMemThruPtr_pDevice(__LINE__, pDevice, sizeof(VkDevice)) +#define vkCreateDevice_ReturnArrayThruPtr_pDevice(pDevice, cmock_len) vkCreateDevice_CMockReturnMemThruPtr_pDevice(__LINE__, pDevice, cmock_len * sizeof(*pDevice)) +#define vkCreateDevice_ReturnMemThruPtr_pDevice(pDevice, cmock_size) vkCreateDevice_CMockReturnMemThruPtr_pDevice(__LINE__, pDevice, cmock_size) +void vkCreateDevice_CMockReturnMemThruPtr_pDevice(UNITY_LINE_TYPE cmock_line, VkDevice const* pDevice, size_t cmock_size); +#define vkCreateDevice_IgnoreArg_physicalDevice() vkCreateDevice_CMockIgnoreArg_physicalDevice(__LINE__) +void vkCreateDevice_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkCreateDevice_IgnoreArg_pCreateInfo() vkCreateDevice_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateDevice_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateDevice_IgnoreArg_pAllocator() vkCreateDevice_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateDevice_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateDevice_IgnoreArg_pDevice() vkCreateDevice_CMockIgnoreArg_pDevice(__LINE__) +void vkCreateDevice_CMockIgnoreArg_pDevice(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDevice_Ignore() vkDestroyDevice_CMockIgnore() +void vkDestroyDevice_CMockIgnore(void); +#define vkDestroyDevice_StopIgnore() vkDestroyDevice_CMockStopIgnore() +void vkDestroyDevice_CMockStopIgnore(void); +#define vkDestroyDevice_ExpectAnyArgs() vkDestroyDevice_CMockExpectAnyArgs(__LINE__) +void vkDestroyDevice_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDevice_Expect(device, pAllocator) vkDestroyDevice_CMockExpect(__LINE__, device, pAllocator) +void vkDestroyDevice_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyDevice_CALLBACK)(VkDevice device, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyDevice_AddCallback(CMOCK_vkDestroyDevice_CALLBACK Callback); +void vkDestroyDevice_Stub(CMOCK_vkDestroyDevice_CALLBACK Callback); +#define vkDestroyDevice_StubWithCallback vkDestroyDevice_AddCallback +#define vkDestroyDevice_IgnoreArg_device() vkDestroyDevice_CMockIgnoreArg_device(__LINE__) +void vkDestroyDevice_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDevice_IgnoreArg_pAllocator() vkDestroyDevice_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyDevice_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkEnumerateInstanceExtensionProperties_IgnoreAndReturn(cmock_retval) vkEnumerateInstanceExtensionProperties_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkEnumerateInstanceExtensionProperties_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkEnumerateInstanceExtensionProperties_StopIgnore() vkEnumerateInstanceExtensionProperties_CMockStopIgnore() +void vkEnumerateInstanceExtensionProperties_CMockStopIgnore(void); +#define vkEnumerateInstanceExtensionProperties_ExpectAnyArgsAndReturn(cmock_retval) vkEnumerateInstanceExtensionProperties_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkEnumerateInstanceExtensionProperties_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkEnumerateInstanceExtensionProperties_ExpectAndReturn(pLayerName, pPropertyCount, pProperties, cmock_retval) vkEnumerateInstanceExtensionProperties_CMockExpectAndReturn(__LINE__, pLayerName, pPropertyCount, pProperties, cmock_retval) +void vkEnumerateInstanceExtensionProperties_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkEnumerateInstanceExtensionProperties_CALLBACK)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties, int cmock_num_calls); +void vkEnumerateInstanceExtensionProperties_AddCallback(CMOCK_vkEnumerateInstanceExtensionProperties_CALLBACK Callback); +void vkEnumerateInstanceExtensionProperties_Stub(CMOCK_vkEnumerateInstanceExtensionProperties_CALLBACK Callback); +#define vkEnumerateInstanceExtensionProperties_StubWithCallback vkEnumerateInstanceExtensionProperties_AddCallback +#define vkEnumerateInstanceExtensionProperties_ReturnThruPtr_pPropertyCount(pPropertyCount) vkEnumerateInstanceExtensionProperties_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, sizeof(uint32_t)) +#define vkEnumerateInstanceExtensionProperties_ReturnArrayThruPtr_pPropertyCount(pPropertyCount, cmock_len) vkEnumerateInstanceExtensionProperties_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, cmock_len * sizeof(*pPropertyCount)) +#define vkEnumerateInstanceExtensionProperties_ReturnMemThruPtr_pPropertyCount(pPropertyCount, cmock_size) vkEnumerateInstanceExtensionProperties_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, cmock_size) +void vkEnumerateInstanceExtensionProperties_CMockReturnMemThruPtr_pPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPropertyCount, size_t cmock_size); +#define vkEnumerateInstanceExtensionProperties_ReturnThruPtr_pProperties(pProperties) vkEnumerateInstanceExtensionProperties_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, sizeof(VkExtensionProperties)) +#define vkEnumerateInstanceExtensionProperties_ReturnArrayThruPtr_pProperties(pProperties, cmock_len) vkEnumerateInstanceExtensionProperties_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_len * sizeof(*pProperties)) +#define vkEnumerateInstanceExtensionProperties_ReturnMemThruPtr_pProperties(pProperties, cmock_size) vkEnumerateInstanceExtensionProperties_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_size) +void vkEnumerateInstanceExtensionProperties_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkExtensionProperties const* pProperties, size_t cmock_size); +#define vkEnumerateInstanceExtensionProperties_IgnoreArg_pLayerName() vkEnumerateInstanceExtensionProperties_CMockIgnoreArg_pLayerName(__LINE__) +void vkEnumerateInstanceExtensionProperties_CMockIgnoreArg_pLayerName(UNITY_LINE_TYPE cmock_line); +#define vkEnumerateInstanceExtensionProperties_IgnoreArg_pPropertyCount() vkEnumerateInstanceExtensionProperties_CMockIgnoreArg_pPropertyCount(__LINE__) +void vkEnumerateInstanceExtensionProperties_CMockIgnoreArg_pPropertyCount(UNITY_LINE_TYPE cmock_line); +#define vkEnumerateInstanceExtensionProperties_IgnoreArg_pProperties() vkEnumerateInstanceExtensionProperties_CMockIgnoreArg_pProperties(__LINE__) +void vkEnumerateInstanceExtensionProperties_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line); +#define vkEnumerateDeviceExtensionProperties_IgnoreAndReturn(cmock_retval) vkEnumerateDeviceExtensionProperties_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkEnumerateDeviceExtensionProperties_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkEnumerateDeviceExtensionProperties_StopIgnore() vkEnumerateDeviceExtensionProperties_CMockStopIgnore() +void vkEnumerateDeviceExtensionProperties_CMockStopIgnore(void); +#define vkEnumerateDeviceExtensionProperties_ExpectAnyArgsAndReturn(cmock_retval) vkEnumerateDeviceExtensionProperties_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkEnumerateDeviceExtensionProperties_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkEnumerateDeviceExtensionProperties_ExpectAndReturn(physicalDevice, pLayerName, pPropertyCount, pProperties, cmock_retval) vkEnumerateDeviceExtensionProperties_CMockExpectAndReturn(__LINE__, physicalDevice, pLayerName, pPropertyCount, pProperties, cmock_retval) +void vkEnumerateDeviceExtensionProperties_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkEnumerateDeviceExtensionProperties_CALLBACK)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties, int cmock_num_calls); +void vkEnumerateDeviceExtensionProperties_AddCallback(CMOCK_vkEnumerateDeviceExtensionProperties_CALLBACK Callback); +void vkEnumerateDeviceExtensionProperties_Stub(CMOCK_vkEnumerateDeviceExtensionProperties_CALLBACK Callback); +#define vkEnumerateDeviceExtensionProperties_StubWithCallback vkEnumerateDeviceExtensionProperties_AddCallback +#define vkEnumerateDeviceExtensionProperties_ReturnThruPtr_pPropertyCount(pPropertyCount) vkEnumerateDeviceExtensionProperties_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, sizeof(uint32_t)) +#define vkEnumerateDeviceExtensionProperties_ReturnArrayThruPtr_pPropertyCount(pPropertyCount, cmock_len) vkEnumerateDeviceExtensionProperties_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, cmock_len * sizeof(*pPropertyCount)) +#define vkEnumerateDeviceExtensionProperties_ReturnMemThruPtr_pPropertyCount(pPropertyCount, cmock_size) vkEnumerateDeviceExtensionProperties_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, cmock_size) +void vkEnumerateDeviceExtensionProperties_CMockReturnMemThruPtr_pPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPropertyCount, size_t cmock_size); +#define vkEnumerateDeviceExtensionProperties_ReturnThruPtr_pProperties(pProperties) vkEnumerateDeviceExtensionProperties_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, sizeof(VkExtensionProperties)) +#define vkEnumerateDeviceExtensionProperties_ReturnArrayThruPtr_pProperties(pProperties, cmock_len) vkEnumerateDeviceExtensionProperties_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_len * sizeof(*pProperties)) +#define vkEnumerateDeviceExtensionProperties_ReturnMemThruPtr_pProperties(pProperties, cmock_size) vkEnumerateDeviceExtensionProperties_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_size) +void vkEnumerateDeviceExtensionProperties_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkExtensionProperties const* pProperties, size_t cmock_size); +#define vkEnumerateDeviceExtensionProperties_IgnoreArg_physicalDevice() vkEnumerateDeviceExtensionProperties_CMockIgnoreArg_physicalDevice(__LINE__) +void vkEnumerateDeviceExtensionProperties_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkEnumerateDeviceExtensionProperties_IgnoreArg_pLayerName() vkEnumerateDeviceExtensionProperties_CMockIgnoreArg_pLayerName(__LINE__) +void vkEnumerateDeviceExtensionProperties_CMockIgnoreArg_pLayerName(UNITY_LINE_TYPE cmock_line); +#define vkEnumerateDeviceExtensionProperties_IgnoreArg_pPropertyCount() vkEnumerateDeviceExtensionProperties_CMockIgnoreArg_pPropertyCount(__LINE__) +void vkEnumerateDeviceExtensionProperties_CMockIgnoreArg_pPropertyCount(UNITY_LINE_TYPE cmock_line); +#define vkEnumerateDeviceExtensionProperties_IgnoreArg_pProperties() vkEnumerateDeviceExtensionProperties_CMockIgnoreArg_pProperties(__LINE__) +void vkEnumerateDeviceExtensionProperties_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line); +#define vkEnumerateInstanceLayerProperties_IgnoreAndReturn(cmock_retval) vkEnumerateInstanceLayerProperties_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkEnumerateInstanceLayerProperties_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkEnumerateInstanceLayerProperties_StopIgnore() vkEnumerateInstanceLayerProperties_CMockStopIgnore() +void vkEnumerateInstanceLayerProperties_CMockStopIgnore(void); +#define vkEnumerateInstanceLayerProperties_ExpectAnyArgsAndReturn(cmock_retval) vkEnumerateInstanceLayerProperties_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkEnumerateInstanceLayerProperties_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkEnumerateInstanceLayerProperties_ExpectAndReturn(pPropertyCount, pProperties, cmock_retval) vkEnumerateInstanceLayerProperties_CMockExpectAndReturn(__LINE__, pPropertyCount, pProperties, cmock_retval) +void vkEnumerateInstanceLayerProperties_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, uint32_t* pPropertyCount, VkLayerProperties* pProperties, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkEnumerateInstanceLayerProperties_CALLBACK)(uint32_t* pPropertyCount, VkLayerProperties* pProperties, int cmock_num_calls); +void vkEnumerateInstanceLayerProperties_AddCallback(CMOCK_vkEnumerateInstanceLayerProperties_CALLBACK Callback); +void vkEnumerateInstanceLayerProperties_Stub(CMOCK_vkEnumerateInstanceLayerProperties_CALLBACK Callback); +#define vkEnumerateInstanceLayerProperties_StubWithCallback vkEnumerateInstanceLayerProperties_AddCallback +#define vkEnumerateInstanceLayerProperties_ReturnThruPtr_pPropertyCount(pPropertyCount) vkEnumerateInstanceLayerProperties_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, sizeof(uint32_t)) +#define vkEnumerateInstanceLayerProperties_ReturnArrayThruPtr_pPropertyCount(pPropertyCount, cmock_len) vkEnumerateInstanceLayerProperties_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, cmock_len * sizeof(*pPropertyCount)) +#define vkEnumerateInstanceLayerProperties_ReturnMemThruPtr_pPropertyCount(pPropertyCount, cmock_size) vkEnumerateInstanceLayerProperties_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, cmock_size) +void vkEnumerateInstanceLayerProperties_CMockReturnMemThruPtr_pPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPropertyCount, size_t cmock_size); +#define vkEnumerateInstanceLayerProperties_ReturnThruPtr_pProperties(pProperties) vkEnumerateInstanceLayerProperties_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, sizeof(VkLayerProperties)) +#define vkEnumerateInstanceLayerProperties_ReturnArrayThruPtr_pProperties(pProperties, cmock_len) vkEnumerateInstanceLayerProperties_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_len * sizeof(*pProperties)) +#define vkEnumerateInstanceLayerProperties_ReturnMemThruPtr_pProperties(pProperties, cmock_size) vkEnumerateInstanceLayerProperties_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_size) +void vkEnumerateInstanceLayerProperties_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkLayerProperties const* pProperties, size_t cmock_size); +#define vkEnumerateInstanceLayerProperties_IgnoreArg_pPropertyCount() vkEnumerateInstanceLayerProperties_CMockIgnoreArg_pPropertyCount(__LINE__) +void vkEnumerateInstanceLayerProperties_CMockIgnoreArg_pPropertyCount(UNITY_LINE_TYPE cmock_line); +#define vkEnumerateInstanceLayerProperties_IgnoreArg_pProperties() vkEnumerateInstanceLayerProperties_CMockIgnoreArg_pProperties(__LINE__) +void vkEnumerateInstanceLayerProperties_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line); +#define vkEnumerateDeviceLayerProperties_IgnoreAndReturn(cmock_retval) vkEnumerateDeviceLayerProperties_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkEnumerateDeviceLayerProperties_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkEnumerateDeviceLayerProperties_StopIgnore() vkEnumerateDeviceLayerProperties_CMockStopIgnore() +void vkEnumerateDeviceLayerProperties_CMockStopIgnore(void); +#define vkEnumerateDeviceLayerProperties_ExpectAnyArgsAndReturn(cmock_retval) vkEnumerateDeviceLayerProperties_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkEnumerateDeviceLayerProperties_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkEnumerateDeviceLayerProperties_ExpectAndReturn(physicalDevice, pPropertyCount, pProperties, cmock_retval) vkEnumerateDeviceLayerProperties_CMockExpectAndReturn(__LINE__, physicalDevice, pPropertyCount, pProperties, cmock_retval) +void vkEnumerateDeviceLayerProperties_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkEnumerateDeviceLayerProperties_CALLBACK)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties, int cmock_num_calls); +void vkEnumerateDeviceLayerProperties_AddCallback(CMOCK_vkEnumerateDeviceLayerProperties_CALLBACK Callback); +void vkEnumerateDeviceLayerProperties_Stub(CMOCK_vkEnumerateDeviceLayerProperties_CALLBACK Callback); +#define vkEnumerateDeviceLayerProperties_StubWithCallback vkEnumerateDeviceLayerProperties_AddCallback +#define vkEnumerateDeviceLayerProperties_ReturnThruPtr_pPropertyCount(pPropertyCount) vkEnumerateDeviceLayerProperties_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, sizeof(uint32_t)) +#define vkEnumerateDeviceLayerProperties_ReturnArrayThruPtr_pPropertyCount(pPropertyCount, cmock_len) vkEnumerateDeviceLayerProperties_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, cmock_len * sizeof(*pPropertyCount)) +#define vkEnumerateDeviceLayerProperties_ReturnMemThruPtr_pPropertyCount(pPropertyCount, cmock_size) vkEnumerateDeviceLayerProperties_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, cmock_size) +void vkEnumerateDeviceLayerProperties_CMockReturnMemThruPtr_pPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPropertyCount, size_t cmock_size); +#define vkEnumerateDeviceLayerProperties_ReturnThruPtr_pProperties(pProperties) vkEnumerateDeviceLayerProperties_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, sizeof(VkLayerProperties)) +#define vkEnumerateDeviceLayerProperties_ReturnArrayThruPtr_pProperties(pProperties, cmock_len) vkEnumerateDeviceLayerProperties_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_len * sizeof(*pProperties)) +#define vkEnumerateDeviceLayerProperties_ReturnMemThruPtr_pProperties(pProperties, cmock_size) vkEnumerateDeviceLayerProperties_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_size) +void vkEnumerateDeviceLayerProperties_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkLayerProperties const* pProperties, size_t cmock_size); +#define vkEnumerateDeviceLayerProperties_IgnoreArg_physicalDevice() vkEnumerateDeviceLayerProperties_CMockIgnoreArg_physicalDevice(__LINE__) +void vkEnumerateDeviceLayerProperties_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkEnumerateDeviceLayerProperties_IgnoreArg_pPropertyCount() vkEnumerateDeviceLayerProperties_CMockIgnoreArg_pPropertyCount(__LINE__) +void vkEnumerateDeviceLayerProperties_CMockIgnoreArg_pPropertyCount(UNITY_LINE_TYPE cmock_line); +#define vkEnumerateDeviceLayerProperties_IgnoreArg_pProperties() vkEnumerateDeviceLayerProperties_CMockIgnoreArg_pProperties(__LINE__) +void vkEnumerateDeviceLayerProperties_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceQueue_Ignore() vkGetDeviceQueue_CMockIgnore() +void vkGetDeviceQueue_CMockIgnore(void); +#define vkGetDeviceQueue_StopIgnore() vkGetDeviceQueue_CMockStopIgnore() +void vkGetDeviceQueue_CMockStopIgnore(void); +#define vkGetDeviceQueue_ExpectAnyArgs() vkGetDeviceQueue_CMockExpectAnyArgs(__LINE__) +void vkGetDeviceQueue_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceQueue_Expect(device, queueFamilyIndex, queueIndex, pQueue) vkGetDeviceQueue_CMockExpect(__LINE__, device, queueFamilyIndex, queueIndex, pQueue) +void vkGetDeviceQueue_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); +typedef void (* CMOCK_vkGetDeviceQueue_CALLBACK)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue, int cmock_num_calls); +void vkGetDeviceQueue_AddCallback(CMOCK_vkGetDeviceQueue_CALLBACK Callback); +void vkGetDeviceQueue_Stub(CMOCK_vkGetDeviceQueue_CALLBACK Callback); +#define vkGetDeviceQueue_StubWithCallback vkGetDeviceQueue_AddCallback +#define vkGetDeviceQueue_ReturnThruPtr_pQueue(pQueue) vkGetDeviceQueue_CMockReturnMemThruPtr_pQueue(__LINE__, pQueue, sizeof(VkQueue)) +#define vkGetDeviceQueue_ReturnArrayThruPtr_pQueue(pQueue, cmock_len) vkGetDeviceQueue_CMockReturnMemThruPtr_pQueue(__LINE__, pQueue, cmock_len * sizeof(*pQueue)) +#define vkGetDeviceQueue_ReturnMemThruPtr_pQueue(pQueue, cmock_size) vkGetDeviceQueue_CMockReturnMemThruPtr_pQueue(__LINE__, pQueue, cmock_size) +void vkGetDeviceQueue_CMockReturnMemThruPtr_pQueue(UNITY_LINE_TYPE cmock_line, VkQueue const* pQueue, size_t cmock_size); +#define vkGetDeviceQueue_IgnoreArg_device() vkGetDeviceQueue_CMockIgnoreArg_device(__LINE__) +void vkGetDeviceQueue_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceQueue_IgnoreArg_queueFamilyIndex() vkGetDeviceQueue_CMockIgnoreArg_queueFamilyIndex(__LINE__) +void vkGetDeviceQueue_CMockIgnoreArg_queueFamilyIndex(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceQueue_IgnoreArg_queueIndex() vkGetDeviceQueue_CMockIgnoreArg_queueIndex(__LINE__) +void vkGetDeviceQueue_CMockIgnoreArg_queueIndex(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceQueue_IgnoreArg_pQueue() vkGetDeviceQueue_CMockIgnoreArg_pQueue(__LINE__) +void vkGetDeviceQueue_CMockIgnoreArg_pQueue(UNITY_LINE_TYPE cmock_line); +#define vkQueueSubmit_IgnoreAndReturn(cmock_retval) vkQueueSubmit_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkQueueSubmit_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkQueueSubmit_StopIgnore() vkQueueSubmit_CMockStopIgnore() +void vkQueueSubmit_CMockStopIgnore(void); +#define vkQueueSubmit_ExpectAnyArgsAndReturn(cmock_retval) vkQueueSubmit_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkQueueSubmit_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkQueueSubmit_ExpectAndReturn(queue, submitCount, pSubmits, fence, cmock_retval) vkQueueSubmit_CMockExpectAndReturn(__LINE__, queue, submitCount, pSubmits, fence, cmock_retval) +void vkQueueSubmit_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkQueueSubmit_CALLBACK)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence, int cmock_num_calls); +void vkQueueSubmit_AddCallback(CMOCK_vkQueueSubmit_CALLBACK Callback); +void vkQueueSubmit_Stub(CMOCK_vkQueueSubmit_CALLBACK Callback); +#define vkQueueSubmit_StubWithCallback vkQueueSubmit_AddCallback +#define vkQueueSubmit_IgnoreArg_queue() vkQueueSubmit_CMockIgnoreArg_queue(__LINE__) +void vkQueueSubmit_CMockIgnoreArg_queue(UNITY_LINE_TYPE cmock_line); +#define vkQueueSubmit_IgnoreArg_submitCount() vkQueueSubmit_CMockIgnoreArg_submitCount(__LINE__) +void vkQueueSubmit_CMockIgnoreArg_submitCount(UNITY_LINE_TYPE cmock_line); +#define vkQueueSubmit_IgnoreArg_pSubmits() vkQueueSubmit_CMockIgnoreArg_pSubmits(__LINE__) +void vkQueueSubmit_CMockIgnoreArg_pSubmits(UNITY_LINE_TYPE cmock_line); +#define vkQueueSubmit_IgnoreArg_fence() vkQueueSubmit_CMockIgnoreArg_fence(__LINE__) +void vkQueueSubmit_CMockIgnoreArg_fence(UNITY_LINE_TYPE cmock_line); +#define vkQueueWaitIdle_IgnoreAndReturn(cmock_retval) vkQueueWaitIdle_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkQueueWaitIdle_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkQueueWaitIdle_StopIgnore() vkQueueWaitIdle_CMockStopIgnore() +void vkQueueWaitIdle_CMockStopIgnore(void); +#define vkQueueWaitIdle_ExpectAnyArgsAndReturn(cmock_retval) vkQueueWaitIdle_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkQueueWaitIdle_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkQueueWaitIdle_ExpectAndReturn(queue, cmock_retval) vkQueueWaitIdle_CMockExpectAndReturn(__LINE__, queue, cmock_retval) +void vkQueueWaitIdle_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkQueue queue, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkQueueWaitIdle_CALLBACK)(VkQueue queue, int cmock_num_calls); +void vkQueueWaitIdle_AddCallback(CMOCK_vkQueueWaitIdle_CALLBACK Callback); +void vkQueueWaitIdle_Stub(CMOCK_vkQueueWaitIdle_CALLBACK Callback); +#define vkQueueWaitIdle_StubWithCallback vkQueueWaitIdle_AddCallback +#define vkQueueWaitIdle_IgnoreArg_queue() vkQueueWaitIdle_CMockIgnoreArg_queue(__LINE__) +void vkQueueWaitIdle_CMockIgnoreArg_queue(UNITY_LINE_TYPE cmock_line); +#define vkDeviceWaitIdle_IgnoreAndReturn(cmock_retval) vkDeviceWaitIdle_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkDeviceWaitIdle_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkDeviceWaitIdle_StopIgnore() vkDeviceWaitIdle_CMockStopIgnore() +void vkDeviceWaitIdle_CMockStopIgnore(void); +#define vkDeviceWaitIdle_ExpectAnyArgsAndReturn(cmock_retval) vkDeviceWaitIdle_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkDeviceWaitIdle_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkDeviceWaitIdle_ExpectAndReturn(device, cmock_retval) vkDeviceWaitIdle_CMockExpectAndReturn(__LINE__, device, cmock_retval) +void vkDeviceWaitIdle_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkDeviceWaitIdle_CALLBACK)(VkDevice device, int cmock_num_calls); +void vkDeviceWaitIdle_AddCallback(CMOCK_vkDeviceWaitIdle_CALLBACK Callback); +void vkDeviceWaitIdle_Stub(CMOCK_vkDeviceWaitIdle_CALLBACK Callback); +#define vkDeviceWaitIdle_StubWithCallback vkDeviceWaitIdle_AddCallback +#define vkDeviceWaitIdle_IgnoreArg_device() vkDeviceWaitIdle_CMockIgnoreArg_device(__LINE__) +void vkDeviceWaitIdle_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkAllocateMemory_IgnoreAndReturn(cmock_retval) vkAllocateMemory_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkAllocateMemory_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkAllocateMemory_StopIgnore() vkAllocateMemory_CMockStopIgnore() +void vkAllocateMemory_CMockStopIgnore(void); +#define vkAllocateMemory_ExpectAnyArgsAndReturn(cmock_retval) vkAllocateMemory_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkAllocateMemory_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkAllocateMemory_ExpectAndReturn(device, pAllocateInfo, pAllocator, pMemory, cmock_retval) vkAllocateMemory_CMockExpectAndReturn(__LINE__, device, pAllocateInfo, pAllocator, pMemory, cmock_retval) +void vkAllocateMemory_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkAllocateMemory_CALLBACK)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory, int cmock_num_calls); +void vkAllocateMemory_AddCallback(CMOCK_vkAllocateMemory_CALLBACK Callback); +void vkAllocateMemory_Stub(CMOCK_vkAllocateMemory_CALLBACK Callback); +#define vkAllocateMemory_StubWithCallback vkAllocateMemory_AddCallback +#define vkAllocateMemory_ReturnThruPtr_pMemory(pMemory) vkAllocateMemory_CMockReturnMemThruPtr_pMemory(__LINE__, pMemory, sizeof(VkDeviceMemory)) +#define vkAllocateMemory_ReturnArrayThruPtr_pMemory(pMemory, cmock_len) vkAllocateMemory_CMockReturnMemThruPtr_pMemory(__LINE__, pMemory, cmock_len * sizeof(*pMemory)) +#define vkAllocateMemory_ReturnMemThruPtr_pMemory(pMemory, cmock_size) vkAllocateMemory_CMockReturnMemThruPtr_pMemory(__LINE__, pMemory, cmock_size) +void vkAllocateMemory_CMockReturnMemThruPtr_pMemory(UNITY_LINE_TYPE cmock_line, VkDeviceMemory const* pMemory, size_t cmock_size); +#define vkAllocateMemory_IgnoreArg_device() vkAllocateMemory_CMockIgnoreArg_device(__LINE__) +void vkAllocateMemory_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkAllocateMemory_IgnoreArg_pAllocateInfo() vkAllocateMemory_CMockIgnoreArg_pAllocateInfo(__LINE__) +void vkAllocateMemory_CMockIgnoreArg_pAllocateInfo(UNITY_LINE_TYPE cmock_line); +#define vkAllocateMemory_IgnoreArg_pAllocator() vkAllocateMemory_CMockIgnoreArg_pAllocator(__LINE__) +void vkAllocateMemory_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkAllocateMemory_IgnoreArg_pMemory() vkAllocateMemory_CMockIgnoreArg_pMemory(__LINE__) +void vkAllocateMemory_CMockIgnoreArg_pMemory(UNITY_LINE_TYPE cmock_line); +#define vkFreeMemory_Ignore() vkFreeMemory_CMockIgnore() +void vkFreeMemory_CMockIgnore(void); +#define vkFreeMemory_StopIgnore() vkFreeMemory_CMockStopIgnore() +void vkFreeMemory_CMockStopIgnore(void); +#define vkFreeMemory_ExpectAnyArgs() vkFreeMemory_CMockExpectAnyArgs(__LINE__) +void vkFreeMemory_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkFreeMemory_Expect(device, memory, pAllocator) vkFreeMemory_CMockExpect(__LINE__, device, memory, pAllocator) +void vkFreeMemory_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkFreeMemory_CALLBACK)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkFreeMemory_AddCallback(CMOCK_vkFreeMemory_CALLBACK Callback); +void vkFreeMemory_Stub(CMOCK_vkFreeMemory_CALLBACK Callback); +#define vkFreeMemory_StubWithCallback vkFreeMemory_AddCallback +#define vkFreeMemory_IgnoreArg_device() vkFreeMemory_CMockIgnoreArg_device(__LINE__) +void vkFreeMemory_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkFreeMemory_IgnoreArg_memory() vkFreeMemory_CMockIgnoreArg_memory(__LINE__) +void vkFreeMemory_CMockIgnoreArg_memory(UNITY_LINE_TYPE cmock_line); +#define vkFreeMemory_IgnoreArg_pAllocator() vkFreeMemory_CMockIgnoreArg_pAllocator(__LINE__) +void vkFreeMemory_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkMapMemory_IgnoreAndReturn(cmock_retval) vkMapMemory_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkMapMemory_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkMapMemory_StopIgnore() vkMapMemory_CMockStopIgnore() +void vkMapMemory_CMockStopIgnore(void); +#define vkMapMemory_ExpectAnyArgsAndReturn(cmock_retval) vkMapMemory_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkMapMemory_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkMapMemory_ExpectAndReturn(device, memory, offset, size, flags, ppData, cmock_retval) vkMapMemory_CMockExpectAndReturn(__LINE__, device, memory, offset, size, flags, ppData, cmock_retval) +void vkMapMemory_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkMapMemory_CALLBACK)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData, int cmock_num_calls); +void vkMapMemory_AddCallback(CMOCK_vkMapMemory_CALLBACK Callback); +void vkMapMemory_Stub(CMOCK_vkMapMemory_CALLBACK Callback); +#define vkMapMemory_StubWithCallback vkMapMemory_AddCallback +#define vkMapMemory_ReturnThruPtr_ppData(ppData) vkMapMemory_CMockReturnMemThruPtr_ppData(__LINE__, ppData, sizeof(void*)) +#define vkMapMemory_ReturnArrayThruPtr_ppData(ppData, cmock_len) vkMapMemory_CMockReturnMemThruPtr_ppData(__LINE__, ppData, cmock_len * sizeof(*ppData)) +#define vkMapMemory_ReturnMemThruPtr_ppData(ppData, cmock_size) vkMapMemory_CMockReturnMemThruPtr_ppData(__LINE__, ppData, cmock_size) +void vkMapMemory_CMockReturnMemThruPtr_ppData(UNITY_LINE_TYPE cmock_line, void* const* ppData, size_t cmock_size); +#define vkMapMemory_IgnoreArg_device() vkMapMemory_CMockIgnoreArg_device(__LINE__) +void vkMapMemory_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkMapMemory_IgnoreArg_memory() vkMapMemory_CMockIgnoreArg_memory(__LINE__) +void vkMapMemory_CMockIgnoreArg_memory(UNITY_LINE_TYPE cmock_line); +#define vkMapMemory_IgnoreArg_offset() vkMapMemory_CMockIgnoreArg_offset(__LINE__) +void vkMapMemory_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line); +#define vkMapMemory_IgnoreArg_size() vkMapMemory_CMockIgnoreArg_size(__LINE__) +void vkMapMemory_CMockIgnoreArg_size(UNITY_LINE_TYPE cmock_line); +#define vkMapMemory_IgnoreArg_flags() vkMapMemory_CMockIgnoreArg_flags(__LINE__) +void vkMapMemory_CMockIgnoreArg_flags(UNITY_LINE_TYPE cmock_line); +#define vkMapMemory_IgnoreArg_ppData() vkMapMemory_CMockIgnoreArg_ppData(__LINE__) +void vkMapMemory_CMockIgnoreArg_ppData(UNITY_LINE_TYPE cmock_line); +#define vkUnmapMemory_Ignore() vkUnmapMemory_CMockIgnore() +void vkUnmapMemory_CMockIgnore(void); +#define vkUnmapMemory_StopIgnore() vkUnmapMemory_CMockStopIgnore() +void vkUnmapMemory_CMockStopIgnore(void); +#define vkUnmapMemory_ExpectAnyArgs() vkUnmapMemory_CMockExpectAnyArgs(__LINE__) +void vkUnmapMemory_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkUnmapMemory_Expect(device, memory) vkUnmapMemory_CMockExpect(__LINE__, device, memory) +void vkUnmapMemory_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeviceMemory memory); +typedef void (* CMOCK_vkUnmapMemory_CALLBACK)(VkDevice device, VkDeviceMemory memory, int cmock_num_calls); +void vkUnmapMemory_AddCallback(CMOCK_vkUnmapMemory_CALLBACK Callback); +void vkUnmapMemory_Stub(CMOCK_vkUnmapMemory_CALLBACK Callback); +#define vkUnmapMemory_StubWithCallback vkUnmapMemory_AddCallback +#define vkUnmapMemory_IgnoreArg_device() vkUnmapMemory_CMockIgnoreArg_device(__LINE__) +void vkUnmapMemory_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkUnmapMemory_IgnoreArg_memory() vkUnmapMemory_CMockIgnoreArg_memory(__LINE__) +void vkUnmapMemory_CMockIgnoreArg_memory(UNITY_LINE_TYPE cmock_line); +#define vkFlushMappedMemoryRanges_IgnoreAndReturn(cmock_retval) vkFlushMappedMemoryRanges_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkFlushMappedMemoryRanges_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkFlushMappedMemoryRanges_StopIgnore() vkFlushMappedMemoryRanges_CMockStopIgnore() +void vkFlushMappedMemoryRanges_CMockStopIgnore(void); +#define vkFlushMappedMemoryRanges_ExpectAnyArgsAndReturn(cmock_retval) vkFlushMappedMemoryRanges_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkFlushMappedMemoryRanges_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkFlushMappedMemoryRanges_ExpectAndReturn(device, memoryRangeCount, pMemoryRanges, cmock_retval) vkFlushMappedMemoryRanges_CMockExpectAndReturn(__LINE__, device, memoryRangeCount, pMemoryRanges, cmock_retval) +void vkFlushMappedMemoryRanges_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkFlushMappedMemoryRanges_CALLBACK)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges, int cmock_num_calls); +void vkFlushMappedMemoryRanges_AddCallback(CMOCK_vkFlushMappedMemoryRanges_CALLBACK Callback); +void vkFlushMappedMemoryRanges_Stub(CMOCK_vkFlushMappedMemoryRanges_CALLBACK Callback); +#define vkFlushMappedMemoryRanges_StubWithCallback vkFlushMappedMemoryRanges_AddCallback +#define vkFlushMappedMemoryRanges_IgnoreArg_device() vkFlushMappedMemoryRanges_CMockIgnoreArg_device(__LINE__) +void vkFlushMappedMemoryRanges_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkFlushMappedMemoryRanges_IgnoreArg_memoryRangeCount() vkFlushMappedMemoryRanges_CMockIgnoreArg_memoryRangeCount(__LINE__) +void vkFlushMappedMemoryRanges_CMockIgnoreArg_memoryRangeCount(UNITY_LINE_TYPE cmock_line); +#define vkFlushMappedMemoryRanges_IgnoreArg_pMemoryRanges() vkFlushMappedMemoryRanges_CMockIgnoreArg_pMemoryRanges(__LINE__) +void vkFlushMappedMemoryRanges_CMockIgnoreArg_pMemoryRanges(UNITY_LINE_TYPE cmock_line); +#define vkInvalidateMappedMemoryRanges_IgnoreAndReturn(cmock_retval) vkInvalidateMappedMemoryRanges_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkInvalidateMappedMemoryRanges_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkInvalidateMappedMemoryRanges_StopIgnore() vkInvalidateMappedMemoryRanges_CMockStopIgnore() +void vkInvalidateMappedMemoryRanges_CMockStopIgnore(void); +#define vkInvalidateMappedMemoryRanges_ExpectAnyArgsAndReturn(cmock_retval) vkInvalidateMappedMemoryRanges_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkInvalidateMappedMemoryRanges_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkInvalidateMappedMemoryRanges_ExpectAndReturn(device, memoryRangeCount, pMemoryRanges, cmock_retval) vkInvalidateMappedMemoryRanges_CMockExpectAndReturn(__LINE__, device, memoryRangeCount, pMemoryRanges, cmock_retval) +void vkInvalidateMappedMemoryRanges_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkInvalidateMappedMemoryRanges_CALLBACK)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges, int cmock_num_calls); +void vkInvalidateMappedMemoryRanges_AddCallback(CMOCK_vkInvalidateMappedMemoryRanges_CALLBACK Callback); +void vkInvalidateMappedMemoryRanges_Stub(CMOCK_vkInvalidateMappedMemoryRanges_CALLBACK Callback); +#define vkInvalidateMappedMemoryRanges_StubWithCallback vkInvalidateMappedMemoryRanges_AddCallback +#define vkInvalidateMappedMemoryRanges_IgnoreArg_device() vkInvalidateMappedMemoryRanges_CMockIgnoreArg_device(__LINE__) +void vkInvalidateMappedMemoryRanges_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkInvalidateMappedMemoryRanges_IgnoreArg_memoryRangeCount() vkInvalidateMappedMemoryRanges_CMockIgnoreArg_memoryRangeCount(__LINE__) +void vkInvalidateMappedMemoryRanges_CMockIgnoreArg_memoryRangeCount(UNITY_LINE_TYPE cmock_line); +#define vkInvalidateMappedMemoryRanges_IgnoreArg_pMemoryRanges() vkInvalidateMappedMemoryRanges_CMockIgnoreArg_pMemoryRanges(__LINE__) +void vkInvalidateMappedMemoryRanges_CMockIgnoreArg_pMemoryRanges(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceMemoryCommitment_Ignore() vkGetDeviceMemoryCommitment_CMockIgnore() +void vkGetDeviceMemoryCommitment_CMockIgnore(void); +#define vkGetDeviceMemoryCommitment_StopIgnore() vkGetDeviceMemoryCommitment_CMockStopIgnore() +void vkGetDeviceMemoryCommitment_CMockStopIgnore(void); +#define vkGetDeviceMemoryCommitment_ExpectAnyArgs() vkGetDeviceMemoryCommitment_CMockExpectAnyArgs(__LINE__) +void vkGetDeviceMemoryCommitment_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceMemoryCommitment_Expect(device, memory, pCommittedMemoryInBytes) vkGetDeviceMemoryCommitment_CMockExpect(__LINE__, device, memory, pCommittedMemoryInBytes) +void vkGetDeviceMemoryCommitment_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); +typedef void (* CMOCK_vkGetDeviceMemoryCommitment_CALLBACK)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes, int cmock_num_calls); +void vkGetDeviceMemoryCommitment_AddCallback(CMOCK_vkGetDeviceMemoryCommitment_CALLBACK Callback); +void vkGetDeviceMemoryCommitment_Stub(CMOCK_vkGetDeviceMemoryCommitment_CALLBACK Callback); +#define vkGetDeviceMemoryCommitment_StubWithCallback vkGetDeviceMemoryCommitment_AddCallback +#define vkGetDeviceMemoryCommitment_ReturnThruPtr_pCommittedMemoryInBytes(pCommittedMemoryInBytes) vkGetDeviceMemoryCommitment_CMockReturnMemThruPtr_pCommittedMemoryInBytes(__LINE__, pCommittedMemoryInBytes, sizeof(VkDeviceSize)) +#define vkGetDeviceMemoryCommitment_ReturnArrayThruPtr_pCommittedMemoryInBytes(pCommittedMemoryInBytes, cmock_len) vkGetDeviceMemoryCommitment_CMockReturnMemThruPtr_pCommittedMemoryInBytes(__LINE__, pCommittedMemoryInBytes, cmock_len * sizeof(*pCommittedMemoryInBytes)) +#define vkGetDeviceMemoryCommitment_ReturnMemThruPtr_pCommittedMemoryInBytes(pCommittedMemoryInBytes, cmock_size) vkGetDeviceMemoryCommitment_CMockReturnMemThruPtr_pCommittedMemoryInBytes(__LINE__, pCommittedMemoryInBytes, cmock_size) +void vkGetDeviceMemoryCommitment_CMockReturnMemThruPtr_pCommittedMemoryInBytes(UNITY_LINE_TYPE cmock_line, VkDeviceSize const* pCommittedMemoryInBytes, size_t cmock_size); +#define vkGetDeviceMemoryCommitment_IgnoreArg_device() vkGetDeviceMemoryCommitment_CMockIgnoreArg_device(__LINE__) +void vkGetDeviceMemoryCommitment_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceMemoryCommitment_IgnoreArg_memory() vkGetDeviceMemoryCommitment_CMockIgnoreArg_memory(__LINE__) +void vkGetDeviceMemoryCommitment_CMockIgnoreArg_memory(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceMemoryCommitment_IgnoreArg_pCommittedMemoryInBytes() vkGetDeviceMemoryCommitment_CMockIgnoreArg_pCommittedMemoryInBytes(__LINE__) +void vkGetDeviceMemoryCommitment_CMockIgnoreArg_pCommittedMemoryInBytes(UNITY_LINE_TYPE cmock_line); +#define vkBindBufferMemory_IgnoreAndReturn(cmock_retval) vkBindBufferMemory_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkBindBufferMemory_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkBindBufferMemory_StopIgnore() vkBindBufferMemory_CMockStopIgnore() +void vkBindBufferMemory_CMockStopIgnore(void); +#define vkBindBufferMemory_ExpectAnyArgsAndReturn(cmock_retval) vkBindBufferMemory_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkBindBufferMemory_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkBindBufferMemory_ExpectAndReturn(device, buffer, memory, memoryOffset, cmock_retval) vkBindBufferMemory_CMockExpectAndReturn(__LINE__, device, buffer, memory, memoryOffset, cmock_retval) +void vkBindBufferMemory_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkBindBufferMemory_CALLBACK)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset, int cmock_num_calls); +void vkBindBufferMemory_AddCallback(CMOCK_vkBindBufferMemory_CALLBACK Callback); +void vkBindBufferMemory_Stub(CMOCK_vkBindBufferMemory_CALLBACK Callback); +#define vkBindBufferMemory_StubWithCallback vkBindBufferMemory_AddCallback +#define vkBindBufferMemory_IgnoreArg_device() vkBindBufferMemory_CMockIgnoreArg_device(__LINE__) +void vkBindBufferMemory_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkBindBufferMemory_IgnoreArg_buffer() vkBindBufferMemory_CMockIgnoreArg_buffer(__LINE__) +void vkBindBufferMemory_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line); +#define vkBindBufferMemory_IgnoreArg_memory() vkBindBufferMemory_CMockIgnoreArg_memory(__LINE__) +void vkBindBufferMemory_CMockIgnoreArg_memory(UNITY_LINE_TYPE cmock_line); +#define vkBindBufferMemory_IgnoreArg_memoryOffset() vkBindBufferMemory_CMockIgnoreArg_memoryOffset(__LINE__) +void vkBindBufferMemory_CMockIgnoreArg_memoryOffset(UNITY_LINE_TYPE cmock_line); +#define vkBindImageMemory_IgnoreAndReturn(cmock_retval) vkBindImageMemory_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkBindImageMemory_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkBindImageMemory_StopIgnore() vkBindImageMemory_CMockStopIgnore() +void vkBindImageMemory_CMockStopIgnore(void); +#define vkBindImageMemory_ExpectAnyArgsAndReturn(cmock_retval) vkBindImageMemory_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkBindImageMemory_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkBindImageMemory_ExpectAndReturn(device, image, memory, memoryOffset, cmock_retval) vkBindImageMemory_CMockExpectAndReturn(__LINE__, device, image, memory, memoryOffset, cmock_retval) +void vkBindImageMemory_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkBindImageMemory_CALLBACK)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset, int cmock_num_calls); +void vkBindImageMemory_AddCallback(CMOCK_vkBindImageMemory_CALLBACK Callback); +void vkBindImageMemory_Stub(CMOCK_vkBindImageMemory_CALLBACK Callback); +#define vkBindImageMemory_StubWithCallback vkBindImageMemory_AddCallback +#define vkBindImageMemory_IgnoreArg_device() vkBindImageMemory_CMockIgnoreArg_device(__LINE__) +void vkBindImageMemory_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkBindImageMemory_IgnoreArg_image() vkBindImageMemory_CMockIgnoreArg_image(__LINE__) +void vkBindImageMemory_CMockIgnoreArg_image(UNITY_LINE_TYPE cmock_line); +#define vkBindImageMemory_IgnoreArg_memory() vkBindImageMemory_CMockIgnoreArg_memory(__LINE__) +void vkBindImageMemory_CMockIgnoreArg_memory(UNITY_LINE_TYPE cmock_line); +#define vkBindImageMemory_IgnoreArg_memoryOffset() vkBindImageMemory_CMockIgnoreArg_memoryOffset(__LINE__) +void vkBindImageMemory_CMockIgnoreArg_memoryOffset(UNITY_LINE_TYPE cmock_line); +#define vkGetBufferMemoryRequirements_Ignore() vkGetBufferMemoryRequirements_CMockIgnore() +void vkGetBufferMemoryRequirements_CMockIgnore(void); +#define vkGetBufferMemoryRequirements_StopIgnore() vkGetBufferMemoryRequirements_CMockStopIgnore() +void vkGetBufferMemoryRequirements_CMockStopIgnore(void); +#define vkGetBufferMemoryRequirements_ExpectAnyArgs() vkGetBufferMemoryRequirements_CMockExpectAnyArgs(__LINE__) +void vkGetBufferMemoryRequirements_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetBufferMemoryRequirements_Expect(device, buffer, pMemoryRequirements) vkGetBufferMemoryRequirements_CMockExpect(__LINE__, device, buffer, pMemoryRequirements) +void vkGetBufferMemoryRequirements_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); +typedef void (* CMOCK_vkGetBufferMemoryRequirements_CALLBACK)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements, int cmock_num_calls); +void vkGetBufferMemoryRequirements_AddCallback(CMOCK_vkGetBufferMemoryRequirements_CALLBACK Callback); +void vkGetBufferMemoryRequirements_Stub(CMOCK_vkGetBufferMemoryRequirements_CALLBACK Callback); +#define vkGetBufferMemoryRequirements_StubWithCallback vkGetBufferMemoryRequirements_AddCallback +#define vkGetBufferMemoryRequirements_ReturnThruPtr_pMemoryRequirements(pMemoryRequirements) vkGetBufferMemoryRequirements_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, sizeof(VkMemoryRequirements)) +#define vkGetBufferMemoryRequirements_ReturnArrayThruPtr_pMemoryRequirements(pMemoryRequirements, cmock_len) vkGetBufferMemoryRequirements_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, cmock_len * sizeof(*pMemoryRequirements)) +#define vkGetBufferMemoryRequirements_ReturnMemThruPtr_pMemoryRequirements(pMemoryRequirements, cmock_size) vkGetBufferMemoryRequirements_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, cmock_size) +void vkGetBufferMemoryRequirements_CMockReturnMemThruPtr_pMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkMemoryRequirements const* pMemoryRequirements, size_t cmock_size); +#define vkGetBufferMemoryRequirements_IgnoreArg_device() vkGetBufferMemoryRequirements_CMockIgnoreArg_device(__LINE__) +void vkGetBufferMemoryRequirements_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetBufferMemoryRequirements_IgnoreArg_buffer() vkGetBufferMemoryRequirements_CMockIgnoreArg_buffer(__LINE__) +void vkGetBufferMemoryRequirements_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line); +#define vkGetBufferMemoryRequirements_IgnoreArg_pMemoryRequirements() vkGetBufferMemoryRequirements_CMockIgnoreArg_pMemoryRequirements(__LINE__) +void vkGetBufferMemoryRequirements_CMockIgnoreArg_pMemoryRequirements(UNITY_LINE_TYPE cmock_line); +#define vkGetImageMemoryRequirements_Ignore() vkGetImageMemoryRequirements_CMockIgnore() +void vkGetImageMemoryRequirements_CMockIgnore(void); +#define vkGetImageMemoryRequirements_StopIgnore() vkGetImageMemoryRequirements_CMockStopIgnore() +void vkGetImageMemoryRequirements_CMockStopIgnore(void); +#define vkGetImageMemoryRequirements_ExpectAnyArgs() vkGetImageMemoryRequirements_CMockExpectAnyArgs(__LINE__) +void vkGetImageMemoryRequirements_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetImageMemoryRequirements_Expect(device, image, pMemoryRequirements) vkGetImageMemoryRequirements_CMockExpect(__LINE__, device, image, pMemoryRequirements) +void vkGetImageMemoryRequirements_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); +typedef void (* CMOCK_vkGetImageMemoryRequirements_CALLBACK)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements, int cmock_num_calls); +void vkGetImageMemoryRequirements_AddCallback(CMOCK_vkGetImageMemoryRequirements_CALLBACK Callback); +void vkGetImageMemoryRequirements_Stub(CMOCK_vkGetImageMemoryRequirements_CALLBACK Callback); +#define vkGetImageMemoryRequirements_StubWithCallback vkGetImageMemoryRequirements_AddCallback +#define vkGetImageMemoryRequirements_ReturnThruPtr_pMemoryRequirements(pMemoryRequirements) vkGetImageMemoryRequirements_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, sizeof(VkMemoryRequirements)) +#define vkGetImageMemoryRequirements_ReturnArrayThruPtr_pMemoryRequirements(pMemoryRequirements, cmock_len) vkGetImageMemoryRequirements_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, cmock_len * sizeof(*pMemoryRequirements)) +#define vkGetImageMemoryRequirements_ReturnMemThruPtr_pMemoryRequirements(pMemoryRequirements, cmock_size) vkGetImageMemoryRequirements_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, cmock_size) +void vkGetImageMemoryRequirements_CMockReturnMemThruPtr_pMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkMemoryRequirements const* pMemoryRequirements, size_t cmock_size); +#define vkGetImageMemoryRequirements_IgnoreArg_device() vkGetImageMemoryRequirements_CMockIgnoreArg_device(__LINE__) +void vkGetImageMemoryRequirements_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetImageMemoryRequirements_IgnoreArg_image() vkGetImageMemoryRequirements_CMockIgnoreArg_image(__LINE__) +void vkGetImageMemoryRequirements_CMockIgnoreArg_image(UNITY_LINE_TYPE cmock_line); +#define vkGetImageMemoryRequirements_IgnoreArg_pMemoryRequirements() vkGetImageMemoryRequirements_CMockIgnoreArg_pMemoryRequirements(__LINE__) +void vkGetImageMemoryRequirements_CMockIgnoreArg_pMemoryRequirements(UNITY_LINE_TYPE cmock_line); +#define vkGetImageSparseMemoryRequirements_Ignore() vkGetImageSparseMemoryRequirements_CMockIgnore() +void vkGetImageSparseMemoryRequirements_CMockIgnore(void); +#define vkGetImageSparseMemoryRequirements_StopIgnore() vkGetImageSparseMemoryRequirements_CMockStopIgnore() +void vkGetImageSparseMemoryRequirements_CMockStopIgnore(void); +#define vkGetImageSparseMemoryRequirements_ExpectAnyArgs() vkGetImageSparseMemoryRequirements_CMockExpectAnyArgs(__LINE__) +void vkGetImageSparseMemoryRequirements_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetImageSparseMemoryRequirements_Expect(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements) vkGetImageSparseMemoryRequirements_CMockExpect(__LINE__, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements) +void vkGetImageSparseMemoryRequirements_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements); +typedef void (* CMOCK_vkGetImageSparseMemoryRequirements_CALLBACK)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements, int cmock_num_calls); +void vkGetImageSparseMemoryRequirements_AddCallback(CMOCK_vkGetImageSparseMemoryRequirements_CALLBACK Callback); +void vkGetImageSparseMemoryRequirements_Stub(CMOCK_vkGetImageSparseMemoryRequirements_CALLBACK Callback); +#define vkGetImageSparseMemoryRequirements_StubWithCallback vkGetImageSparseMemoryRequirements_AddCallback +#define vkGetImageSparseMemoryRequirements_ReturnThruPtr_pSparseMemoryRequirementCount(pSparseMemoryRequirementCount) vkGetImageSparseMemoryRequirements_CMockReturnMemThruPtr_pSparseMemoryRequirementCount(__LINE__, pSparseMemoryRequirementCount, sizeof(uint32_t)) +#define vkGetImageSparseMemoryRequirements_ReturnArrayThruPtr_pSparseMemoryRequirementCount(pSparseMemoryRequirementCount, cmock_len) vkGetImageSparseMemoryRequirements_CMockReturnMemThruPtr_pSparseMemoryRequirementCount(__LINE__, pSparseMemoryRequirementCount, cmock_len * sizeof(*pSparseMemoryRequirementCount)) +#define vkGetImageSparseMemoryRequirements_ReturnMemThruPtr_pSparseMemoryRequirementCount(pSparseMemoryRequirementCount, cmock_size) vkGetImageSparseMemoryRequirements_CMockReturnMemThruPtr_pSparseMemoryRequirementCount(__LINE__, pSparseMemoryRequirementCount, cmock_size) +void vkGetImageSparseMemoryRequirements_CMockReturnMemThruPtr_pSparseMemoryRequirementCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pSparseMemoryRequirementCount, size_t cmock_size); +#define vkGetImageSparseMemoryRequirements_ReturnThruPtr_pSparseMemoryRequirements(pSparseMemoryRequirements) vkGetImageSparseMemoryRequirements_CMockReturnMemThruPtr_pSparseMemoryRequirements(__LINE__, pSparseMemoryRequirements, sizeof(VkSparseImageMemoryRequirements)) +#define vkGetImageSparseMemoryRequirements_ReturnArrayThruPtr_pSparseMemoryRequirements(pSparseMemoryRequirements, cmock_len) vkGetImageSparseMemoryRequirements_CMockReturnMemThruPtr_pSparseMemoryRequirements(__LINE__, pSparseMemoryRequirements, cmock_len * sizeof(*pSparseMemoryRequirements)) +#define vkGetImageSparseMemoryRequirements_ReturnMemThruPtr_pSparseMemoryRequirements(pSparseMemoryRequirements, cmock_size) vkGetImageSparseMemoryRequirements_CMockReturnMemThruPtr_pSparseMemoryRequirements(__LINE__, pSparseMemoryRequirements, cmock_size) +void vkGetImageSparseMemoryRequirements_CMockReturnMemThruPtr_pSparseMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkSparseImageMemoryRequirements const* pSparseMemoryRequirements, size_t cmock_size); +#define vkGetImageSparseMemoryRequirements_IgnoreArg_device() vkGetImageSparseMemoryRequirements_CMockIgnoreArg_device(__LINE__) +void vkGetImageSparseMemoryRequirements_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetImageSparseMemoryRequirements_IgnoreArg_image() vkGetImageSparseMemoryRequirements_CMockIgnoreArg_image(__LINE__) +void vkGetImageSparseMemoryRequirements_CMockIgnoreArg_image(UNITY_LINE_TYPE cmock_line); +#define vkGetImageSparseMemoryRequirements_IgnoreArg_pSparseMemoryRequirementCount() vkGetImageSparseMemoryRequirements_CMockIgnoreArg_pSparseMemoryRequirementCount(__LINE__) +void vkGetImageSparseMemoryRequirements_CMockIgnoreArg_pSparseMemoryRequirementCount(UNITY_LINE_TYPE cmock_line); +#define vkGetImageSparseMemoryRequirements_IgnoreArg_pSparseMemoryRequirements() vkGetImageSparseMemoryRequirements_CMockIgnoreArg_pSparseMemoryRequirements(__LINE__) +void vkGetImageSparseMemoryRequirements_CMockIgnoreArg_pSparseMemoryRequirements(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSparseImageFormatProperties_Ignore() vkGetPhysicalDeviceSparseImageFormatProperties_CMockIgnore() +void vkGetPhysicalDeviceSparseImageFormatProperties_CMockIgnore(void); +#define vkGetPhysicalDeviceSparseImageFormatProperties_StopIgnore() vkGetPhysicalDeviceSparseImageFormatProperties_CMockStopIgnore() +void vkGetPhysicalDeviceSparseImageFormatProperties_CMockStopIgnore(void); +#define vkGetPhysicalDeviceSparseImageFormatProperties_ExpectAnyArgs() vkGetPhysicalDeviceSparseImageFormatProperties_CMockExpectAnyArgs(__LINE__) +void vkGetPhysicalDeviceSparseImageFormatProperties_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSparseImageFormatProperties_Expect(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties) vkGetPhysicalDeviceSparseImageFormatProperties_CMockExpect(__LINE__, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties) +void vkGetPhysicalDeviceSparseImageFormatProperties_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties); +typedef void (* CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALLBACK)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties, int cmock_num_calls); +void vkGetPhysicalDeviceSparseImageFormatProperties_AddCallback(CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALLBACK Callback); +void vkGetPhysicalDeviceSparseImageFormatProperties_Stub(CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties_CALLBACK Callback); +#define vkGetPhysicalDeviceSparseImageFormatProperties_StubWithCallback vkGetPhysicalDeviceSparseImageFormatProperties_AddCallback +#define vkGetPhysicalDeviceSparseImageFormatProperties_ReturnThruPtr_pPropertyCount(pPropertyCount) vkGetPhysicalDeviceSparseImageFormatProperties_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, sizeof(uint32_t)) +#define vkGetPhysicalDeviceSparseImageFormatProperties_ReturnArrayThruPtr_pPropertyCount(pPropertyCount, cmock_len) vkGetPhysicalDeviceSparseImageFormatProperties_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, cmock_len * sizeof(*pPropertyCount)) +#define vkGetPhysicalDeviceSparseImageFormatProperties_ReturnMemThruPtr_pPropertyCount(pPropertyCount, cmock_size) vkGetPhysicalDeviceSparseImageFormatProperties_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, cmock_size) +void vkGetPhysicalDeviceSparseImageFormatProperties_CMockReturnMemThruPtr_pPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPropertyCount, size_t cmock_size); +#define vkGetPhysicalDeviceSparseImageFormatProperties_ReturnThruPtr_pProperties(pProperties) vkGetPhysicalDeviceSparseImageFormatProperties_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, sizeof(VkSparseImageFormatProperties)) +#define vkGetPhysicalDeviceSparseImageFormatProperties_ReturnArrayThruPtr_pProperties(pProperties, cmock_len) vkGetPhysicalDeviceSparseImageFormatProperties_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_len * sizeof(*pProperties)) +#define vkGetPhysicalDeviceSparseImageFormatProperties_ReturnMemThruPtr_pProperties(pProperties, cmock_size) vkGetPhysicalDeviceSparseImageFormatProperties_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_size) +void vkGetPhysicalDeviceSparseImageFormatProperties_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkSparseImageFormatProperties const* pProperties, size_t cmock_size); +#define vkGetPhysicalDeviceSparseImageFormatProperties_IgnoreArg_physicalDevice() vkGetPhysicalDeviceSparseImageFormatProperties_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceSparseImageFormatProperties_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSparseImageFormatProperties_IgnoreArg_format() vkGetPhysicalDeviceSparseImageFormatProperties_CMockIgnoreArg_format(__LINE__) +void vkGetPhysicalDeviceSparseImageFormatProperties_CMockIgnoreArg_format(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSparseImageFormatProperties_IgnoreArg_type() vkGetPhysicalDeviceSparseImageFormatProperties_CMockIgnoreArg_type(__LINE__) +void vkGetPhysicalDeviceSparseImageFormatProperties_CMockIgnoreArg_type(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSparseImageFormatProperties_IgnoreArg_samples() vkGetPhysicalDeviceSparseImageFormatProperties_CMockIgnoreArg_samples(__LINE__) +void vkGetPhysicalDeviceSparseImageFormatProperties_CMockIgnoreArg_samples(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSparseImageFormatProperties_IgnoreArg_usage() vkGetPhysicalDeviceSparseImageFormatProperties_CMockIgnoreArg_usage(__LINE__) +void vkGetPhysicalDeviceSparseImageFormatProperties_CMockIgnoreArg_usage(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSparseImageFormatProperties_IgnoreArg_tiling() vkGetPhysicalDeviceSparseImageFormatProperties_CMockIgnoreArg_tiling(__LINE__) +void vkGetPhysicalDeviceSparseImageFormatProperties_CMockIgnoreArg_tiling(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSparseImageFormatProperties_IgnoreArg_pPropertyCount() vkGetPhysicalDeviceSparseImageFormatProperties_CMockIgnoreArg_pPropertyCount(__LINE__) +void vkGetPhysicalDeviceSparseImageFormatProperties_CMockIgnoreArg_pPropertyCount(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSparseImageFormatProperties_IgnoreArg_pProperties() vkGetPhysicalDeviceSparseImageFormatProperties_CMockIgnoreArg_pProperties(__LINE__) +void vkGetPhysicalDeviceSparseImageFormatProperties_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line); +#define vkQueueBindSparse_IgnoreAndReturn(cmock_retval) vkQueueBindSparse_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkQueueBindSparse_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkQueueBindSparse_StopIgnore() vkQueueBindSparse_CMockStopIgnore() +void vkQueueBindSparse_CMockStopIgnore(void); +#define vkQueueBindSparse_ExpectAnyArgsAndReturn(cmock_retval) vkQueueBindSparse_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkQueueBindSparse_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkQueueBindSparse_ExpectAndReturn(queue, bindInfoCount, pBindInfo, fence, cmock_retval) vkQueueBindSparse_CMockExpectAndReturn(__LINE__, queue, bindInfoCount, pBindInfo, fence, cmock_retval) +void vkQueueBindSparse_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkQueueBindSparse_CALLBACK)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence, int cmock_num_calls); +void vkQueueBindSparse_AddCallback(CMOCK_vkQueueBindSparse_CALLBACK Callback); +void vkQueueBindSparse_Stub(CMOCK_vkQueueBindSparse_CALLBACK Callback); +#define vkQueueBindSparse_StubWithCallback vkQueueBindSparse_AddCallback +#define vkQueueBindSparse_IgnoreArg_queue() vkQueueBindSparse_CMockIgnoreArg_queue(__LINE__) +void vkQueueBindSparse_CMockIgnoreArg_queue(UNITY_LINE_TYPE cmock_line); +#define vkQueueBindSparse_IgnoreArg_bindInfoCount() vkQueueBindSparse_CMockIgnoreArg_bindInfoCount(__LINE__) +void vkQueueBindSparse_CMockIgnoreArg_bindInfoCount(UNITY_LINE_TYPE cmock_line); +#define vkQueueBindSparse_IgnoreArg_pBindInfo() vkQueueBindSparse_CMockIgnoreArg_pBindInfo(__LINE__) +void vkQueueBindSparse_CMockIgnoreArg_pBindInfo(UNITY_LINE_TYPE cmock_line); +#define vkQueueBindSparse_IgnoreArg_fence() vkQueueBindSparse_CMockIgnoreArg_fence(__LINE__) +void vkQueueBindSparse_CMockIgnoreArg_fence(UNITY_LINE_TYPE cmock_line); +#define vkCreateFence_IgnoreAndReturn(cmock_retval) vkCreateFence_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateFence_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateFence_StopIgnore() vkCreateFence_CMockStopIgnore() +void vkCreateFence_CMockStopIgnore(void); +#define vkCreateFence_ExpectAnyArgsAndReturn(cmock_retval) vkCreateFence_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateFence_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateFence_ExpectAndReturn(device, pCreateInfo, pAllocator, pFence, cmock_retval) vkCreateFence_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pFence, cmock_retval) +void vkCreateFence_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateFence_CALLBACK)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence, int cmock_num_calls); +void vkCreateFence_AddCallback(CMOCK_vkCreateFence_CALLBACK Callback); +void vkCreateFence_Stub(CMOCK_vkCreateFence_CALLBACK Callback); +#define vkCreateFence_StubWithCallback vkCreateFence_AddCallback +#define vkCreateFence_ReturnThruPtr_pFence(pFence) vkCreateFence_CMockReturnMemThruPtr_pFence(__LINE__, pFence, sizeof(VkFence)) +#define vkCreateFence_ReturnArrayThruPtr_pFence(pFence, cmock_len) vkCreateFence_CMockReturnMemThruPtr_pFence(__LINE__, pFence, cmock_len * sizeof(*pFence)) +#define vkCreateFence_ReturnMemThruPtr_pFence(pFence, cmock_size) vkCreateFence_CMockReturnMemThruPtr_pFence(__LINE__, pFence, cmock_size) +void vkCreateFence_CMockReturnMemThruPtr_pFence(UNITY_LINE_TYPE cmock_line, VkFence const* pFence, size_t cmock_size); +#define vkCreateFence_IgnoreArg_device() vkCreateFence_CMockIgnoreArg_device(__LINE__) +void vkCreateFence_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateFence_IgnoreArg_pCreateInfo() vkCreateFence_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateFence_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateFence_IgnoreArg_pAllocator() vkCreateFence_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateFence_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateFence_IgnoreArg_pFence() vkCreateFence_CMockIgnoreArg_pFence(__LINE__) +void vkCreateFence_CMockIgnoreArg_pFence(UNITY_LINE_TYPE cmock_line); +#define vkDestroyFence_Ignore() vkDestroyFence_CMockIgnore() +void vkDestroyFence_CMockIgnore(void); +#define vkDestroyFence_StopIgnore() vkDestroyFence_CMockStopIgnore() +void vkDestroyFence_CMockStopIgnore(void); +#define vkDestroyFence_ExpectAnyArgs() vkDestroyFence_CMockExpectAnyArgs(__LINE__) +void vkDestroyFence_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyFence_Expect(device, fence, pAllocator) vkDestroyFence_CMockExpect(__LINE__, device, fence, pAllocator) +void vkDestroyFence_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyFence_CALLBACK)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyFence_AddCallback(CMOCK_vkDestroyFence_CALLBACK Callback); +void vkDestroyFence_Stub(CMOCK_vkDestroyFence_CALLBACK Callback); +#define vkDestroyFence_StubWithCallback vkDestroyFence_AddCallback +#define vkDestroyFence_IgnoreArg_device() vkDestroyFence_CMockIgnoreArg_device(__LINE__) +void vkDestroyFence_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyFence_IgnoreArg_fence() vkDestroyFence_CMockIgnoreArg_fence(__LINE__) +void vkDestroyFence_CMockIgnoreArg_fence(UNITY_LINE_TYPE cmock_line); +#define vkDestroyFence_IgnoreArg_pAllocator() vkDestroyFence_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyFence_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkResetFences_IgnoreAndReturn(cmock_retval) vkResetFences_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkResetFences_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkResetFences_StopIgnore() vkResetFences_CMockStopIgnore() +void vkResetFences_CMockStopIgnore(void); +#define vkResetFences_ExpectAnyArgsAndReturn(cmock_retval) vkResetFences_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkResetFences_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkResetFences_ExpectAndReturn(device, fenceCount, pFences, cmock_retval) vkResetFences_CMockExpectAndReturn(__LINE__, device, fenceCount, pFences, cmock_retval) +void vkResetFences_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkResetFences_CALLBACK)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, int cmock_num_calls); +void vkResetFences_AddCallback(CMOCK_vkResetFences_CALLBACK Callback); +void vkResetFences_Stub(CMOCK_vkResetFences_CALLBACK Callback); +#define vkResetFences_StubWithCallback vkResetFences_AddCallback +#define vkResetFences_IgnoreArg_device() vkResetFences_CMockIgnoreArg_device(__LINE__) +void vkResetFences_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkResetFences_IgnoreArg_fenceCount() vkResetFences_CMockIgnoreArg_fenceCount(__LINE__) +void vkResetFences_CMockIgnoreArg_fenceCount(UNITY_LINE_TYPE cmock_line); +#define vkResetFences_IgnoreArg_pFences() vkResetFences_CMockIgnoreArg_pFences(__LINE__) +void vkResetFences_CMockIgnoreArg_pFences(UNITY_LINE_TYPE cmock_line); +#define vkGetFenceStatus_IgnoreAndReturn(cmock_retval) vkGetFenceStatus_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetFenceStatus_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetFenceStatus_StopIgnore() vkGetFenceStatus_CMockStopIgnore() +void vkGetFenceStatus_CMockStopIgnore(void); +#define vkGetFenceStatus_ExpectAnyArgsAndReturn(cmock_retval) vkGetFenceStatus_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetFenceStatus_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetFenceStatus_ExpectAndReturn(device, fence, cmock_retval) vkGetFenceStatus_CMockExpectAndReturn(__LINE__, device, fence, cmock_retval) +void vkGetFenceStatus_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkFence fence, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetFenceStatus_CALLBACK)(VkDevice device, VkFence fence, int cmock_num_calls); +void vkGetFenceStatus_AddCallback(CMOCK_vkGetFenceStatus_CALLBACK Callback); +void vkGetFenceStatus_Stub(CMOCK_vkGetFenceStatus_CALLBACK Callback); +#define vkGetFenceStatus_StubWithCallback vkGetFenceStatus_AddCallback +#define vkGetFenceStatus_IgnoreArg_device() vkGetFenceStatus_CMockIgnoreArg_device(__LINE__) +void vkGetFenceStatus_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetFenceStatus_IgnoreArg_fence() vkGetFenceStatus_CMockIgnoreArg_fence(__LINE__) +void vkGetFenceStatus_CMockIgnoreArg_fence(UNITY_LINE_TYPE cmock_line); +#define vkWaitForFences_IgnoreAndReturn(cmock_retval) vkWaitForFences_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkWaitForFences_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkWaitForFences_StopIgnore() vkWaitForFences_CMockStopIgnore() +void vkWaitForFences_CMockStopIgnore(void); +#define vkWaitForFences_ExpectAnyArgsAndReturn(cmock_retval) vkWaitForFences_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkWaitForFences_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkWaitForFences_ExpectAndReturn(device, fenceCount, pFences, waitAll, timeout, cmock_retval) vkWaitForFences_CMockExpectAndReturn(__LINE__, device, fenceCount, pFences, waitAll, timeout, cmock_retval) +void vkWaitForFences_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkWaitForFences_CALLBACK)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout, int cmock_num_calls); +void vkWaitForFences_AddCallback(CMOCK_vkWaitForFences_CALLBACK Callback); +void vkWaitForFences_Stub(CMOCK_vkWaitForFences_CALLBACK Callback); +#define vkWaitForFences_StubWithCallback vkWaitForFences_AddCallback +#define vkWaitForFences_IgnoreArg_device() vkWaitForFences_CMockIgnoreArg_device(__LINE__) +void vkWaitForFences_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkWaitForFences_IgnoreArg_fenceCount() vkWaitForFences_CMockIgnoreArg_fenceCount(__LINE__) +void vkWaitForFences_CMockIgnoreArg_fenceCount(UNITY_LINE_TYPE cmock_line); +#define vkWaitForFences_IgnoreArg_pFences() vkWaitForFences_CMockIgnoreArg_pFences(__LINE__) +void vkWaitForFences_CMockIgnoreArg_pFences(UNITY_LINE_TYPE cmock_line); +#define vkWaitForFences_IgnoreArg_waitAll() vkWaitForFences_CMockIgnoreArg_waitAll(__LINE__) +void vkWaitForFences_CMockIgnoreArg_waitAll(UNITY_LINE_TYPE cmock_line); +#define vkWaitForFences_IgnoreArg_timeout() vkWaitForFences_CMockIgnoreArg_timeout(__LINE__) +void vkWaitForFences_CMockIgnoreArg_timeout(UNITY_LINE_TYPE cmock_line); +#define vkCreateSemaphore_IgnoreAndReturn(cmock_retval) vkCreateSemaphore_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateSemaphore_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateSemaphore_StopIgnore() vkCreateSemaphore_CMockStopIgnore() +void vkCreateSemaphore_CMockStopIgnore(void); +#define vkCreateSemaphore_ExpectAnyArgsAndReturn(cmock_retval) vkCreateSemaphore_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateSemaphore_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateSemaphore_ExpectAndReturn(device, pCreateInfo, pAllocator, pSemaphore, cmock_retval) vkCreateSemaphore_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pSemaphore, cmock_retval) +void vkCreateSemaphore_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateSemaphore_CALLBACK)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore, int cmock_num_calls); +void vkCreateSemaphore_AddCallback(CMOCK_vkCreateSemaphore_CALLBACK Callback); +void vkCreateSemaphore_Stub(CMOCK_vkCreateSemaphore_CALLBACK Callback); +#define vkCreateSemaphore_StubWithCallback vkCreateSemaphore_AddCallback +#define vkCreateSemaphore_ReturnThruPtr_pSemaphore(pSemaphore) vkCreateSemaphore_CMockReturnMemThruPtr_pSemaphore(__LINE__, pSemaphore, sizeof(VkSemaphore)) +#define vkCreateSemaphore_ReturnArrayThruPtr_pSemaphore(pSemaphore, cmock_len) vkCreateSemaphore_CMockReturnMemThruPtr_pSemaphore(__LINE__, pSemaphore, cmock_len * sizeof(*pSemaphore)) +#define vkCreateSemaphore_ReturnMemThruPtr_pSemaphore(pSemaphore, cmock_size) vkCreateSemaphore_CMockReturnMemThruPtr_pSemaphore(__LINE__, pSemaphore, cmock_size) +void vkCreateSemaphore_CMockReturnMemThruPtr_pSemaphore(UNITY_LINE_TYPE cmock_line, VkSemaphore const* pSemaphore, size_t cmock_size); +#define vkCreateSemaphore_IgnoreArg_device() vkCreateSemaphore_CMockIgnoreArg_device(__LINE__) +void vkCreateSemaphore_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateSemaphore_IgnoreArg_pCreateInfo() vkCreateSemaphore_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateSemaphore_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateSemaphore_IgnoreArg_pAllocator() vkCreateSemaphore_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateSemaphore_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateSemaphore_IgnoreArg_pSemaphore() vkCreateSemaphore_CMockIgnoreArg_pSemaphore(__LINE__) +void vkCreateSemaphore_CMockIgnoreArg_pSemaphore(UNITY_LINE_TYPE cmock_line); +#define vkDestroySemaphore_Ignore() vkDestroySemaphore_CMockIgnore() +void vkDestroySemaphore_CMockIgnore(void); +#define vkDestroySemaphore_StopIgnore() vkDestroySemaphore_CMockStopIgnore() +void vkDestroySemaphore_CMockStopIgnore(void); +#define vkDestroySemaphore_ExpectAnyArgs() vkDestroySemaphore_CMockExpectAnyArgs(__LINE__) +void vkDestroySemaphore_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroySemaphore_Expect(device, semaphore, pAllocator) vkDestroySemaphore_CMockExpect(__LINE__, device, semaphore, pAllocator) +void vkDestroySemaphore_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroySemaphore_CALLBACK)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroySemaphore_AddCallback(CMOCK_vkDestroySemaphore_CALLBACK Callback); +void vkDestroySemaphore_Stub(CMOCK_vkDestroySemaphore_CALLBACK Callback); +#define vkDestroySemaphore_StubWithCallback vkDestroySemaphore_AddCallback +#define vkDestroySemaphore_IgnoreArg_device() vkDestroySemaphore_CMockIgnoreArg_device(__LINE__) +void vkDestroySemaphore_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroySemaphore_IgnoreArg_semaphore() vkDestroySemaphore_CMockIgnoreArg_semaphore(__LINE__) +void vkDestroySemaphore_CMockIgnoreArg_semaphore(UNITY_LINE_TYPE cmock_line); +#define vkDestroySemaphore_IgnoreArg_pAllocator() vkDestroySemaphore_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroySemaphore_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateEvent_IgnoreAndReturn(cmock_retval) vkCreateEvent_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateEvent_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateEvent_StopIgnore() vkCreateEvent_CMockStopIgnore() +void vkCreateEvent_CMockStopIgnore(void); +#define vkCreateEvent_ExpectAnyArgsAndReturn(cmock_retval) vkCreateEvent_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateEvent_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateEvent_ExpectAndReturn(device, pCreateInfo, pAllocator, pEvent, cmock_retval) vkCreateEvent_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pEvent, cmock_retval) +void vkCreateEvent_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateEvent_CALLBACK)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent, int cmock_num_calls); +void vkCreateEvent_AddCallback(CMOCK_vkCreateEvent_CALLBACK Callback); +void vkCreateEvent_Stub(CMOCK_vkCreateEvent_CALLBACK Callback); +#define vkCreateEvent_StubWithCallback vkCreateEvent_AddCallback +#define vkCreateEvent_ReturnThruPtr_pEvent(pEvent) vkCreateEvent_CMockReturnMemThruPtr_pEvent(__LINE__, pEvent, sizeof(VkEvent)) +#define vkCreateEvent_ReturnArrayThruPtr_pEvent(pEvent, cmock_len) vkCreateEvent_CMockReturnMemThruPtr_pEvent(__LINE__, pEvent, cmock_len * sizeof(*pEvent)) +#define vkCreateEvent_ReturnMemThruPtr_pEvent(pEvent, cmock_size) vkCreateEvent_CMockReturnMemThruPtr_pEvent(__LINE__, pEvent, cmock_size) +void vkCreateEvent_CMockReturnMemThruPtr_pEvent(UNITY_LINE_TYPE cmock_line, VkEvent const* pEvent, size_t cmock_size); +#define vkCreateEvent_IgnoreArg_device() vkCreateEvent_CMockIgnoreArg_device(__LINE__) +void vkCreateEvent_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateEvent_IgnoreArg_pCreateInfo() vkCreateEvent_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateEvent_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateEvent_IgnoreArg_pAllocator() vkCreateEvent_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateEvent_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateEvent_IgnoreArg_pEvent() vkCreateEvent_CMockIgnoreArg_pEvent(__LINE__) +void vkCreateEvent_CMockIgnoreArg_pEvent(UNITY_LINE_TYPE cmock_line); +#define vkDestroyEvent_Ignore() vkDestroyEvent_CMockIgnore() +void vkDestroyEvent_CMockIgnore(void); +#define vkDestroyEvent_StopIgnore() vkDestroyEvent_CMockStopIgnore() +void vkDestroyEvent_CMockStopIgnore(void); +#define vkDestroyEvent_ExpectAnyArgs() vkDestroyEvent_CMockExpectAnyArgs(__LINE__) +void vkDestroyEvent_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyEvent_Expect(device, event, pAllocator) vkDestroyEvent_CMockExpect(__LINE__, device, event, pAllocator) +void vkDestroyEvent_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyEvent_CALLBACK)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyEvent_AddCallback(CMOCK_vkDestroyEvent_CALLBACK Callback); +void vkDestroyEvent_Stub(CMOCK_vkDestroyEvent_CALLBACK Callback); +#define vkDestroyEvent_StubWithCallback vkDestroyEvent_AddCallback +#define vkDestroyEvent_IgnoreArg_device() vkDestroyEvent_CMockIgnoreArg_device(__LINE__) +void vkDestroyEvent_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyEvent_IgnoreArg_event() vkDestroyEvent_CMockIgnoreArg_event(__LINE__) +void vkDestroyEvent_CMockIgnoreArg_event(UNITY_LINE_TYPE cmock_line); +#define vkDestroyEvent_IgnoreArg_pAllocator() vkDestroyEvent_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyEvent_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkGetEventStatus_IgnoreAndReturn(cmock_retval) vkGetEventStatus_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetEventStatus_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetEventStatus_StopIgnore() vkGetEventStatus_CMockStopIgnore() +void vkGetEventStatus_CMockStopIgnore(void); +#define vkGetEventStatus_ExpectAnyArgsAndReturn(cmock_retval) vkGetEventStatus_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetEventStatus_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetEventStatus_ExpectAndReturn(device, event, cmock_retval) vkGetEventStatus_CMockExpectAndReturn(__LINE__, device, event, cmock_retval) +void vkGetEventStatus_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkEvent event, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetEventStatus_CALLBACK)(VkDevice device, VkEvent event, int cmock_num_calls); +void vkGetEventStatus_AddCallback(CMOCK_vkGetEventStatus_CALLBACK Callback); +void vkGetEventStatus_Stub(CMOCK_vkGetEventStatus_CALLBACK Callback); +#define vkGetEventStatus_StubWithCallback vkGetEventStatus_AddCallback +#define vkGetEventStatus_IgnoreArg_device() vkGetEventStatus_CMockIgnoreArg_device(__LINE__) +void vkGetEventStatus_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetEventStatus_IgnoreArg_event() vkGetEventStatus_CMockIgnoreArg_event(__LINE__) +void vkGetEventStatus_CMockIgnoreArg_event(UNITY_LINE_TYPE cmock_line); +#define vkSetEvent_IgnoreAndReturn(cmock_retval) vkSetEvent_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkSetEvent_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkSetEvent_StopIgnore() vkSetEvent_CMockStopIgnore() +void vkSetEvent_CMockStopIgnore(void); +#define vkSetEvent_ExpectAnyArgsAndReturn(cmock_retval) vkSetEvent_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkSetEvent_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkSetEvent_ExpectAndReturn(device, event, cmock_retval) vkSetEvent_CMockExpectAndReturn(__LINE__, device, event, cmock_retval) +void vkSetEvent_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkEvent event, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkSetEvent_CALLBACK)(VkDevice device, VkEvent event, int cmock_num_calls); +void vkSetEvent_AddCallback(CMOCK_vkSetEvent_CALLBACK Callback); +void vkSetEvent_Stub(CMOCK_vkSetEvent_CALLBACK Callback); +#define vkSetEvent_StubWithCallback vkSetEvent_AddCallback +#define vkSetEvent_IgnoreArg_device() vkSetEvent_CMockIgnoreArg_device(__LINE__) +void vkSetEvent_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkSetEvent_IgnoreArg_event() vkSetEvent_CMockIgnoreArg_event(__LINE__) +void vkSetEvent_CMockIgnoreArg_event(UNITY_LINE_TYPE cmock_line); +#define vkResetEvent_IgnoreAndReturn(cmock_retval) vkResetEvent_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkResetEvent_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkResetEvent_StopIgnore() vkResetEvent_CMockStopIgnore() +void vkResetEvent_CMockStopIgnore(void); +#define vkResetEvent_ExpectAnyArgsAndReturn(cmock_retval) vkResetEvent_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkResetEvent_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkResetEvent_ExpectAndReturn(device, event, cmock_retval) vkResetEvent_CMockExpectAndReturn(__LINE__, device, event, cmock_retval) +void vkResetEvent_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkEvent event, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkResetEvent_CALLBACK)(VkDevice device, VkEvent event, int cmock_num_calls); +void vkResetEvent_AddCallback(CMOCK_vkResetEvent_CALLBACK Callback); +void vkResetEvent_Stub(CMOCK_vkResetEvent_CALLBACK Callback); +#define vkResetEvent_StubWithCallback vkResetEvent_AddCallback +#define vkResetEvent_IgnoreArg_device() vkResetEvent_CMockIgnoreArg_device(__LINE__) +void vkResetEvent_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkResetEvent_IgnoreArg_event() vkResetEvent_CMockIgnoreArg_event(__LINE__) +void vkResetEvent_CMockIgnoreArg_event(UNITY_LINE_TYPE cmock_line); +#define vkCreateQueryPool_IgnoreAndReturn(cmock_retval) vkCreateQueryPool_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateQueryPool_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateQueryPool_StopIgnore() vkCreateQueryPool_CMockStopIgnore() +void vkCreateQueryPool_CMockStopIgnore(void); +#define vkCreateQueryPool_ExpectAnyArgsAndReturn(cmock_retval) vkCreateQueryPool_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateQueryPool_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateQueryPool_ExpectAndReturn(device, pCreateInfo, pAllocator, pQueryPool, cmock_retval) vkCreateQueryPool_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pQueryPool, cmock_retval) +void vkCreateQueryPool_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateQueryPool_CALLBACK)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool, int cmock_num_calls); +void vkCreateQueryPool_AddCallback(CMOCK_vkCreateQueryPool_CALLBACK Callback); +void vkCreateQueryPool_Stub(CMOCK_vkCreateQueryPool_CALLBACK Callback); +#define vkCreateQueryPool_StubWithCallback vkCreateQueryPool_AddCallback +#define vkCreateQueryPool_ReturnThruPtr_pQueryPool(pQueryPool) vkCreateQueryPool_CMockReturnMemThruPtr_pQueryPool(__LINE__, pQueryPool, sizeof(VkQueryPool)) +#define vkCreateQueryPool_ReturnArrayThruPtr_pQueryPool(pQueryPool, cmock_len) vkCreateQueryPool_CMockReturnMemThruPtr_pQueryPool(__LINE__, pQueryPool, cmock_len * sizeof(*pQueryPool)) +#define vkCreateQueryPool_ReturnMemThruPtr_pQueryPool(pQueryPool, cmock_size) vkCreateQueryPool_CMockReturnMemThruPtr_pQueryPool(__LINE__, pQueryPool, cmock_size) +void vkCreateQueryPool_CMockReturnMemThruPtr_pQueryPool(UNITY_LINE_TYPE cmock_line, VkQueryPool const* pQueryPool, size_t cmock_size); +#define vkCreateQueryPool_IgnoreArg_device() vkCreateQueryPool_CMockIgnoreArg_device(__LINE__) +void vkCreateQueryPool_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateQueryPool_IgnoreArg_pCreateInfo() vkCreateQueryPool_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateQueryPool_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateQueryPool_IgnoreArg_pAllocator() vkCreateQueryPool_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateQueryPool_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateQueryPool_IgnoreArg_pQueryPool() vkCreateQueryPool_CMockIgnoreArg_pQueryPool(__LINE__) +void vkCreateQueryPool_CMockIgnoreArg_pQueryPool(UNITY_LINE_TYPE cmock_line); +#define vkDestroyQueryPool_Ignore() vkDestroyQueryPool_CMockIgnore() +void vkDestroyQueryPool_CMockIgnore(void); +#define vkDestroyQueryPool_StopIgnore() vkDestroyQueryPool_CMockStopIgnore() +void vkDestroyQueryPool_CMockStopIgnore(void); +#define vkDestroyQueryPool_ExpectAnyArgs() vkDestroyQueryPool_CMockExpectAnyArgs(__LINE__) +void vkDestroyQueryPool_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyQueryPool_Expect(device, queryPool, pAllocator) vkDestroyQueryPool_CMockExpect(__LINE__, device, queryPool, pAllocator) +void vkDestroyQueryPool_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyQueryPool_CALLBACK)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyQueryPool_AddCallback(CMOCK_vkDestroyQueryPool_CALLBACK Callback); +void vkDestroyQueryPool_Stub(CMOCK_vkDestroyQueryPool_CALLBACK Callback); +#define vkDestroyQueryPool_StubWithCallback vkDestroyQueryPool_AddCallback +#define vkDestroyQueryPool_IgnoreArg_device() vkDestroyQueryPool_CMockIgnoreArg_device(__LINE__) +void vkDestroyQueryPool_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyQueryPool_IgnoreArg_queryPool() vkDestroyQueryPool_CMockIgnoreArg_queryPool(__LINE__) +void vkDestroyQueryPool_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line); +#define vkDestroyQueryPool_IgnoreArg_pAllocator() vkDestroyQueryPool_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyQueryPool_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkGetQueryPoolResults_IgnoreAndReturn(cmock_retval) vkGetQueryPoolResults_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetQueryPoolResults_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetQueryPoolResults_StopIgnore() vkGetQueryPoolResults_CMockStopIgnore() +void vkGetQueryPoolResults_CMockStopIgnore(void); +#define vkGetQueryPoolResults_ExpectAnyArgsAndReturn(cmock_retval) vkGetQueryPoolResults_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetQueryPoolResults_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetQueryPoolResults_ExpectAndReturn(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags, cmock_retval) vkGetQueryPoolResults_CMockExpectAndReturn(__LINE__, device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags, cmock_retval) +void vkGetQueryPoolResults_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetQueryPoolResults_CALLBACK)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags, int cmock_num_calls); +void vkGetQueryPoolResults_AddCallback(CMOCK_vkGetQueryPoolResults_CALLBACK Callback); +void vkGetQueryPoolResults_Stub(CMOCK_vkGetQueryPoolResults_CALLBACK Callback); +#define vkGetQueryPoolResults_StubWithCallback vkGetQueryPoolResults_AddCallback +#define vkGetQueryPoolResults_ReturnThruPtr_pData(pData) vkGetQueryPoolResults_CMockReturnMemThruPtr_pData(__LINE__, pData, sizeof(*pData)) +#define vkGetQueryPoolResults_ReturnArrayThruPtr_pData(pData, cmock_len) vkGetQueryPoolResults_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_len * sizeof(*pData)) +#define vkGetQueryPoolResults_ReturnMemThruPtr_pData(pData, cmock_size) vkGetQueryPoolResults_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_size) +void vkGetQueryPoolResults_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, void const* pData, size_t cmock_size); +#define vkGetQueryPoolResults_IgnoreArg_device() vkGetQueryPoolResults_CMockIgnoreArg_device(__LINE__) +void vkGetQueryPoolResults_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetQueryPoolResults_IgnoreArg_queryPool() vkGetQueryPoolResults_CMockIgnoreArg_queryPool(__LINE__) +void vkGetQueryPoolResults_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line); +#define vkGetQueryPoolResults_IgnoreArg_firstQuery() vkGetQueryPoolResults_CMockIgnoreArg_firstQuery(__LINE__) +void vkGetQueryPoolResults_CMockIgnoreArg_firstQuery(UNITY_LINE_TYPE cmock_line); +#define vkGetQueryPoolResults_IgnoreArg_queryCount() vkGetQueryPoolResults_CMockIgnoreArg_queryCount(__LINE__) +void vkGetQueryPoolResults_CMockIgnoreArg_queryCount(UNITY_LINE_TYPE cmock_line); +#define vkGetQueryPoolResults_IgnoreArg_dataSize() vkGetQueryPoolResults_CMockIgnoreArg_dataSize(__LINE__) +void vkGetQueryPoolResults_CMockIgnoreArg_dataSize(UNITY_LINE_TYPE cmock_line); +#define vkGetQueryPoolResults_IgnoreArg_pData() vkGetQueryPoolResults_CMockIgnoreArg_pData(__LINE__) +void vkGetQueryPoolResults_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line); +#define vkGetQueryPoolResults_IgnoreArg_stride() vkGetQueryPoolResults_CMockIgnoreArg_stride(__LINE__) +void vkGetQueryPoolResults_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line); +#define vkGetQueryPoolResults_IgnoreArg_flags() vkGetQueryPoolResults_CMockIgnoreArg_flags(__LINE__) +void vkGetQueryPoolResults_CMockIgnoreArg_flags(UNITY_LINE_TYPE cmock_line); +#define vkCreateBuffer_IgnoreAndReturn(cmock_retval) vkCreateBuffer_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateBuffer_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateBuffer_StopIgnore() vkCreateBuffer_CMockStopIgnore() +void vkCreateBuffer_CMockStopIgnore(void); +#define vkCreateBuffer_ExpectAnyArgsAndReturn(cmock_retval) vkCreateBuffer_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateBuffer_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateBuffer_ExpectAndReturn(device, pCreateInfo, pAllocator, pBuffer, cmock_retval) vkCreateBuffer_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pBuffer, cmock_retval) +void vkCreateBuffer_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateBuffer_CALLBACK)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer, int cmock_num_calls); +void vkCreateBuffer_AddCallback(CMOCK_vkCreateBuffer_CALLBACK Callback); +void vkCreateBuffer_Stub(CMOCK_vkCreateBuffer_CALLBACK Callback); +#define vkCreateBuffer_StubWithCallback vkCreateBuffer_AddCallback +#define vkCreateBuffer_ReturnThruPtr_pBuffer(pBuffer) vkCreateBuffer_CMockReturnMemThruPtr_pBuffer(__LINE__, pBuffer, sizeof(VkBuffer)) +#define vkCreateBuffer_ReturnArrayThruPtr_pBuffer(pBuffer, cmock_len) vkCreateBuffer_CMockReturnMemThruPtr_pBuffer(__LINE__, pBuffer, cmock_len * sizeof(*pBuffer)) +#define vkCreateBuffer_ReturnMemThruPtr_pBuffer(pBuffer, cmock_size) vkCreateBuffer_CMockReturnMemThruPtr_pBuffer(__LINE__, pBuffer, cmock_size) +void vkCreateBuffer_CMockReturnMemThruPtr_pBuffer(UNITY_LINE_TYPE cmock_line, VkBuffer const* pBuffer, size_t cmock_size); +#define vkCreateBuffer_IgnoreArg_device() vkCreateBuffer_CMockIgnoreArg_device(__LINE__) +void vkCreateBuffer_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateBuffer_IgnoreArg_pCreateInfo() vkCreateBuffer_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateBuffer_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateBuffer_IgnoreArg_pAllocator() vkCreateBuffer_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateBuffer_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateBuffer_IgnoreArg_pBuffer() vkCreateBuffer_CMockIgnoreArg_pBuffer(__LINE__) +void vkCreateBuffer_CMockIgnoreArg_pBuffer(UNITY_LINE_TYPE cmock_line); +#define vkDestroyBuffer_Ignore() vkDestroyBuffer_CMockIgnore() +void vkDestroyBuffer_CMockIgnore(void); +#define vkDestroyBuffer_StopIgnore() vkDestroyBuffer_CMockStopIgnore() +void vkDestroyBuffer_CMockStopIgnore(void); +#define vkDestroyBuffer_ExpectAnyArgs() vkDestroyBuffer_CMockExpectAnyArgs(__LINE__) +void vkDestroyBuffer_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyBuffer_Expect(device, buffer, pAllocator) vkDestroyBuffer_CMockExpect(__LINE__, device, buffer, pAllocator) +void vkDestroyBuffer_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyBuffer_CALLBACK)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyBuffer_AddCallback(CMOCK_vkDestroyBuffer_CALLBACK Callback); +void vkDestroyBuffer_Stub(CMOCK_vkDestroyBuffer_CALLBACK Callback); +#define vkDestroyBuffer_StubWithCallback vkDestroyBuffer_AddCallback +#define vkDestroyBuffer_IgnoreArg_device() vkDestroyBuffer_CMockIgnoreArg_device(__LINE__) +void vkDestroyBuffer_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyBuffer_IgnoreArg_buffer() vkDestroyBuffer_CMockIgnoreArg_buffer(__LINE__) +void vkDestroyBuffer_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line); +#define vkDestroyBuffer_IgnoreArg_pAllocator() vkDestroyBuffer_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyBuffer_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateBufferView_IgnoreAndReturn(cmock_retval) vkCreateBufferView_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateBufferView_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateBufferView_StopIgnore() vkCreateBufferView_CMockStopIgnore() +void vkCreateBufferView_CMockStopIgnore(void); +#define vkCreateBufferView_ExpectAnyArgsAndReturn(cmock_retval) vkCreateBufferView_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateBufferView_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateBufferView_ExpectAndReturn(device, pCreateInfo, pAllocator, pView, cmock_retval) vkCreateBufferView_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pView, cmock_retval) +void vkCreateBufferView_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateBufferView_CALLBACK)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView, int cmock_num_calls); +void vkCreateBufferView_AddCallback(CMOCK_vkCreateBufferView_CALLBACK Callback); +void vkCreateBufferView_Stub(CMOCK_vkCreateBufferView_CALLBACK Callback); +#define vkCreateBufferView_StubWithCallback vkCreateBufferView_AddCallback +#define vkCreateBufferView_ReturnThruPtr_pView(pView) vkCreateBufferView_CMockReturnMemThruPtr_pView(__LINE__, pView, sizeof(VkBufferView)) +#define vkCreateBufferView_ReturnArrayThruPtr_pView(pView, cmock_len) vkCreateBufferView_CMockReturnMemThruPtr_pView(__LINE__, pView, cmock_len * sizeof(*pView)) +#define vkCreateBufferView_ReturnMemThruPtr_pView(pView, cmock_size) vkCreateBufferView_CMockReturnMemThruPtr_pView(__LINE__, pView, cmock_size) +void vkCreateBufferView_CMockReturnMemThruPtr_pView(UNITY_LINE_TYPE cmock_line, VkBufferView const* pView, size_t cmock_size); +#define vkCreateBufferView_IgnoreArg_device() vkCreateBufferView_CMockIgnoreArg_device(__LINE__) +void vkCreateBufferView_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateBufferView_IgnoreArg_pCreateInfo() vkCreateBufferView_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateBufferView_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateBufferView_IgnoreArg_pAllocator() vkCreateBufferView_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateBufferView_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateBufferView_IgnoreArg_pView() vkCreateBufferView_CMockIgnoreArg_pView(__LINE__) +void vkCreateBufferView_CMockIgnoreArg_pView(UNITY_LINE_TYPE cmock_line); +#define vkDestroyBufferView_Ignore() vkDestroyBufferView_CMockIgnore() +void vkDestroyBufferView_CMockIgnore(void); +#define vkDestroyBufferView_StopIgnore() vkDestroyBufferView_CMockStopIgnore() +void vkDestroyBufferView_CMockStopIgnore(void); +#define vkDestroyBufferView_ExpectAnyArgs() vkDestroyBufferView_CMockExpectAnyArgs(__LINE__) +void vkDestroyBufferView_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyBufferView_Expect(device, bufferView, pAllocator) vkDestroyBufferView_CMockExpect(__LINE__, device, bufferView, pAllocator) +void vkDestroyBufferView_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyBufferView_CALLBACK)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyBufferView_AddCallback(CMOCK_vkDestroyBufferView_CALLBACK Callback); +void vkDestroyBufferView_Stub(CMOCK_vkDestroyBufferView_CALLBACK Callback); +#define vkDestroyBufferView_StubWithCallback vkDestroyBufferView_AddCallback +#define vkDestroyBufferView_IgnoreArg_device() vkDestroyBufferView_CMockIgnoreArg_device(__LINE__) +void vkDestroyBufferView_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyBufferView_IgnoreArg_bufferView() vkDestroyBufferView_CMockIgnoreArg_bufferView(__LINE__) +void vkDestroyBufferView_CMockIgnoreArg_bufferView(UNITY_LINE_TYPE cmock_line); +#define vkDestroyBufferView_IgnoreArg_pAllocator() vkDestroyBufferView_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyBufferView_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateImage_IgnoreAndReturn(cmock_retval) vkCreateImage_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateImage_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateImage_StopIgnore() vkCreateImage_CMockStopIgnore() +void vkCreateImage_CMockStopIgnore(void); +#define vkCreateImage_ExpectAnyArgsAndReturn(cmock_retval) vkCreateImage_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateImage_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateImage_ExpectAndReturn(device, pCreateInfo, pAllocator, pImage, cmock_retval) vkCreateImage_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pImage, cmock_retval) +void vkCreateImage_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateImage_CALLBACK)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage, int cmock_num_calls); +void vkCreateImage_AddCallback(CMOCK_vkCreateImage_CALLBACK Callback); +void vkCreateImage_Stub(CMOCK_vkCreateImage_CALLBACK Callback); +#define vkCreateImage_StubWithCallback vkCreateImage_AddCallback +#define vkCreateImage_ReturnThruPtr_pImage(pImage) vkCreateImage_CMockReturnMemThruPtr_pImage(__LINE__, pImage, sizeof(VkImage)) +#define vkCreateImage_ReturnArrayThruPtr_pImage(pImage, cmock_len) vkCreateImage_CMockReturnMemThruPtr_pImage(__LINE__, pImage, cmock_len * sizeof(*pImage)) +#define vkCreateImage_ReturnMemThruPtr_pImage(pImage, cmock_size) vkCreateImage_CMockReturnMemThruPtr_pImage(__LINE__, pImage, cmock_size) +void vkCreateImage_CMockReturnMemThruPtr_pImage(UNITY_LINE_TYPE cmock_line, VkImage const* pImage, size_t cmock_size); +#define vkCreateImage_IgnoreArg_device() vkCreateImage_CMockIgnoreArg_device(__LINE__) +void vkCreateImage_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateImage_IgnoreArg_pCreateInfo() vkCreateImage_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateImage_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateImage_IgnoreArg_pAllocator() vkCreateImage_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateImage_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateImage_IgnoreArg_pImage() vkCreateImage_CMockIgnoreArg_pImage(__LINE__) +void vkCreateImage_CMockIgnoreArg_pImage(UNITY_LINE_TYPE cmock_line); +#define vkDestroyImage_Ignore() vkDestroyImage_CMockIgnore() +void vkDestroyImage_CMockIgnore(void); +#define vkDestroyImage_StopIgnore() vkDestroyImage_CMockStopIgnore() +void vkDestroyImage_CMockStopIgnore(void); +#define vkDestroyImage_ExpectAnyArgs() vkDestroyImage_CMockExpectAnyArgs(__LINE__) +void vkDestroyImage_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyImage_Expect(device, image, pAllocator) vkDestroyImage_CMockExpect(__LINE__, device, image, pAllocator) +void vkDestroyImage_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyImage_CALLBACK)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyImage_AddCallback(CMOCK_vkDestroyImage_CALLBACK Callback); +void vkDestroyImage_Stub(CMOCK_vkDestroyImage_CALLBACK Callback); +#define vkDestroyImage_StubWithCallback vkDestroyImage_AddCallback +#define vkDestroyImage_IgnoreArg_device() vkDestroyImage_CMockIgnoreArg_device(__LINE__) +void vkDestroyImage_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyImage_IgnoreArg_image() vkDestroyImage_CMockIgnoreArg_image(__LINE__) +void vkDestroyImage_CMockIgnoreArg_image(UNITY_LINE_TYPE cmock_line); +#define vkDestroyImage_IgnoreArg_pAllocator() vkDestroyImage_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyImage_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkGetImageSubresourceLayout_Ignore() vkGetImageSubresourceLayout_CMockIgnore() +void vkGetImageSubresourceLayout_CMockIgnore(void); +#define vkGetImageSubresourceLayout_StopIgnore() vkGetImageSubresourceLayout_CMockStopIgnore() +void vkGetImageSubresourceLayout_CMockStopIgnore(void); +#define vkGetImageSubresourceLayout_ExpectAnyArgs() vkGetImageSubresourceLayout_CMockExpectAnyArgs(__LINE__) +void vkGetImageSubresourceLayout_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetImageSubresourceLayout_Expect(device, image, pSubresource, pLayout) vkGetImageSubresourceLayout_CMockExpect(__LINE__, device, image, pSubresource, pLayout) +void vkGetImageSubresourceLayout_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); +typedef void (* CMOCK_vkGetImageSubresourceLayout_CALLBACK)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout, int cmock_num_calls); +void vkGetImageSubresourceLayout_AddCallback(CMOCK_vkGetImageSubresourceLayout_CALLBACK Callback); +void vkGetImageSubresourceLayout_Stub(CMOCK_vkGetImageSubresourceLayout_CALLBACK Callback); +#define vkGetImageSubresourceLayout_StubWithCallback vkGetImageSubresourceLayout_AddCallback +#define vkGetImageSubresourceLayout_ReturnThruPtr_pLayout(pLayout) vkGetImageSubresourceLayout_CMockReturnMemThruPtr_pLayout(__LINE__, pLayout, sizeof(VkSubresourceLayout)) +#define vkGetImageSubresourceLayout_ReturnArrayThruPtr_pLayout(pLayout, cmock_len) vkGetImageSubresourceLayout_CMockReturnMemThruPtr_pLayout(__LINE__, pLayout, cmock_len * sizeof(*pLayout)) +#define vkGetImageSubresourceLayout_ReturnMemThruPtr_pLayout(pLayout, cmock_size) vkGetImageSubresourceLayout_CMockReturnMemThruPtr_pLayout(__LINE__, pLayout, cmock_size) +void vkGetImageSubresourceLayout_CMockReturnMemThruPtr_pLayout(UNITY_LINE_TYPE cmock_line, VkSubresourceLayout const* pLayout, size_t cmock_size); +#define vkGetImageSubresourceLayout_IgnoreArg_device() vkGetImageSubresourceLayout_CMockIgnoreArg_device(__LINE__) +void vkGetImageSubresourceLayout_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetImageSubresourceLayout_IgnoreArg_image() vkGetImageSubresourceLayout_CMockIgnoreArg_image(__LINE__) +void vkGetImageSubresourceLayout_CMockIgnoreArg_image(UNITY_LINE_TYPE cmock_line); +#define vkGetImageSubresourceLayout_IgnoreArg_pSubresource() vkGetImageSubresourceLayout_CMockIgnoreArg_pSubresource(__LINE__) +void vkGetImageSubresourceLayout_CMockIgnoreArg_pSubresource(UNITY_LINE_TYPE cmock_line); +#define vkGetImageSubresourceLayout_IgnoreArg_pLayout() vkGetImageSubresourceLayout_CMockIgnoreArg_pLayout(__LINE__) +void vkGetImageSubresourceLayout_CMockIgnoreArg_pLayout(UNITY_LINE_TYPE cmock_line); +#define vkCreateImageView_IgnoreAndReturn(cmock_retval) vkCreateImageView_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateImageView_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateImageView_StopIgnore() vkCreateImageView_CMockStopIgnore() +void vkCreateImageView_CMockStopIgnore(void); +#define vkCreateImageView_ExpectAnyArgsAndReturn(cmock_retval) vkCreateImageView_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateImageView_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateImageView_ExpectAndReturn(device, pCreateInfo, pAllocator, pView, cmock_retval) vkCreateImageView_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pView, cmock_retval) +void vkCreateImageView_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateImageView_CALLBACK)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView, int cmock_num_calls); +void vkCreateImageView_AddCallback(CMOCK_vkCreateImageView_CALLBACK Callback); +void vkCreateImageView_Stub(CMOCK_vkCreateImageView_CALLBACK Callback); +#define vkCreateImageView_StubWithCallback vkCreateImageView_AddCallback +#define vkCreateImageView_ReturnThruPtr_pView(pView) vkCreateImageView_CMockReturnMemThruPtr_pView(__LINE__, pView, sizeof(VkImageView)) +#define vkCreateImageView_ReturnArrayThruPtr_pView(pView, cmock_len) vkCreateImageView_CMockReturnMemThruPtr_pView(__LINE__, pView, cmock_len * sizeof(*pView)) +#define vkCreateImageView_ReturnMemThruPtr_pView(pView, cmock_size) vkCreateImageView_CMockReturnMemThruPtr_pView(__LINE__, pView, cmock_size) +void vkCreateImageView_CMockReturnMemThruPtr_pView(UNITY_LINE_TYPE cmock_line, VkImageView const* pView, size_t cmock_size); +#define vkCreateImageView_IgnoreArg_device() vkCreateImageView_CMockIgnoreArg_device(__LINE__) +void vkCreateImageView_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateImageView_IgnoreArg_pCreateInfo() vkCreateImageView_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateImageView_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateImageView_IgnoreArg_pAllocator() vkCreateImageView_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateImageView_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateImageView_IgnoreArg_pView() vkCreateImageView_CMockIgnoreArg_pView(__LINE__) +void vkCreateImageView_CMockIgnoreArg_pView(UNITY_LINE_TYPE cmock_line); +#define vkDestroyImageView_Ignore() vkDestroyImageView_CMockIgnore() +void vkDestroyImageView_CMockIgnore(void); +#define vkDestroyImageView_StopIgnore() vkDestroyImageView_CMockStopIgnore() +void vkDestroyImageView_CMockStopIgnore(void); +#define vkDestroyImageView_ExpectAnyArgs() vkDestroyImageView_CMockExpectAnyArgs(__LINE__) +void vkDestroyImageView_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyImageView_Expect(device, imageView, pAllocator) vkDestroyImageView_CMockExpect(__LINE__, device, imageView, pAllocator) +void vkDestroyImageView_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyImageView_CALLBACK)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyImageView_AddCallback(CMOCK_vkDestroyImageView_CALLBACK Callback); +void vkDestroyImageView_Stub(CMOCK_vkDestroyImageView_CALLBACK Callback); +#define vkDestroyImageView_StubWithCallback vkDestroyImageView_AddCallback +#define vkDestroyImageView_IgnoreArg_device() vkDestroyImageView_CMockIgnoreArg_device(__LINE__) +void vkDestroyImageView_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyImageView_IgnoreArg_imageView() vkDestroyImageView_CMockIgnoreArg_imageView(__LINE__) +void vkDestroyImageView_CMockIgnoreArg_imageView(UNITY_LINE_TYPE cmock_line); +#define vkDestroyImageView_IgnoreArg_pAllocator() vkDestroyImageView_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyImageView_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateShaderModule_IgnoreAndReturn(cmock_retval) vkCreateShaderModule_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateShaderModule_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateShaderModule_StopIgnore() vkCreateShaderModule_CMockStopIgnore() +void vkCreateShaderModule_CMockStopIgnore(void); +#define vkCreateShaderModule_ExpectAnyArgsAndReturn(cmock_retval) vkCreateShaderModule_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateShaderModule_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateShaderModule_ExpectAndReturn(device, pCreateInfo, pAllocator, pShaderModule, cmock_retval) vkCreateShaderModule_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pShaderModule, cmock_retval) +void vkCreateShaderModule_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateShaderModule_CALLBACK)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule, int cmock_num_calls); +void vkCreateShaderModule_AddCallback(CMOCK_vkCreateShaderModule_CALLBACK Callback); +void vkCreateShaderModule_Stub(CMOCK_vkCreateShaderModule_CALLBACK Callback); +#define vkCreateShaderModule_StubWithCallback vkCreateShaderModule_AddCallback +#define vkCreateShaderModule_ReturnThruPtr_pShaderModule(pShaderModule) vkCreateShaderModule_CMockReturnMemThruPtr_pShaderModule(__LINE__, pShaderModule, sizeof(VkShaderModule)) +#define vkCreateShaderModule_ReturnArrayThruPtr_pShaderModule(pShaderModule, cmock_len) vkCreateShaderModule_CMockReturnMemThruPtr_pShaderModule(__LINE__, pShaderModule, cmock_len * sizeof(*pShaderModule)) +#define vkCreateShaderModule_ReturnMemThruPtr_pShaderModule(pShaderModule, cmock_size) vkCreateShaderModule_CMockReturnMemThruPtr_pShaderModule(__LINE__, pShaderModule, cmock_size) +void vkCreateShaderModule_CMockReturnMemThruPtr_pShaderModule(UNITY_LINE_TYPE cmock_line, VkShaderModule const* pShaderModule, size_t cmock_size); +#define vkCreateShaderModule_IgnoreArg_device() vkCreateShaderModule_CMockIgnoreArg_device(__LINE__) +void vkCreateShaderModule_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateShaderModule_IgnoreArg_pCreateInfo() vkCreateShaderModule_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateShaderModule_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateShaderModule_IgnoreArg_pAllocator() vkCreateShaderModule_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateShaderModule_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateShaderModule_IgnoreArg_pShaderModule() vkCreateShaderModule_CMockIgnoreArg_pShaderModule(__LINE__) +void vkCreateShaderModule_CMockIgnoreArg_pShaderModule(UNITY_LINE_TYPE cmock_line); +#define vkDestroyShaderModule_Ignore() vkDestroyShaderModule_CMockIgnore() +void vkDestroyShaderModule_CMockIgnore(void); +#define vkDestroyShaderModule_StopIgnore() vkDestroyShaderModule_CMockStopIgnore() +void vkDestroyShaderModule_CMockStopIgnore(void); +#define vkDestroyShaderModule_ExpectAnyArgs() vkDestroyShaderModule_CMockExpectAnyArgs(__LINE__) +void vkDestroyShaderModule_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyShaderModule_Expect(device, shaderModule, pAllocator) vkDestroyShaderModule_CMockExpect(__LINE__, device, shaderModule, pAllocator) +void vkDestroyShaderModule_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyShaderModule_CALLBACK)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyShaderModule_AddCallback(CMOCK_vkDestroyShaderModule_CALLBACK Callback); +void vkDestroyShaderModule_Stub(CMOCK_vkDestroyShaderModule_CALLBACK Callback); +#define vkDestroyShaderModule_StubWithCallback vkDestroyShaderModule_AddCallback +#define vkDestroyShaderModule_IgnoreArg_device() vkDestroyShaderModule_CMockIgnoreArg_device(__LINE__) +void vkDestroyShaderModule_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyShaderModule_IgnoreArg_shaderModule() vkDestroyShaderModule_CMockIgnoreArg_shaderModule(__LINE__) +void vkDestroyShaderModule_CMockIgnoreArg_shaderModule(UNITY_LINE_TYPE cmock_line); +#define vkDestroyShaderModule_IgnoreArg_pAllocator() vkDestroyShaderModule_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyShaderModule_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreatePipelineCache_IgnoreAndReturn(cmock_retval) vkCreatePipelineCache_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreatePipelineCache_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreatePipelineCache_StopIgnore() vkCreatePipelineCache_CMockStopIgnore() +void vkCreatePipelineCache_CMockStopIgnore(void); +#define vkCreatePipelineCache_ExpectAnyArgsAndReturn(cmock_retval) vkCreatePipelineCache_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreatePipelineCache_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreatePipelineCache_ExpectAndReturn(device, pCreateInfo, pAllocator, pPipelineCache, cmock_retval) vkCreatePipelineCache_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pPipelineCache, cmock_retval) +void vkCreatePipelineCache_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreatePipelineCache_CALLBACK)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache, int cmock_num_calls); +void vkCreatePipelineCache_AddCallback(CMOCK_vkCreatePipelineCache_CALLBACK Callback); +void vkCreatePipelineCache_Stub(CMOCK_vkCreatePipelineCache_CALLBACK Callback); +#define vkCreatePipelineCache_StubWithCallback vkCreatePipelineCache_AddCallback +#define vkCreatePipelineCache_ReturnThruPtr_pPipelineCache(pPipelineCache) vkCreatePipelineCache_CMockReturnMemThruPtr_pPipelineCache(__LINE__, pPipelineCache, sizeof(VkPipelineCache)) +#define vkCreatePipelineCache_ReturnArrayThruPtr_pPipelineCache(pPipelineCache, cmock_len) vkCreatePipelineCache_CMockReturnMemThruPtr_pPipelineCache(__LINE__, pPipelineCache, cmock_len * sizeof(*pPipelineCache)) +#define vkCreatePipelineCache_ReturnMemThruPtr_pPipelineCache(pPipelineCache, cmock_size) vkCreatePipelineCache_CMockReturnMemThruPtr_pPipelineCache(__LINE__, pPipelineCache, cmock_size) +void vkCreatePipelineCache_CMockReturnMemThruPtr_pPipelineCache(UNITY_LINE_TYPE cmock_line, VkPipelineCache const* pPipelineCache, size_t cmock_size); +#define vkCreatePipelineCache_IgnoreArg_device() vkCreatePipelineCache_CMockIgnoreArg_device(__LINE__) +void vkCreatePipelineCache_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreatePipelineCache_IgnoreArg_pCreateInfo() vkCreatePipelineCache_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreatePipelineCache_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreatePipelineCache_IgnoreArg_pAllocator() vkCreatePipelineCache_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreatePipelineCache_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreatePipelineCache_IgnoreArg_pPipelineCache() vkCreatePipelineCache_CMockIgnoreArg_pPipelineCache(__LINE__) +void vkCreatePipelineCache_CMockIgnoreArg_pPipelineCache(UNITY_LINE_TYPE cmock_line); +#define vkDestroyPipelineCache_Ignore() vkDestroyPipelineCache_CMockIgnore() +void vkDestroyPipelineCache_CMockIgnore(void); +#define vkDestroyPipelineCache_StopIgnore() vkDestroyPipelineCache_CMockStopIgnore() +void vkDestroyPipelineCache_CMockStopIgnore(void); +#define vkDestroyPipelineCache_ExpectAnyArgs() vkDestroyPipelineCache_CMockExpectAnyArgs(__LINE__) +void vkDestroyPipelineCache_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyPipelineCache_Expect(device, pipelineCache, pAllocator) vkDestroyPipelineCache_CMockExpect(__LINE__, device, pipelineCache, pAllocator) +void vkDestroyPipelineCache_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyPipelineCache_CALLBACK)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyPipelineCache_AddCallback(CMOCK_vkDestroyPipelineCache_CALLBACK Callback); +void vkDestroyPipelineCache_Stub(CMOCK_vkDestroyPipelineCache_CALLBACK Callback); +#define vkDestroyPipelineCache_StubWithCallback vkDestroyPipelineCache_AddCallback +#define vkDestroyPipelineCache_IgnoreArg_device() vkDestroyPipelineCache_CMockIgnoreArg_device(__LINE__) +void vkDestroyPipelineCache_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyPipelineCache_IgnoreArg_pipelineCache() vkDestroyPipelineCache_CMockIgnoreArg_pipelineCache(__LINE__) +void vkDestroyPipelineCache_CMockIgnoreArg_pipelineCache(UNITY_LINE_TYPE cmock_line); +#define vkDestroyPipelineCache_IgnoreArg_pAllocator() vkDestroyPipelineCache_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyPipelineCache_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkGetPipelineCacheData_IgnoreAndReturn(cmock_retval) vkGetPipelineCacheData_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPipelineCacheData_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPipelineCacheData_StopIgnore() vkGetPipelineCacheData_CMockStopIgnore() +void vkGetPipelineCacheData_CMockStopIgnore(void); +#define vkGetPipelineCacheData_ExpectAnyArgsAndReturn(cmock_retval) vkGetPipelineCacheData_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPipelineCacheData_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPipelineCacheData_ExpectAndReturn(device, pipelineCache, pDataSize, pData, cmock_retval) vkGetPipelineCacheData_CMockExpectAndReturn(__LINE__, device, pipelineCache, pDataSize, pData, cmock_retval) +void vkGetPipelineCacheData_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPipelineCacheData_CALLBACK)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData, int cmock_num_calls); +void vkGetPipelineCacheData_AddCallback(CMOCK_vkGetPipelineCacheData_CALLBACK Callback); +void vkGetPipelineCacheData_Stub(CMOCK_vkGetPipelineCacheData_CALLBACK Callback); +#define vkGetPipelineCacheData_StubWithCallback vkGetPipelineCacheData_AddCallback +#define vkGetPipelineCacheData_ReturnThruPtr_pDataSize(pDataSize) vkGetPipelineCacheData_CMockReturnMemThruPtr_pDataSize(__LINE__, pDataSize, sizeof(size_t)) +#define vkGetPipelineCacheData_ReturnArrayThruPtr_pDataSize(pDataSize, cmock_len) vkGetPipelineCacheData_CMockReturnMemThruPtr_pDataSize(__LINE__, pDataSize, cmock_len * sizeof(*pDataSize)) +#define vkGetPipelineCacheData_ReturnMemThruPtr_pDataSize(pDataSize, cmock_size) vkGetPipelineCacheData_CMockReturnMemThruPtr_pDataSize(__LINE__, pDataSize, cmock_size) +void vkGetPipelineCacheData_CMockReturnMemThruPtr_pDataSize(UNITY_LINE_TYPE cmock_line, size_t const* pDataSize, size_t cmock_size); +#define vkGetPipelineCacheData_ReturnThruPtr_pData(pData) vkGetPipelineCacheData_CMockReturnMemThruPtr_pData(__LINE__, pData, sizeof(*pData)) +#define vkGetPipelineCacheData_ReturnArrayThruPtr_pData(pData, cmock_len) vkGetPipelineCacheData_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_len * sizeof(*pData)) +#define vkGetPipelineCacheData_ReturnMemThruPtr_pData(pData, cmock_size) vkGetPipelineCacheData_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_size) +void vkGetPipelineCacheData_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, void const* pData, size_t cmock_size); +#define vkGetPipelineCacheData_IgnoreArg_device() vkGetPipelineCacheData_CMockIgnoreArg_device(__LINE__) +void vkGetPipelineCacheData_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetPipelineCacheData_IgnoreArg_pipelineCache() vkGetPipelineCacheData_CMockIgnoreArg_pipelineCache(__LINE__) +void vkGetPipelineCacheData_CMockIgnoreArg_pipelineCache(UNITY_LINE_TYPE cmock_line); +#define vkGetPipelineCacheData_IgnoreArg_pDataSize() vkGetPipelineCacheData_CMockIgnoreArg_pDataSize(__LINE__) +void vkGetPipelineCacheData_CMockIgnoreArg_pDataSize(UNITY_LINE_TYPE cmock_line); +#define vkGetPipelineCacheData_IgnoreArg_pData() vkGetPipelineCacheData_CMockIgnoreArg_pData(__LINE__) +void vkGetPipelineCacheData_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line); +#define vkMergePipelineCaches_IgnoreAndReturn(cmock_retval) vkMergePipelineCaches_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkMergePipelineCaches_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkMergePipelineCaches_StopIgnore() vkMergePipelineCaches_CMockStopIgnore() +void vkMergePipelineCaches_CMockStopIgnore(void); +#define vkMergePipelineCaches_ExpectAnyArgsAndReturn(cmock_retval) vkMergePipelineCaches_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkMergePipelineCaches_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkMergePipelineCaches_ExpectAndReturn(device, dstCache, srcCacheCount, pSrcCaches, cmock_retval) vkMergePipelineCaches_CMockExpectAndReturn(__LINE__, device, dstCache, srcCacheCount, pSrcCaches, cmock_retval) +void vkMergePipelineCaches_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkMergePipelineCaches_CALLBACK)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches, int cmock_num_calls); +void vkMergePipelineCaches_AddCallback(CMOCK_vkMergePipelineCaches_CALLBACK Callback); +void vkMergePipelineCaches_Stub(CMOCK_vkMergePipelineCaches_CALLBACK Callback); +#define vkMergePipelineCaches_StubWithCallback vkMergePipelineCaches_AddCallback +#define vkMergePipelineCaches_IgnoreArg_device() vkMergePipelineCaches_CMockIgnoreArg_device(__LINE__) +void vkMergePipelineCaches_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkMergePipelineCaches_IgnoreArg_dstCache() vkMergePipelineCaches_CMockIgnoreArg_dstCache(__LINE__) +void vkMergePipelineCaches_CMockIgnoreArg_dstCache(UNITY_LINE_TYPE cmock_line); +#define vkMergePipelineCaches_IgnoreArg_srcCacheCount() vkMergePipelineCaches_CMockIgnoreArg_srcCacheCount(__LINE__) +void vkMergePipelineCaches_CMockIgnoreArg_srcCacheCount(UNITY_LINE_TYPE cmock_line); +#define vkMergePipelineCaches_IgnoreArg_pSrcCaches() vkMergePipelineCaches_CMockIgnoreArg_pSrcCaches(__LINE__) +void vkMergePipelineCaches_CMockIgnoreArg_pSrcCaches(UNITY_LINE_TYPE cmock_line); +#define vkCreateGraphicsPipelines_IgnoreAndReturn(cmock_retval) vkCreateGraphicsPipelines_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateGraphicsPipelines_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateGraphicsPipelines_StopIgnore() vkCreateGraphicsPipelines_CMockStopIgnore() +void vkCreateGraphicsPipelines_CMockStopIgnore(void); +#define vkCreateGraphicsPipelines_ExpectAnyArgsAndReturn(cmock_retval) vkCreateGraphicsPipelines_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateGraphicsPipelines_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateGraphicsPipelines_ExpectAndReturn(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, cmock_retval) vkCreateGraphicsPipelines_CMockExpectAndReturn(__LINE__, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, cmock_retval) +void vkCreateGraphicsPipelines_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateGraphicsPipelines_CALLBACK)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, int cmock_num_calls); +void vkCreateGraphicsPipelines_AddCallback(CMOCK_vkCreateGraphicsPipelines_CALLBACK Callback); +void vkCreateGraphicsPipelines_Stub(CMOCK_vkCreateGraphicsPipelines_CALLBACK Callback); +#define vkCreateGraphicsPipelines_StubWithCallback vkCreateGraphicsPipelines_AddCallback +#define vkCreateGraphicsPipelines_ReturnThruPtr_pPipelines(pPipelines) vkCreateGraphicsPipelines_CMockReturnMemThruPtr_pPipelines(__LINE__, pPipelines, sizeof(VkPipeline)) +#define vkCreateGraphicsPipelines_ReturnArrayThruPtr_pPipelines(pPipelines, cmock_len) vkCreateGraphicsPipelines_CMockReturnMemThruPtr_pPipelines(__LINE__, pPipelines, cmock_len * sizeof(*pPipelines)) +#define vkCreateGraphicsPipelines_ReturnMemThruPtr_pPipelines(pPipelines, cmock_size) vkCreateGraphicsPipelines_CMockReturnMemThruPtr_pPipelines(__LINE__, pPipelines, cmock_size) +void vkCreateGraphicsPipelines_CMockReturnMemThruPtr_pPipelines(UNITY_LINE_TYPE cmock_line, VkPipeline const* pPipelines, size_t cmock_size); +#define vkCreateGraphicsPipelines_IgnoreArg_device() vkCreateGraphicsPipelines_CMockIgnoreArg_device(__LINE__) +void vkCreateGraphicsPipelines_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateGraphicsPipelines_IgnoreArg_pipelineCache() vkCreateGraphicsPipelines_CMockIgnoreArg_pipelineCache(__LINE__) +void vkCreateGraphicsPipelines_CMockIgnoreArg_pipelineCache(UNITY_LINE_TYPE cmock_line); +#define vkCreateGraphicsPipelines_IgnoreArg_createInfoCount() vkCreateGraphicsPipelines_CMockIgnoreArg_createInfoCount(__LINE__) +void vkCreateGraphicsPipelines_CMockIgnoreArg_createInfoCount(UNITY_LINE_TYPE cmock_line); +#define vkCreateGraphicsPipelines_IgnoreArg_pCreateInfos() vkCreateGraphicsPipelines_CMockIgnoreArg_pCreateInfos(__LINE__) +void vkCreateGraphicsPipelines_CMockIgnoreArg_pCreateInfos(UNITY_LINE_TYPE cmock_line); +#define vkCreateGraphicsPipelines_IgnoreArg_pAllocator() vkCreateGraphicsPipelines_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateGraphicsPipelines_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateGraphicsPipelines_IgnoreArg_pPipelines() vkCreateGraphicsPipelines_CMockIgnoreArg_pPipelines(__LINE__) +void vkCreateGraphicsPipelines_CMockIgnoreArg_pPipelines(UNITY_LINE_TYPE cmock_line); +#define vkCreateComputePipelines_IgnoreAndReturn(cmock_retval) vkCreateComputePipelines_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateComputePipelines_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateComputePipelines_StopIgnore() vkCreateComputePipelines_CMockStopIgnore() +void vkCreateComputePipelines_CMockStopIgnore(void); +#define vkCreateComputePipelines_ExpectAnyArgsAndReturn(cmock_retval) vkCreateComputePipelines_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateComputePipelines_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateComputePipelines_ExpectAndReturn(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, cmock_retval) vkCreateComputePipelines_CMockExpectAndReturn(__LINE__, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, cmock_retval) +void vkCreateComputePipelines_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateComputePipelines_CALLBACK)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, int cmock_num_calls); +void vkCreateComputePipelines_AddCallback(CMOCK_vkCreateComputePipelines_CALLBACK Callback); +void vkCreateComputePipelines_Stub(CMOCK_vkCreateComputePipelines_CALLBACK Callback); +#define vkCreateComputePipelines_StubWithCallback vkCreateComputePipelines_AddCallback +#define vkCreateComputePipelines_ReturnThruPtr_pPipelines(pPipelines) vkCreateComputePipelines_CMockReturnMemThruPtr_pPipelines(__LINE__, pPipelines, sizeof(VkPipeline)) +#define vkCreateComputePipelines_ReturnArrayThruPtr_pPipelines(pPipelines, cmock_len) vkCreateComputePipelines_CMockReturnMemThruPtr_pPipelines(__LINE__, pPipelines, cmock_len * sizeof(*pPipelines)) +#define vkCreateComputePipelines_ReturnMemThruPtr_pPipelines(pPipelines, cmock_size) vkCreateComputePipelines_CMockReturnMemThruPtr_pPipelines(__LINE__, pPipelines, cmock_size) +void vkCreateComputePipelines_CMockReturnMemThruPtr_pPipelines(UNITY_LINE_TYPE cmock_line, VkPipeline const* pPipelines, size_t cmock_size); +#define vkCreateComputePipelines_IgnoreArg_device() vkCreateComputePipelines_CMockIgnoreArg_device(__LINE__) +void vkCreateComputePipelines_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateComputePipelines_IgnoreArg_pipelineCache() vkCreateComputePipelines_CMockIgnoreArg_pipelineCache(__LINE__) +void vkCreateComputePipelines_CMockIgnoreArg_pipelineCache(UNITY_LINE_TYPE cmock_line); +#define vkCreateComputePipelines_IgnoreArg_createInfoCount() vkCreateComputePipelines_CMockIgnoreArg_createInfoCount(__LINE__) +void vkCreateComputePipelines_CMockIgnoreArg_createInfoCount(UNITY_LINE_TYPE cmock_line); +#define vkCreateComputePipelines_IgnoreArg_pCreateInfos() vkCreateComputePipelines_CMockIgnoreArg_pCreateInfos(__LINE__) +void vkCreateComputePipelines_CMockIgnoreArg_pCreateInfos(UNITY_LINE_TYPE cmock_line); +#define vkCreateComputePipelines_IgnoreArg_pAllocator() vkCreateComputePipelines_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateComputePipelines_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateComputePipelines_IgnoreArg_pPipelines() vkCreateComputePipelines_CMockIgnoreArg_pPipelines(__LINE__) +void vkCreateComputePipelines_CMockIgnoreArg_pPipelines(UNITY_LINE_TYPE cmock_line); +#define vkDestroyPipeline_Ignore() vkDestroyPipeline_CMockIgnore() +void vkDestroyPipeline_CMockIgnore(void); +#define vkDestroyPipeline_StopIgnore() vkDestroyPipeline_CMockStopIgnore() +void vkDestroyPipeline_CMockStopIgnore(void); +#define vkDestroyPipeline_ExpectAnyArgs() vkDestroyPipeline_CMockExpectAnyArgs(__LINE__) +void vkDestroyPipeline_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyPipeline_Expect(device, pipeline, pAllocator) vkDestroyPipeline_CMockExpect(__LINE__, device, pipeline, pAllocator) +void vkDestroyPipeline_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyPipeline_CALLBACK)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyPipeline_AddCallback(CMOCK_vkDestroyPipeline_CALLBACK Callback); +void vkDestroyPipeline_Stub(CMOCK_vkDestroyPipeline_CALLBACK Callback); +#define vkDestroyPipeline_StubWithCallback vkDestroyPipeline_AddCallback +#define vkDestroyPipeline_IgnoreArg_device() vkDestroyPipeline_CMockIgnoreArg_device(__LINE__) +void vkDestroyPipeline_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyPipeline_IgnoreArg_pipeline() vkDestroyPipeline_CMockIgnoreArg_pipeline(__LINE__) +void vkDestroyPipeline_CMockIgnoreArg_pipeline(UNITY_LINE_TYPE cmock_line); +#define vkDestroyPipeline_IgnoreArg_pAllocator() vkDestroyPipeline_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyPipeline_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreatePipelineLayout_IgnoreAndReturn(cmock_retval) vkCreatePipelineLayout_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreatePipelineLayout_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreatePipelineLayout_StopIgnore() vkCreatePipelineLayout_CMockStopIgnore() +void vkCreatePipelineLayout_CMockStopIgnore(void); +#define vkCreatePipelineLayout_ExpectAnyArgsAndReturn(cmock_retval) vkCreatePipelineLayout_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreatePipelineLayout_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreatePipelineLayout_ExpectAndReturn(device, pCreateInfo, pAllocator, pPipelineLayout, cmock_retval) vkCreatePipelineLayout_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pPipelineLayout, cmock_retval) +void vkCreatePipelineLayout_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreatePipelineLayout_CALLBACK)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout, int cmock_num_calls); +void vkCreatePipelineLayout_AddCallback(CMOCK_vkCreatePipelineLayout_CALLBACK Callback); +void vkCreatePipelineLayout_Stub(CMOCK_vkCreatePipelineLayout_CALLBACK Callback); +#define vkCreatePipelineLayout_StubWithCallback vkCreatePipelineLayout_AddCallback +#define vkCreatePipelineLayout_ReturnThruPtr_pPipelineLayout(pPipelineLayout) vkCreatePipelineLayout_CMockReturnMemThruPtr_pPipelineLayout(__LINE__, pPipelineLayout, sizeof(VkPipelineLayout)) +#define vkCreatePipelineLayout_ReturnArrayThruPtr_pPipelineLayout(pPipelineLayout, cmock_len) vkCreatePipelineLayout_CMockReturnMemThruPtr_pPipelineLayout(__LINE__, pPipelineLayout, cmock_len * sizeof(*pPipelineLayout)) +#define vkCreatePipelineLayout_ReturnMemThruPtr_pPipelineLayout(pPipelineLayout, cmock_size) vkCreatePipelineLayout_CMockReturnMemThruPtr_pPipelineLayout(__LINE__, pPipelineLayout, cmock_size) +void vkCreatePipelineLayout_CMockReturnMemThruPtr_pPipelineLayout(UNITY_LINE_TYPE cmock_line, VkPipelineLayout const* pPipelineLayout, size_t cmock_size); +#define vkCreatePipelineLayout_IgnoreArg_device() vkCreatePipelineLayout_CMockIgnoreArg_device(__LINE__) +void vkCreatePipelineLayout_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreatePipelineLayout_IgnoreArg_pCreateInfo() vkCreatePipelineLayout_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreatePipelineLayout_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreatePipelineLayout_IgnoreArg_pAllocator() vkCreatePipelineLayout_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreatePipelineLayout_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreatePipelineLayout_IgnoreArg_pPipelineLayout() vkCreatePipelineLayout_CMockIgnoreArg_pPipelineLayout(__LINE__) +void vkCreatePipelineLayout_CMockIgnoreArg_pPipelineLayout(UNITY_LINE_TYPE cmock_line); +#define vkDestroyPipelineLayout_Ignore() vkDestroyPipelineLayout_CMockIgnore() +void vkDestroyPipelineLayout_CMockIgnore(void); +#define vkDestroyPipelineLayout_StopIgnore() vkDestroyPipelineLayout_CMockStopIgnore() +void vkDestroyPipelineLayout_CMockStopIgnore(void); +#define vkDestroyPipelineLayout_ExpectAnyArgs() vkDestroyPipelineLayout_CMockExpectAnyArgs(__LINE__) +void vkDestroyPipelineLayout_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyPipelineLayout_Expect(device, pipelineLayout, pAllocator) vkDestroyPipelineLayout_CMockExpect(__LINE__, device, pipelineLayout, pAllocator) +void vkDestroyPipelineLayout_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyPipelineLayout_CALLBACK)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyPipelineLayout_AddCallback(CMOCK_vkDestroyPipelineLayout_CALLBACK Callback); +void vkDestroyPipelineLayout_Stub(CMOCK_vkDestroyPipelineLayout_CALLBACK Callback); +#define vkDestroyPipelineLayout_StubWithCallback vkDestroyPipelineLayout_AddCallback +#define vkDestroyPipelineLayout_IgnoreArg_device() vkDestroyPipelineLayout_CMockIgnoreArg_device(__LINE__) +void vkDestroyPipelineLayout_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyPipelineLayout_IgnoreArg_pipelineLayout() vkDestroyPipelineLayout_CMockIgnoreArg_pipelineLayout(__LINE__) +void vkDestroyPipelineLayout_CMockIgnoreArg_pipelineLayout(UNITY_LINE_TYPE cmock_line); +#define vkDestroyPipelineLayout_IgnoreArg_pAllocator() vkDestroyPipelineLayout_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyPipelineLayout_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateSampler_IgnoreAndReturn(cmock_retval) vkCreateSampler_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateSampler_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateSampler_StopIgnore() vkCreateSampler_CMockStopIgnore() +void vkCreateSampler_CMockStopIgnore(void); +#define vkCreateSampler_ExpectAnyArgsAndReturn(cmock_retval) vkCreateSampler_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateSampler_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateSampler_ExpectAndReturn(device, pCreateInfo, pAllocator, pSampler, cmock_retval) vkCreateSampler_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pSampler, cmock_retval) +void vkCreateSampler_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateSampler_CALLBACK)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler, int cmock_num_calls); +void vkCreateSampler_AddCallback(CMOCK_vkCreateSampler_CALLBACK Callback); +void vkCreateSampler_Stub(CMOCK_vkCreateSampler_CALLBACK Callback); +#define vkCreateSampler_StubWithCallback vkCreateSampler_AddCallback +#define vkCreateSampler_ReturnThruPtr_pSampler(pSampler) vkCreateSampler_CMockReturnMemThruPtr_pSampler(__LINE__, pSampler, sizeof(VkSampler)) +#define vkCreateSampler_ReturnArrayThruPtr_pSampler(pSampler, cmock_len) vkCreateSampler_CMockReturnMemThruPtr_pSampler(__LINE__, pSampler, cmock_len * sizeof(*pSampler)) +#define vkCreateSampler_ReturnMemThruPtr_pSampler(pSampler, cmock_size) vkCreateSampler_CMockReturnMemThruPtr_pSampler(__LINE__, pSampler, cmock_size) +void vkCreateSampler_CMockReturnMemThruPtr_pSampler(UNITY_LINE_TYPE cmock_line, VkSampler const* pSampler, size_t cmock_size); +#define vkCreateSampler_IgnoreArg_device() vkCreateSampler_CMockIgnoreArg_device(__LINE__) +void vkCreateSampler_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateSampler_IgnoreArg_pCreateInfo() vkCreateSampler_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateSampler_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateSampler_IgnoreArg_pAllocator() vkCreateSampler_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateSampler_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateSampler_IgnoreArg_pSampler() vkCreateSampler_CMockIgnoreArg_pSampler(__LINE__) +void vkCreateSampler_CMockIgnoreArg_pSampler(UNITY_LINE_TYPE cmock_line); +#define vkDestroySampler_Ignore() vkDestroySampler_CMockIgnore() +void vkDestroySampler_CMockIgnore(void); +#define vkDestroySampler_StopIgnore() vkDestroySampler_CMockStopIgnore() +void vkDestroySampler_CMockStopIgnore(void); +#define vkDestroySampler_ExpectAnyArgs() vkDestroySampler_CMockExpectAnyArgs(__LINE__) +void vkDestroySampler_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroySampler_Expect(device, sampler, pAllocator) vkDestroySampler_CMockExpect(__LINE__, device, sampler, pAllocator) +void vkDestroySampler_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroySampler_CALLBACK)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroySampler_AddCallback(CMOCK_vkDestroySampler_CALLBACK Callback); +void vkDestroySampler_Stub(CMOCK_vkDestroySampler_CALLBACK Callback); +#define vkDestroySampler_StubWithCallback vkDestroySampler_AddCallback +#define vkDestroySampler_IgnoreArg_device() vkDestroySampler_CMockIgnoreArg_device(__LINE__) +void vkDestroySampler_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroySampler_IgnoreArg_sampler() vkDestroySampler_CMockIgnoreArg_sampler(__LINE__) +void vkDestroySampler_CMockIgnoreArg_sampler(UNITY_LINE_TYPE cmock_line); +#define vkDestroySampler_IgnoreArg_pAllocator() vkDestroySampler_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroySampler_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateDescriptorSetLayout_IgnoreAndReturn(cmock_retval) vkCreateDescriptorSetLayout_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateDescriptorSetLayout_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateDescriptorSetLayout_StopIgnore() vkCreateDescriptorSetLayout_CMockStopIgnore() +void vkCreateDescriptorSetLayout_CMockStopIgnore(void); +#define vkCreateDescriptorSetLayout_ExpectAnyArgsAndReturn(cmock_retval) vkCreateDescriptorSetLayout_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateDescriptorSetLayout_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateDescriptorSetLayout_ExpectAndReturn(device, pCreateInfo, pAllocator, pSetLayout, cmock_retval) vkCreateDescriptorSetLayout_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pSetLayout, cmock_retval) +void vkCreateDescriptorSetLayout_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateDescriptorSetLayout_CALLBACK)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout, int cmock_num_calls); +void vkCreateDescriptorSetLayout_AddCallback(CMOCK_vkCreateDescriptorSetLayout_CALLBACK Callback); +void vkCreateDescriptorSetLayout_Stub(CMOCK_vkCreateDescriptorSetLayout_CALLBACK Callback); +#define vkCreateDescriptorSetLayout_StubWithCallback vkCreateDescriptorSetLayout_AddCallback +#define vkCreateDescriptorSetLayout_ReturnThruPtr_pSetLayout(pSetLayout) vkCreateDescriptorSetLayout_CMockReturnMemThruPtr_pSetLayout(__LINE__, pSetLayout, sizeof(VkDescriptorSetLayout)) +#define vkCreateDescriptorSetLayout_ReturnArrayThruPtr_pSetLayout(pSetLayout, cmock_len) vkCreateDescriptorSetLayout_CMockReturnMemThruPtr_pSetLayout(__LINE__, pSetLayout, cmock_len * sizeof(*pSetLayout)) +#define vkCreateDescriptorSetLayout_ReturnMemThruPtr_pSetLayout(pSetLayout, cmock_size) vkCreateDescriptorSetLayout_CMockReturnMemThruPtr_pSetLayout(__LINE__, pSetLayout, cmock_size) +void vkCreateDescriptorSetLayout_CMockReturnMemThruPtr_pSetLayout(UNITY_LINE_TYPE cmock_line, VkDescriptorSetLayout const* pSetLayout, size_t cmock_size); +#define vkCreateDescriptorSetLayout_IgnoreArg_device() vkCreateDescriptorSetLayout_CMockIgnoreArg_device(__LINE__) +void vkCreateDescriptorSetLayout_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateDescriptorSetLayout_IgnoreArg_pCreateInfo() vkCreateDescriptorSetLayout_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateDescriptorSetLayout_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateDescriptorSetLayout_IgnoreArg_pAllocator() vkCreateDescriptorSetLayout_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateDescriptorSetLayout_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateDescriptorSetLayout_IgnoreArg_pSetLayout() vkCreateDescriptorSetLayout_CMockIgnoreArg_pSetLayout(__LINE__) +void vkCreateDescriptorSetLayout_CMockIgnoreArg_pSetLayout(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDescriptorSetLayout_Ignore() vkDestroyDescriptorSetLayout_CMockIgnore() +void vkDestroyDescriptorSetLayout_CMockIgnore(void); +#define vkDestroyDescriptorSetLayout_StopIgnore() vkDestroyDescriptorSetLayout_CMockStopIgnore() +void vkDestroyDescriptorSetLayout_CMockStopIgnore(void); +#define vkDestroyDescriptorSetLayout_ExpectAnyArgs() vkDestroyDescriptorSetLayout_CMockExpectAnyArgs(__LINE__) +void vkDestroyDescriptorSetLayout_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDescriptorSetLayout_Expect(device, descriptorSetLayout, pAllocator) vkDestroyDescriptorSetLayout_CMockExpect(__LINE__, device, descriptorSetLayout, pAllocator) +void vkDestroyDescriptorSetLayout_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyDescriptorSetLayout_CALLBACK)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyDescriptorSetLayout_AddCallback(CMOCK_vkDestroyDescriptorSetLayout_CALLBACK Callback); +void vkDestroyDescriptorSetLayout_Stub(CMOCK_vkDestroyDescriptorSetLayout_CALLBACK Callback); +#define vkDestroyDescriptorSetLayout_StubWithCallback vkDestroyDescriptorSetLayout_AddCallback +#define vkDestroyDescriptorSetLayout_IgnoreArg_device() vkDestroyDescriptorSetLayout_CMockIgnoreArg_device(__LINE__) +void vkDestroyDescriptorSetLayout_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDescriptorSetLayout_IgnoreArg_descriptorSetLayout() vkDestroyDescriptorSetLayout_CMockIgnoreArg_descriptorSetLayout(__LINE__) +void vkDestroyDescriptorSetLayout_CMockIgnoreArg_descriptorSetLayout(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDescriptorSetLayout_IgnoreArg_pAllocator() vkDestroyDescriptorSetLayout_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyDescriptorSetLayout_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateDescriptorPool_IgnoreAndReturn(cmock_retval) vkCreateDescriptorPool_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateDescriptorPool_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateDescriptorPool_StopIgnore() vkCreateDescriptorPool_CMockStopIgnore() +void vkCreateDescriptorPool_CMockStopIgnore(void); +#define vkCreateDescriptorPool_ExpectAnyArgsAndReturn(cmock_retval) vkCreateDescriptorPool_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateDescriptorPool_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateDescriptorPool_ExpectAndReturn(device, pCreateInfo, pAllocator, pDescriptorPool, cmock_retval) vkCreateDescriptorPool_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pDescriptorPool, cmock_retval) +void vkCreateDescriptorPool_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateDescriptorPool_CALLBACK)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool, int cmock_num_calls); +void vkCreateDescriptorPool_AddCallback(CMOCK_vkCreateDescriptorPool_CALLBACK Callback); +void vkCreateDescriptorPool_Stub(CMOCK_vkCreateDescriptorPool_CALLBACK Callback); +#define vkCreateDescriptorPool_StubWithCallback vkCreateDescriptorPool_AddCallback +#define vkCreateDescriptorPool_ReturnThruPtr_pDescriptorPool(pDescriptorPool) vkCreateDescriptorPool_CMockReturnMemThruPtr_pDescriptorPool(__LINE__, pDescriptorPool, sizeof(VkDescriptorPool)) +#define vkCreateDescriptorPool_ReturnArrayThruPtr_pDescriptorPool(pDescriptorPool, cmock_len) vkCreateDescriptorPool_CMockReturnMemThruPtr_pDescriptorPool(__LINE__, pDescriptorPool, cmock_len * sizeof(*pDescriptorPool)) +#define vkCreateDescriptorPool_ReturnMemThruPtr_pDescriptorPool(pDescriptorPool, cmock_size) vkCreateDescriptorPool_CMockReturnMemThruPtr_pDescriptorPool(__LINE__, pDescriptorPool, cmock_size) +void vkCreateDescriptorPool_CMockReturnMemThruPtr_pDescriptorPool(UNITY_LINE_TYPE cmock_line, VkDescriptorPool const* pDescriptorPool, size_t cmock_size); +#define vkCreateDescriptorPool_IgnoreArg_device() vkCreateDescriptorPool_CMockIgnoreArg_device(__LINE__) +void vkCreateDescriptorPool_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateDescriptorPool_IgnoreArg_pCreateInfo() vkCreateDescriptorPool_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateDescriptorPool_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateDescriptorPool_IgnoreArg_pAllocator() vkCreateDescriptorPool_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateDescriptorPool_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateDescriptorPool_IgnoreArg_pDescriptorPool() vkCreateDescriptorPool_CMockIgnoreArg_pDescriptorPool(__LINE__) +void vkCreateDescriptorPool_CMockIgnoreArg_pDescriptorPool(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDescriptorPool_Ignore() vkDestroyDescriptorPool_CMockIgnore() +void vkDestroyDescriptorPool_CMockIgnore(void); +#define vkDestroyDescriptorPool_StopIgnore() vkDestroyDescriptorPool_CMockStopIgnore() +void vkDestroyDescriptorPool_CMockStopIgnore(void); +#define vkDestroyDescriptorPool_ExpectAnyArgs() vkDestroyDescriptorPool_CMockExpectAnyArgs(__LINE__) +void vkDestroyDescriptorPool_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDescriptorPool_Expect(device, descriptorPool, pAllocator) vkDestroyDescriptorPool_CMockExpect(__LINE__, device, descriptorPool, pAllocator) +void vkDestroyDescriptorPool_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyDescriptorPool_CALLBACK)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyDescriptorPool_AddCallback(CMOCK_vkDestroyDescriptorPool_CALLBACK Callback); +void vkDestroyDescriptorPool_Stub(CMOCK_vkDestroyDescriptorPool_CALLBACK Callback); +#define vkDestroyDescriptorPool_StubWithCallback vkDestroyDescriptorPool_AddCallback +#define vkDestroyDescriptorPool_IgnoreArg_device() vkDestroyDescriptorPool_CMockIgnoreArg_device(__LINE__) +void vkDestroyDescriptorPool_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDescriptorPool_IgnoreArg_descriptorPool() vkDestroyDescriptorPool_CMockIgnoreArg_descriptorPool(__LINE__) +void vkDestroyDescriptorPool_CMockIgnoreArg_descriptorPool(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDescriptorPool_IgnoreArg_pAllocator() vkDestroyDescriptorPool_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyDescriptorPool_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkResetDescriptorPool_IgnoreAndReturn(cmock_retval) vkResetDescriptorPool_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkResetDescriptorPool_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkResetDescriptorPool_StopIgnore() vkResetDescriptorPool_CMockStopIgnore() +void vkResetDescriptorPool_CMockStopIgnore(void); +#define vkResetDescriptorPool_ExpectAnyArgsAndReturn(cmock_retval) vkResetDescriptorPool_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkResetDescriptorPool_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkResetDescriptorPool_ExpectAndReturn(device, descriptorPool, flags, cmock_retval) vkResetDescriptorPool_CMockExpectAndReturn(__LINE__, device, descriptorPool, flags, cmock_retval) +void vkResetDescriptorPool_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkResetDescriptorPool_CALLBACK)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags, int cmock_num_calls); +void vkResetDescriptorPool_AddCallback(CMOCK_vkResetDescriptorPool_CALLBACK Callback); +void vkResetDescriptorPool_Stub(CMOCK_vkResetDescriptorPool_CALLBACK Callback); +#define vkResetDescriptorPool_StubWithCallback vkResetDescriptorPool_AddCallback +#define vkResetDescriptorPool_IgnoreArg_device() vkResetDescriptorPool_CMockIgnoreArg_device(__LINE__) +void vkResetDescriptorPool_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkResetDescriptorPool_IgnoreArg_descriptorPool() vkResetDescriptorPool_CMockIgnoreArg_descriptorPool(__LINE__) +void vkResetDescriptorPool_CMockIgnoreArg_descriptorPool(UNITY_LINE_TYPE cmock_line); +#define vkResetDescriptorPool_IgnoreArg_flags() vkResetDescriptorPool_CMockIgnoreArg_flags(__LINE__) +void vkResetDescriptorPool_CMockIgnoreArg_flags(UNITY_LINE_TYPE cmock_line); +#define vkAllocateDescriptorSets_IgnoreAndReturn(cmock_retval) vkAllocateDescriptorSets_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkAllocateDescriptorSets_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkAllocateDescriptorSets_StopIgnore() vkAllocateDescriptorSets_CMockStopIgnore() +void vkAllocateDescriptorSets_CMockStopIgnore(void); +#define vkAllocateDescriptorSets_ExpectAnyArgsAndReturn(cmock_retval) vkAllocateDescriptorSets_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkAllocateDescriptorSets_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkAllocateDescriptorSets_ExpectAndReturn(device, pAllocateInfo, pDescriptorSets, cmock_retval) vkAllocateDescriptorSets_CMockExpectAndReturn(__LINE__, device, pAllocateInfo, pDescriptorSets, cmock_retval) +void vkAllocateDescriptorSets_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkAllocateDescriptorSets_CALLBACK)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets, int cmock_num_calls); +void vkAllocateDescriptorSets_AddCallback(CMOCK_vkAllocateDescriptorSets_CALLBACK Callback); +void vkAllocateDescriptorSets_Stub(CMOCK_vkAllocateDescriptorSets_CALLBACK Callback); +#define vkAllocateDescriptorSets_StubWithCallback vkAllocateDescriptorSets_AddCallback +#define vkAllocateDescriptorSets_ReturnThruPtr_pDescriptorSets(pDescriptorSets) vkAllocateDescriptorSets_CMockReturnMemThruPtr_pDescriptorSets(__LINE__, pDescriptorSets, sizeof(VkDescriptorSet)) +#define vkAllocateDescriptorSets_ReturnArrayThruPtr_pDescriptorSets(pDescriptorSets, cmock_len) vkAllocateDescriptorSets_CMockReturnMemThruPtr_pDescriptorSets(__LINE__, pDescriptorSets, cmock_len * sizeof(*pDescriptorSets)) +#define vkAllocateDescriptorSets_ReturnMemThruPtr_pDescriptorSets(pDescriptorSets, cmock_size) vkAllocateDescriptorSets_CMockReturnMemThruPtr_pDescriptorSets(__LINE__, pDescriptorSets, cmock_size) +void vkAllocateDescriptorSets_CMockReturnMemThruPtr_pDescriptorSets(UNITY_LINE_TYPE cmock_line, VkDescriptorSet const* pDescriptorSets, size_t cmock_size); +#define vkAllocateDescriptorSets_IgnoreArg_device() vkAllocateDescriptorSets_CMockIgnoreArg_device(__LINE__) +void vkAllocateDescriptorSets_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkAllocateDescriptorSets_IgnoreArg_pAllocateInfo() vkAllocateDescriptorSets_CMockIgnoreArg_pAllocateInfo(__LINE__) +void vkAllocateDescriptorSets_CMockIgnoreArg_pAllocateInfo(UNITY_LINE_TYPE cmock_line); +#define vkAllocateDescriptorSets_IgnoreArg_pDescriptorSets() vkAllocateDescriptorSets_CMockIgnoreArg_pDescriptorSets(__LINE__) +void vkAllocateDescriptorSets_CMockIgnoreArg_pDescriptorSets(UNITY_LINE_TYPE cmock_line); +#define vkFreeDescriptorSets_IgnoreAndReturn(cmock_retval) vkFreeDescriptorSets_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkFreeDescriptorSets_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkFreeDescriptorSets_StopIgnore() vkFreeDescriptorSets_CMockStopIgnore() +void vkFreeDescriptorSets_CMockStopIgnore(void); +#define vkFreeDescriptorSets_ExpectAnyArgsAndReturn(cmock_retval) vkFreeDescriptorSets_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkFreeDescriptorSets_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkFreeDescriptorSets_ExpectAndReturn(device, descriptorPool, descriptorSetCount, pDescriptorSets, cmock_retval) vkFreeDescriptorSets_CMockExpectAndReturn(__LINE__, device, descriptorPool, descriptorSetCount, pDescriptorSets, cmock_retval) +void vkFreeDescriptorSets_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkFreeDescriptorSets_CALLBACK)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, int cmock_num_calls); +void vkFreeDescriptorSets_AddCallback(CMOCK_vkFreeDescriptorSets_CALLBACK Callback); +void vkFreeDescriptorSets_Stub(CMOCK_vkFreeDescriptorSets_CALLBACK Callback); +#define vkFreeDescriptorSets_StubWithCallback vkFreeDescriptorSets_AddCallback +#define vkFreeDescriptorSets_IgnoreArg_device() vkFreeDescriptorSets_CMockIgnoreArg_device(__LINE__) +void vkFreeDescriptorSets_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkFreeDescriptorSets_IgnoreArg_descriptorPool() vkFreeDescriptorSets_CMockIgnoreArg_descriptorPool(__LINE__) +void vkFreeDescriptorSets_CMockIgnoreArg_descriptorPool(UNITY_LINE_TYPE cmock_line); +#define vkFreeDescriptorSets_IgnoreArg_descriptorSetCount() vkFreeDescriptorSets_CMockIgnoreArg_descriptorSetCount(__LINE__) +void vkFreeDescriptorSets_CMockIgnoreArg_descriptorSetCount(UNITY_LINE_TYPE cmock_line); +#define vkFreeDescriptorSets_IgnoreArg_pDescriptorSets() vkFreeDescriptorSets_CMockIgnoreArg_pDescriptorSets(__LINE__) +void vkFreeDescriptorSets_CMockIgnoreArg_pDescriptorSets(UNITY_LINE_TYPE cmock_line); +#define vkUpdateDescriptorSets_Ignore() vkUpdateDescriptorSets_CMockIgnore() +void vkUpdateDescriptorSets_CMockIgnore(void); +#define vkUpdateDescriptorSets_StopIgnore() vkUpdateDescriptorSets_CMockStopIgnore() +void vkUpdateDescriptorSets_CMockStopIgnore(void); +#define vkUpdateDescriptorSets_ExpectAnyArgs() vkUpdateDescriptorSets_CMockExpectAnyArgs(__LINE__) +void vkUpdateDescriptorSets_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkUpdateDescriptorSets_Expect(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies) vkUpdateDescriptorSets_CMockExpect(__LINE__, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies) +void vkUpdateDescriptorSets_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies); +typedef void (* CMOCK_vkUpdateDescriptorSets_CALLBACK)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies, int cmock_num_calls); +void vkUpdateDescriptorSets_AddCallback(CMOCK_vkUpdateDescriptorSets_CALLBACK Callback); +void vkUpdateDescriptorSets_Stub(CMOCK_vkUpdateDescriptorSets_CALLBACK Callback); +#define vkUpdateDescriptorSets_StubWithCallback vkUpdateDescriptorSets_AddCallback +#define vkUpdateDescriptorSets_IgnoreArg_device() vkUpdateDescriptorSets_CMockIgnoreArg_device(__LINE__) +void vkUpdateDescriptorSets_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkUpdateDescriptorSets_IgnoreArg_descriptorWriteCount() vkUpdateDescriptorSets_CMockIgnoreArg_descriptorWriteCount(__LINE__) +void vkUpdateDescriptorSets_CMockIgnoreArg_descriptorWriteCount(UNITY_LINE_TYPE cmock_line); +#define vkUpdateDescriptorSets_IgnoreArg_pDescriptorWrites() vkUpdateDescriptorSets_CMockIgnoreArg_pDescriptorWrites(__LINE__) +void vkUpdateDescriptorSets_CMockIgnoreArg_pDescriptorWrites(UNITY_LINE_TYPE cmock_line); +#define vkUpdateDescriptorSets_IgnoreArg_descriptorCopyCount() vkUpdateDescriptorSets_CMockIgnoreArg_descriptorCopyCount(__LINE__) +void vkUpdateDescriptorSets_CMockIgnoreArg_descriptorCopyCount(UNITY_LINE_TYPE cmock_line); +#define vkUpdateDescriptorSets_IgnoreArg_pDescriptorCopies() vkUpdateDescriptorSets_CMockIgnoreArg_pDescriptorCopies(__LINE__) +void vkUpdateDescriptorSets_CMockIgnoreArg_pDescriptorCopies(UNITY_LINE_TYPE cmock_line); +#define vkCreateFramebuffer_IgnoreAndReturn(cmock_retval) vkCreateFramebuffer_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateFramebuffer_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateFramebuffer_StopIgnore() vkCreateFramebuffer_CMockStopIgnore() +void vkCreateFramebuffer_CMockStopIgnore(void); +#define vkCreateFramebuffer_ExpectAnyArgsAndReturn(cmock_retval) vkCreateFramebuffer_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateFramebuffer_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateFramebuffer_ExpectAndReturn(device, pCreateInfo, pAllocator, pFramebuffer, cmock_retval) vkCreateFramebuffer_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pFramebuffer, cmock_retval) +void vkCreateFramebuffer_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateFramebuffer_CALLBACK)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer, int cmock_num_calls); +void vkCreateFramebuffer_AddCallback(CMOCK_vkCreateFramebuffer_CALLBACK Callback); +void vkCreateFramebuffer_Stub(CMOCK_vkCreateFramebuffer_CALLBACK Callback); +#define vkCreateFramebuffer_StubWithCallback vkCreateFramebuffer_AddCallback +#define vkCreateFramebuffer_ReturnThruPtr_pFramebuffer(pFramebuffer) vkCreateFramebuffer_CMockReturnMemThruPtr_pFramebuffer(__LINE__, pFramebuffer, sizeof(VkFramebuffer)) +#define vkCreateFramebuffer_ReturnArrayThruPtr_pFramebuffer(pFramebuffer, cmock_len) vkCreateFramebuffer_CMockReturnMemThruPtr_pFramebuffer(__LINE__, pFramebuffer, cmock_len * sizeof(*pFramebuffer)) +#define vkCreateFramebuffer_ReturnMemThruPtr_pFramebuffer(pFramebuffer, cmock_size) vkCreateFramebuffer_CMockReturnMemThruPtr_pFramebuffer(__LINE__, pFramebuffer, cmock_size) +void vkCreateFramebuffer_CMockReturnMemThruPtr_pFramebuffer(UNITY_LINE_TYPE cmock_line, VkFramebuffer const* pFramebuffer, size_t cmock_size); +#define vkCreateFramebuffer_IgnoreArg_device() vkCreateFramebuffer_CMockIgnoreArg_device(__LINE__) +void vkCreateFramebuffer_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateFramebuffer_IgnoreArg_pCreateInfo() vkCreateFramebuffer_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateFramebuffer_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateFramebuffer_IgnoreArg_pAllocator() vkCreateFramebuffer_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateFramebuffer_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateFramebuffer_IgnoreArg_pFramebuffer() vkCreateFramebuffer_CMockIgnoreArg_pFramebuffer(__LINE__) +void vkCreateFramebuffer_CMockIgnoreArg_pFramebuffer(UNITY_LINE_TYPE cmock_line); +#define vkDestroyFramebuffer_Ignore() vkDestroyFramebuffer_CMockIgnore() +void vkDestroyFramebuffer_CMockIgnore(void); +#define vkDestroyFramebuffer_StopIgnore() vkDestroyFramebuffer_CMockStopIgnore() +void vkDestroyFramebuffer_CMockStopIgnore(void); +#define vkDestroyFramebuffer_ExpectAnyArgs() vkDestroyFramebuffer_CMockExpectAnyArgs(__LINE__) +void vkDestroyFramebuffer_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyFramebuffer_Expect(device, framebuffer, pAllocator) vkDestroyFramebuffer_CMockExpect(__LINE__, device, framebuffer, pAllocator) +void vkDestroyFramebuffer_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyFramebuffer_CALLBACK)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyFramebuffer_AddCallback(CMOCK_vkDestroyFramebuffer_CALLBACK Callback); +void vkDestroyFramebuffer_Stub(CMOCK_vkDestroyFramebuffer_CALLBACK Callback); +#define vkDestroyFramebuffer_StubWithCallback vkDestroyFramebuffer_AddCallback +#define vkDestroyFramebuffer_IgnoreArg_device() vkDestroyFramebuffer_CMockIgnoreArg_device(__LINE__) +void vkDestroyFramebuffer_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyFramebuffer_IgnoreArg_framebuffer() vkDestroyFramebuffer_CMockIgnoreArg_framebuffer(__LINE__) +void vkDestroyFramebuffer_CMockIgnoreArg_framebuffer(UNITY_LINE_TYPE cmock_line); +#define vkDestroyFramebuffer_IgnoreArg_pAllocator() vkDestroyFramebuffer_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyFramebuffer_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateRenderPass_IgnoreAndReturn(cmock_retval) vkCreateRenderPass_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateRenderPass_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateRenderPass_StopIgnore() vkCreateRenderPass_CMockStopIgnore() +void vkCreateRenderPass_CMockStopIgnore(void); +#define vkCreateRenderPass_ExpectAnyArgsAndReturn(cmock_retval) vkCreateRenderPass_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateRenderPass_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateRenderPass_ExpectAndReturn(device, pCreateInfo, pAllocator, pRenderPass, cmock_retval) vkCreateRenderPass_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pRenderPass, cmock_retval) +void vkCreateRenderPass_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateRenderPass_CALLBACK)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, int cmock_num_calls); +void vkCreateRenderPass_AddCallback(CMOCK_vkCreateRenderPass_CALLBACK Callback); +void vkCreateRenderPass_Stub(CMOCK_vkCreateRenderPass_CALLBACK Callback); +#define vkCreateRenderPass_StubWithCallback vkCreateRenderPass_AddCallback +#define vkCreateRenderPass_ReturnThruPtr_pRenderPass(pRenderPass) vkCreateRenderPass_CMockReturnMemThruPtr_pRenderPass(__LINE__, pRenderPass, sizeof(VkRenderPass)) +#define vkCreateRenderPass_ReturnArrayThruPtr_pRenderPass(pRenderPass, cmock_len) vkCreateRenderPass_CMockReturnMemThruPtr_pRenderPass(__LINE__, pRenderPass, cmock_len * sizeof(*pRenderPass)) +#define vkCreateRenderPass_ReturnMemThruPtr_pRenderPass(pRenderPass, cmock_size) vkCreateRenderPass_CMockReturnMemThruPtr_pRenderPass(__LINE__, pRenderPass, cmock_size) +void vkCreateRenderPass_CMockReturnMemThruPtr_pRenderPass(UNITY_LINE_TYPE cmock_line, VkRenderPass const* pRenderPass, size_t cmock_size); +#define vkCreateRenderPass_IgnoreArg_device() vkCreateRenderPass_CMockIgnoreArg_device(__LINE__) +void vkCreateRenderPass_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateRenderPass_IgnoreArg_pCreateInfo() vkCreateRenderPass_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateRenderPass_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateRenderPass_IgnoreArg_pAllocator() vkCreateRenderPass_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateRenderPass_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateRenderPass_IgnoreArg_pRenderPass() vkCreateRenderPass_CMockIgnoreArg_pRenderPass(__LINE__) +void vkCreateRenderPass_CMockIgnoreArg_pRenderPass(UNITY_LINE_TYPE cmock_line); +#define vkDestroyRenderPass_Ignore() vkDestroyRenderPass_CMockIgnore() +void vkDestroyRenderPass_CMockIgnore(void); +#define vkDestroyRenderPass_StopIgnore() vkDestroyRenderPass_CMockStopIgnore() +void vkDestroyRenderPass_CMockStopIgnore(void); +#define vkDestroyRenderPass_ExpectAnyArgs() vkDestroyRenderPass_CMockExpectAnyArgs(__LINE__) +void vkDestroyRenderPass_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyRenderPass_Expect(device, renderPass, pAllocator) vkDestroyRenderPass_CMockExpect(__LINE__, device, renderPass, pAllocator) +void vkDestroyRenderPass_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyRenderPass_CALLBACK)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyRenderPass_AddCallback(CMOCK_vkDestroyRenderPass_CALLBACK Callback); +void vkDestroyRenderPass_Stub(CMOCK_vkDestroyRenderPass_CALLBACK Callback); +#define vkDestroyRenderPass_StubWithCallback vkDestroyRenderPass_AddCallback +#define vkDestroyRenderPass_IgnoreArg_device() vkDestroyRenderPass_CMockIgnoreArg_device(__LINE__) +void vkDestroyRenderPass_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyRenderPass_IgnoreArg_renderPass() vkDestroyRenderPass_CMockIgnoreArg_renderPass(__LINE__) +void vkDestroyRenderPass_CMockIgnoreArg_renderPass(UNITY_LINE_TYPE cmock_line); +#define vkDestroyRenderPass_IgnoreArg_pAllocator() vkDestroyRenderPass_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyRenderPass_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkGetRenderAreaGranularity_Ignore() vkGetRenderAreaGranularity_CMockIgnore() +void vkGetRenderAreaGranularity_CMockIgnore(void); +#define vkGetRenderAreaGranularity_StopIgnore() vkGetRenderAreaGranularity_CMockStopIgnore() +void vkGetRenderAreaGranularity_CMockStopIgnore(void); +#define vkGetRenderAreaGranularity_ExpectAnyArgs() vkGetRenderAreaGranularity_CMockExpectAnyArgs(__LINE__) +void vkGetRenderAreaGranularity_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetRenderAreaGranularity_Expect(device, renderPass, pGranularity) vkGetRenderAreaGranularity_CMockExpect(__LINE__, device, renderPass, pGranularity) +void vkGetRenderAreaGranularity_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); +typedef void (* CMOCK_vkGetRenderAreaGranularity_CALLBACK)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity, int cmock_num_calls); +void vkGetRenderAreaGranularity_AddCallback(CMOCK_vkGetRenderAreaGranularity_CALLBACK Callback); +void vkGetRenderAreaGranularity_Stub(CMOCK_vkGetRenderAreaGranularity_CALLBACK Callback); +#define vkGetRenderAreaGranularity_StubWithCallback vkGetRenderAreaGranularity_AddCallback +#define vkGetRenderAreaGranularity_ReturnThruPtr_pGranularity(pGranularity) vkGetRenderAreaGranularity_CMockReturnMemThruPtr_pGranularity(__LINE__, pGranularity, sizeof(VkExtent2D)) +#define vkGetRenderAreaGranularity_ReturnArrayThruPtr_pGranularity(pGranularity, cmock_len) vkGetRenderAreaGranularity_CMockReturnMemThruPtr_pGranularity(__LINE__, pGranularity, cmock_len * sizeof(*pGranularity)) +#define vkGetRenderAreaGranularity_ReturnMemThruPtr_pGranularity(pGranularity, cmock_size) vkGetRenderAreaGranularity_CMockReturnMemThruPtr_pGranularity(__LINE__, pGranularity, cmock_size) +void vkGetRenderAreaGranularity_CMockReturnMemThruPtr_pGranularity(UNITY_LINE_TYPE cmock_line, VkExtent2D const* pGranularity, size_t cmock_size); +#define vkGetRenderAreaGranularity_IgnoreArg_device() vkGetRenderAreaGranularity_CMockIgnoreArg_device(__LINE__) +void vkGetRenderAreaGranularity_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetRenderAreaGranularity_IgnoreArg_renderPass() vkGetRenderAreaGranularity_CMockIgnoreArg_renderPass(__LINE__) +void vkGetRenderAreaGranularity_CMockIgnoreArg_renderPass(UNITY_LINE_TYPE cmock_line); +#define vkGetRenderAreaGranularity_IgnoreArg_pGranularity() vkGetRenderAreaGranularity_CMockIgnoreArg_pGranularity(__LINE__) +void vkGetRenderAreaGranularity_CMockIgnoreArg_pGranularity(UNITY_LINE_TYPE cmock_line); +#define vkCreateCommandPool_IgnoreAndReturn(cmock_retval) vkCreateCommandPool_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateCommandPool_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateCommandPool_StopIgnore() vkCreateCommandPool_CMockStopIgnore() +void vkCreateCommandPool_CMockStopIgnore(void); +#define vkCreateCommandPool_ExpectAnyArgsAndReturn(cmock_retval) vkCreateCommandPool_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateCommandPool_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateCommandPool_ExpectAndReturn(device, pCreateInfo, pAllocator, pCommandPool, cmock_retval) vkCreateCommandPool_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pCommandPool, cmock_retval) +void vkCreateCommandPool_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateCommandPool_CALLBACK)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool, int cmock_num_calls); +void vkCreateCommandPool_AddCallback(CMOCK_vkCreateCommandPool_CALLBACK Callback); +void vkCreateCommandPool_Stub(CMOCK_vkCreateCommandPool_CALLBACK Callback); +#define vkCreateCommandPool_StubWithCallback vkCreateCommandPool_AddCallback +#define vkCreateCommandPool_ReturnThruPtr_pCommandPool(pCommandPool) vkCreateCommandPool_CMockReturnMemThruPtr_pCommandPool(__LINE__, pCommandPool, sizeof(VkCommandPool)) +#define vkCreateCommandPool_ReturnArrayThruPtr_pCommandPool(pCommandPool, cmock_len) vkCreateCommandPool_CMockReturnMemThruPtr_pCommandPool(__LINE__, pCommandPool, cmock_len * sizeof(*pCommandPool)) +#define vkCreateCommandPool_ReturnMemThruPtr_pCommandPool(pCommandPool, cmock_size) vkCreateCommandPool_CMockReturnMemThruPtr_pCommandPool(__LINE__, pCommandPool, cmock_size) +void vkCreateCommandPool_CMockReturnMemThruPtr_pCommandPool(UNITY_LINE_TYPE cmock_line, VkCommandPool const* pCommandPool, size_t cmock_size); +#define vkCreateCommandPool_IgnoreArg_device() vkCreateCommandPool_CMockIgnoreArg_device(__LINE__) +void vkCreateCommandPool_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateCommandPool_IgnoreArg_pCreateInfo() vkCreateCommandPool_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateCommandPool_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateCommandPool_IgnoreArg_pAllocator() vkCreateCommandPool_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateCommandPool_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateCommandPool_IgnoreArg_pCommandPool() vkCreateCommandPool_CMockIgnoreArg_pCommandPool(__LINE__) +void vkCreateCommandPool_CMockIgnoreArg_pCommandPool(UNITY_LINE_TYPE cmock_line); +#define vkDestroyCommandPool_Ignore() vkDestroyCommandPool_CMockIgnore() +void vkDestroyCommandPool_CMockIgnore(void); +#define vkDestroyCommandPool_StopIgnore() vkDestroyCommandPool_CMockStopIgnore() +void vkDestroyCommandPool_CMockStopIgnore(void); +#define vkDestroyCommandPool_ExpectAnyArgs() vkDestroyCommandPool_CMockExpectAnyArgs(__LINE__) +void vkDestroyCommandPool_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyCommandPool_Expect(device, commandPool, pAllocator) vkDestroyCommandPool_CMockExpect(__LINE__, device, commandPool, pAllocator) +void vkDestroyCommandPool_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyCommandPool_CALLBACK)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyCommandPool_AddCallback(CMOCK_vkDestroyCommandPool_CALLBACK Callback); +void vkDestroyCommandPool_Stub(CMOCK_vkDestroyCommandPool_CALLBACK Callback); +#define vkDestroyCommandPool_StubWithCallback vkDestroyCommandPool_AddCallback +#define vkDestroyCommandPool_IgnoreArg_device() vkDestroyCommandPool_CMockIgnoreArg_device(__LINE__) +void vkDestroyCommandPool_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyCommandPool_IgnoreArg_commandPool() vkDestroyCommandPool_CMockIgnoreArg_commandPool(__LINE__) +void vkDestroyCommandPool_CMockIgnoreArg_commandPool(UNITY_LINE_TYPE cmock_line); +#define vkDestroyCommandPool_IgnoreArg_pAllocator() vkDestroyCommandPool_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyCommandPool_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkResetCommandPool_IgnoreAndReturn(cmock_retval) vkResetCommandPool_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkResetCommandPool_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkResetCommandPool_StopIgnore() vkResetCommandPool_CMockStopIgnore() +void vkResetCommandPool_CMockStopIgnore(void); +#define vkResetCommandPool_ExpectAnyArgsAndReturn(cmock_retval) vkResetCommandPool_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkResetCommandPool_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkResetCommandPool_ExpectAndReturn(device, commandPool, flags, cmock_retval) vkResetCommandPool_CMockExpectAndReturn(__LINE__, device, commandPool, flags, cmock_retval) +void vkResetCommandPool_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkResetCommandPool_CALLBACK)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags, int cmock_num_calls); +void vkResetCommandPool_AddCallback(CMOCK_vkResetCommandPool_CALLBACK Callback); +void vkResetCommandPool_Stub(CMOCK_vkResetCommandPool_CALLBACK Callback); +#define vkResetCommandPool_StubWithCallback vkResetCommandPool_AddCallback +#define vkResetCommandPool_IgnoreArg_device() vkResetCommandPool_CMockIgnoreArg_device(__LINE__) +void vkResetCommandPool_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkResetCommandPool_IgnoreArg_commandPool() vkResetCommandPool_CMockIgnoreArg_commandPool(__LINE__) +void vkResetCommandPool_CMockIgnoreArg_commandPool(UNITY_LINE_TYPE cmock_line); +#define vkResetCommandPool_IgnoreArg_flags() vkResetCommandPool_CMockIgnoreArg_flags(__LINE__) +void vkResetCommandPool_CMockIgnoreArg_flags(UNITY_LINE_TYPE cmock_line); +#define vkAllocateCommandBuffers_IgnoreAndReturn(cmock_retval) vkAllocateCommandBuffers_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkAllocateCommandBuffers_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkAllocateCommandBuffers_StopIgnore() vkAllocateCommandBuffers_CMockStopIgnore() +void vkAllocateCommandBuffers_CMockStopIgnore(void); +#define vkAllocateCommandBuffers_ExpectAnyArgsAndReturn(cmock_retval) vkAllocateCommandBuffers_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkAllocateCommandBuffers_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkAllocateCommandBuffers_ExpectAndReturn(device, pAllocateInfo, pCommandBuffers, cmock_retval) vkAllocateCommandBuffers_CMockExpectAndReturn(__LINE__, device, pAllocateInfo, pCommandBuffers, cmock_retval) +void vkAllocateCommandBuffers_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkAllocateCommandBuffers_CALLBACK)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers, int cmock_num_calls); +void vkAllocateCommandBuffers_AddCallback(CMOCK_vkAllocateCommandBuffers_CALLBACK Callback); +void vkAllocateCommandBuffers_Stub(CMOCK_vkAllocateCommandBuffers_CALLBACK Callback); +#define vkAllocateCommandBuffers_StubWithCallback vkAllocateCommandBuffers_AddCallback +#define vkAllocateCommandBuffers_ReturnThruPtr_pCommandBuffers(pCommandBuffers) vkAllocateCommandBuffers_CMockReturnMemThruPtr_pCommandBuffers(__LINE__, pCommandBuffers, sizeof(VkCommandBuffer)) +#define vkAllocateCommandBuffers_ReturnArrayThruPtr_pCommandBuffers(pCommandBuffers, cmock_len) vkAllocateCommandBuffers_CMockReturnMemThruPtr_pCommandBuffers(__LINE__, pCommandBuffers, cmock_len * sizeof(*pCommandBuffers)) +#define vkAllocateCommandBuffers_ReturnMemThruPtr_pCommandBuffers(pCommandBuffers, cmock_size) vkAllocateCommandBuffers_CMockReturnMemThruPtr_pCommandBuffers(__LINE__, pCommandBuffers, cmock_size) +void vkAllocateCommandBuffers_CMockReturnMemThruPtr_pCommandBuffers(UNITY_LINE_TYPE cmock_line, VkCommandBuffer const* pCommandBuffers, size_t cmock_size); +#define vkAllocateCommandBuffers_IgnoreArg_device() vkAllocateCommandBuffers_CMockIgnoreArg_device(__LINE__) +void vkAllocateCommandBuffers_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkAllocateCommandBuffers_IgnoreArg_pAllocateInfo() vkAllocateCommandBuffers_CMockIgnoreArg_pAllocateInfo(__LINE__) +void vkAllocateCommandBuffers_CMockIgnoreArg_pAllocateInfo(UNITY_LINE_TYPE cmock_line); +#define vkAllocateCommandBuffers_IgnoreArg_pCommandBuffers() vkAllocateCommandBuffers_CMockIgnoreArg_pCommandBuffers(__LINE__) +void vkAllocateCommandBuffers_CMockIgnoreArg_pCommandBuffers(UNITY_LINE_TYPE cmock_line); +#define vkFreeCommandBuffers_Ignore() vkFreeCommandBuffers_CMockIgnore() +void vkFreeCommandBuffers_CMockIgnore(void); +#define vkFreeCommandBuffers_StopIgnore() vkFreeCommandBuffers_CMockStopIgnore() +void vkFreeCommandBuffers_CMockStopIgnore(void); +#define vkFreeCommandBuffers_ExpectAnyArgs() vkFreeCommandBuffers_CMockExpectAnyArgs(__LINE__) +void vkFreeCommandBuffers_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkFreeCommandBuffers_Expect(device, commandPool, commandBufferCount, pCommandBuffers) vkFreeCommandBuffers_CMockExpect(__LINE__, device, commandPool, commandBufferCount, pCommandBuffers) +void vkFreeCommandBuffers_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); +typedef void (* CMOCK_vkFreeCommandBuffers_CALLBACK)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers, int cmock_num_calls); +void vkFreeCommandBuffers_AddCallback(CMOCK_vkFreeCommandBuffers_CALLBACK Callback); +void vkFreeCommandBuffers_Stub(CMOCK_vkFreeCommandBuffers_CALLBACK Callback); +#define vkFreeCommandBuffers_StubWithCallback vkFreeCommandBuffers_AddCallback +#define vkFreeCommandBuffers_IgnoreArg_device() vkFreeCommandBuffers_CMockIgnoreArg_device(__LINE__) +void vkFreeCommandBuffers_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkFreeCommandBuffers_IgnoreArg_commandPool() vkFreeCommandBuffers_CMockIgnoreArg_commandPool(__LINE__) +void vkFreeCommandBuffers_CMockIgnoreArg_commandPool(UNITY_LINE_TYPE cmock_line); +#define vkFreeCommandBuffers_IgnoreArg_commandBufferCount() vkFreeCommandBuffers_CMockIgnoreArg_commandBufferCount(__LINE__) +void vkFreeCommandBuffers_CMockIgnoreArg_commandBufferCount(UNITY_LINE_TYPE cmock_line); +#define vkFreeCommandBuffers_IgnoreArg_pCommandBuffers() vkFreeCommandBuffers_CMockIgnoreArg_pCommandBuffers(__LINE__) +void vkFreeCommandBuffers_CMockIgnoreArg_pCommandBuffers(UNITY_LINE_TYPE cmock_line); +#define vkBeginCommandBuffer_IgnoreAndReturn(cmock_retval) vkBeginCommandBuffer_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkBeginCommandBuffer_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkBeginCommandBuffer_StopIgnore() vkBeginCommandBuffer_CMockStopIgnore() +void vkBeginCommandBuffer_CMockStopIgnore(void); +#define vkBeginCommandBuffer_ExpectAnyArgsAndReturn(cmock_retval) vkBeginCommandBuffer_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkBeginCommandBuffer_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkBeginCommandBuffer_ExpectAndReturn(commandBuffer, pBeginInfo, cmock_retval) vkBeginCommandBuffer_CMockExpectAndReturn(__LINE__, commandBuffer, pBeginInfo, cmock_retval) +void vkBeginCommandBuffer_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkBeginCommandBuffer_CALLBACK)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo, int cmock_num_calls); +void vkBeginCommandBuffer_AddCallback(CMOCK_vkBeginCommandBuffer_CALLBACK Callback); +void vkBeginCommandBuffer_Stub(CMOCK_vkBeginCommandBuffer_CALLBACK Callback); +#define vkBeginCommandBuffer_StubWithCallback vkBeginCommandBuffer_AddCallback +#define vkBeginCommandBuffer_IgnoreArg_commandBuffer() vkBeginCommandBuffer_CMockIgnoreArg_commandBuffer(__LINE__) +void vkBeginCommandBuffer_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkBeginCommandBuffer_IgnoreArg_pBeginInfo() vkBeginCommandBuffer_CMockIgnoreArg_pBeginInfo(__LINE__) +void vkBeginCommandBuffer_CMockIgnoreArg_pBeginInfo(UNITY_LINE_TYPE cmock_line); +#define vkEndCommandBuffer_IgnoreAndReturn(cmock_retval) vkEndCommandBuffer_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkEndCommandBuffer_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkEndCommandBuffer_StopIgnore() vkEndCommandBuffer_CMockStopIgnore() +void vkEndCommandBuffer_CMockStopIgnore(void); +#define vkEndCommandBuffer_ExpectAnyArgsAndReturn(cmock_retval) vkEndCommandBuffer_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkEndCommandBuffer_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkEndCommandBuffer_ExpectAndReturn(commandBuffer, cmock_retval) vkEndCommandBuffer_CMockExpectAndReturn(__LINE__, commandBuffer, cmock_retval) +void vkEndCommandBuffer_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkEndCommandBuffer_CALLBACK)(VkCommandBuffer commandBuffer, int cmock_num_calls); +void vkEndCommandBuffer_AddCallback(CMOCK_vkEndCommandBuffer_CALLBACK Callback); +void vkEndCommandBuffer_Stub(CMOCK_vkEndCommandBuffer_CALLBACK Callback); +#define vkEndCommandBuffer_StubWithCallback vkEndCommandBuffer_AddCallback +#define vkEndCommandBuffer_IgnoreArg_commandBuffer() vkEndCommandBuffer_CMockIgnoreArg_commandBuffer(__LINE__) +void vkEndCommandBuffer_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkResetCommandBuffer_IgnoreAndReturn(cmock_retval) vkResetCommandBuffer_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkResetCommandBuffer_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkResetCommandBuffer_StopIgnore() vkResetCommandBuffer_CMockStopIgnore() +void vkResetCommandBuffer_CMockStopIgnore(void); +#define vkResetCommandBuffer_ExpectAnyArgsAndReturn(cmock_retval) vkResetCommandBuffer_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkResetCommandBuffer_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkResetCommandBuffer_ExpectAndReturn(commandBuffer, flags, cmock_retval) vkResetCommandBuffer_CMockExpectAndReturn(__LINE__, commandBuffer, flags, cmock_retval) +void vkResetCommandBuffer_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkResetCommandBuffer_CALLBACK)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags, int cmock_num_calls); +void vkResetCommandBuffer_AddCallback(CMOCK_vkResetCommandBuffer_CALLBACK Callback); +void vkResetCommandBuffer_Stub(CMOCK_vkResetCommandBuffer_CALLBACK Callback); +#define vkResetCommandBuffer_StubWithCallback vkResetCommandBuffer_AddCallback +#define vkResetCommandBuffer_IgnoreArg_commandBuffer() vkResetCommandBuffer_CMockIgnoreArg_commandBuffer(__LINE__) +void vkResetCommandBuffer_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkResetCommandBuffer_IgnoreArg_flags() vkResetCommandBuffer_CMockIgnoreArg_flags(__LINE__) +void vkResetCommandBuffer_CMockIgnoreArg_flags(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindPipeline_Ignore() vkCmdBindPipeline_CMockIgnore() +void vkCmdBindPipeline_CMockIgnore(void); +#define vkCmdBindPipeline_StopIgnore() vkCmdBindPipeline_CMockStopIgnore() +void vkCmdBindPipeline_CMockStopIgnore(void); +#define vkCmdBindPipeline_ExpectAnyArgs() vkCmdBindPipeline_CMockExpectAnyArgs(__LINE__) +void vkCmdBindPipeline_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindPipeline_Expect(commandBuffer, pipelineBindPoint, pipeline) vkCmdBindPipeline_CMockExpect(__LINE__, commandBuffer, pipelineBindPoint, pipeline) +void vkCmdBindPipeline_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); +typedef void (* CMOCK_vkCmdBindPipeline_CALLBACK)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, int cmock_num_calls); +void vkCmdBindPipeline_AddCallback(CMOCK_vkCmdBindPipeline_CALLBACK Callback); +void vkCmdBindPipeline_Stub(CMOCK_vkCmdBindPipeline_CALLBACK Callback); +#define vkCmdBindPipeline_StubWithCallback vkCmdBindPipeline_AddCallback +#define vkCmdBindPipeline_IgnoreArg_commandBuffer() vkCmdBindPipeline_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBindPipeline_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindPipeline_IgnoreArg_pipelineBindPoint() vkCmdBindPipeline_CMockIgnoreArg_pipelineBindPoint(__LINE__) +void vkCmdBindPipeline_CMockIgnoreArg_pipelineBindPoint(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindPipeline_IgnoreArg_pipeline() vkCmdBindPipeline_CMockIgnoreArg_pipeline(__LINE__) +void vkCmdBindPipeline_CMockIgnoreArg_pipeline(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewport_Ignore() vkCmdSetViewport_CMockIgnore() +void vkCmdSetViewport_CMockIgnore(void); +#define vkCmdSetViewport_StopIgnore() vkCmdSetViewport_CMockStopIgnore() +void vkCmdSetViewport_CMockStopIgnore(void); +#define vkCmdSetViewport_ExpectAnyArgs() vkCmdSetViewport_CMockExpectAnyArgs(__LINE__) +void vkCmdSetViewport_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewport_Expect(commandBuffer, firstViewport, viewportCount, pViewports) vkCmdSetViewport_CMockExpect(__LINE__, commandBuffer, firstViewport, viewportCount, pViewports) +void vkCmdSetViewport_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports); +typedef void (* CMOCK_vkCmdSetViewport_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports, int cmock_num_calls); +void vkCmdSetViewport_AddCallback(CMOCK_vkCmdSetViewport_CALLBACK Callback); +void vkCmdSetViewport_Stub(CMOCK_vkCmdSetViewport_CALLBACK Callback); +#define vkCmdSetViewport_StubWithCallback vkCmdSetViewport_AddCallback +#define vkCmdSetViewport_IgnoreArg_commandBuffer() vkCmdSetViewport_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetViewport_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewport_IgnoreArg_firstViewport() vkCmdSetViewport_CMockIgnoreArg_firstViewport(__LINE__) +void vkCmdSetViewport_CMockIgnoreArg_firstViewport(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewport_IgnoreArg_viewportCount() vkCmdSetViewport_CMockIgnoreArg_viewportCount(__LINE__) +void vkCmdSetViewport_CMockIgnoreArg_viewportCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewport_IgnoreArg_pViewports() vkCmdSetViewport_CMockIgnoreArg_pViewports(__LINE__) +void vkCmdSetViewport_CMockIgnoreArg_pViewports(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetScissor_Ignore() vkCmdSetScissor_CMockIgnore() +void vkCmdSetScissor_CMockIgnore(void); +#define vkCmdSetScissor_StopIgnore() vkCmdSetScissor_CMockStopIgnore() +void vkCmdSetScissor_CMockStopIgnore(void); +#define vkCmdSetScissor_ExpectAnyArgs() vkCmdSetScissor_CMockExpectAnyArgs(__LINE__) +void vkCmdSetScissor_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetScissor_Expect(commandBuffer, firstScissor, scissorCount, pScissors) vkCmdSetScissor_CMockExpect(__LINE__, commandBuffer, firstScissor, scissorCount, pScissors) +void vkCmdSetScissor_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors); +typedef void (* CMOCK_vkCmdSetScissor_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors, int cmock_num_calls); +void vkCmdSetScissor_AddCallback(CMOCK_vkCmdSetScissor_CALLBACK Callback); +void vkCmdSetScissor_Stub(CMOCK_vkCmdSetScissor_CALLBACK Callback); +#define vkCmdSetScissor_StubWithCallback vkCmdSetScissor_AddCallback +#define vkCmdSetScissor_IgnoreArg_commandBuffer() vkCmdSetScissor_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetScissor_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetScissor_IgnoreArg_firstScissor() vkCmdSetScissor_CMockIgnoreArg_firstScissor(__LINE__) +void vkCmdSetScissor_CMockIgnoreArg_firstScissor(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetScissor_IgnoreArg_scissorCount() vkCmdSetScissor_CMockIgnoreArg_scissorCount(__LINE__) +void vkCmdSetScissor_CMockIgnoreArg_scissorCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetScissor_IgnoreArg_pScissors() vkCmdSetScissor_CMockIgnoreArg_pScissors(__LINE__) +void vkCmdSetScissor_CMockIgnoreArg_pScissors(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetLineWidth_Ignore() vkCmdSetLineWidth_CMockIgnore() +void vkCmdSetLineWidth_CMockIgnore(void); +#define vkCmdSetLineWidth_StopIgnore() vkCmdSetLineWidth_CMockStopIgnore() +void vkCmdSetLineWidth_CMockStopIgnore(void); +#define vkCmdSetLineWidth_ExpectAnyArgs() vkCmdSetLineWidth_CMockExpectAnyArgs(__LINE__) +void vkCmdSetLineWidth_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetLineWidth_Expect(commandBuffer, lineWidth) vkCmdSetLineWidth_CMockExpect(__LINE__, commandBuffer, lineWidth) +void vkCmdSetLineWidth_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, float lineWidth); +typedef void (* CMOCK_vkCmdSetLineWidth_CALLBACK)(VkCommandBuffer commandBuffer, float lineWidth, int cmock_num_calls); +void vkCmdSetLineWidth_AddCallback(CMOCK_vkCmdSetLineWidth_CALLBACK Callback); +void vkCmdSetLineWidth_Stub(CMOCK_vkCmdSetLineWidth_CALLBACK Callback); +#define vkCmdSetLineWidth_StubWithCallback vkCmdSetLineWidth_AddCallback +#define vkCmdSetLineWidth_IgnoreArg_commandBuffer() vkCmdSetLineWidth_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetLineWidth_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetLineWidth_IgnoreArg_lineWidth() vkCmdSetLineWidth_CMockIgnoreArg_lineWidth(__LINE__) +void vkCmdSetLineWidth_CMockIgnoreArg_lineWidth(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthBias_Ignore() vkCmdSetDepthBias_CMockIgnore() +void vkCmdSetDepthBias_CMockIgnore(void); +#define vkCmdSetDepthBias_StopIgnore() vkCmdSetDepthBias_CMockStopIgnore() +void vkCmdSetDepthBias_CMockStopIgnore(void); +#define vkCmdSetDepthBias_ExpectAnyArgs() vkCmdSetDepthBias_CMockExpectAnyArgs(__LINE__) +void vkCmdSetDepthBias_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthBias_Expect(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor) vkCmdSetDepthBias_CMockExpect(__LINE__, commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor) +void vkCmdSetDepthBias_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor); +typedef void (* CMOCK_vkCmdSetDepthBias_CALLBACK)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, int cmock_num_calls); +void vkCmdSetDepthBias_AddCallback(CMOCK_vkCmdSetDepthBias_CALLBACK Callback); +void vkCmdSetDepthBias_Stub(CMOCK_vkCmdSetDepthBias_CALLBACK Callback); +#define vkCmdSetDepthBias_StubWithCallback vkCmdSetDepthBias_AddCallback +#define vkCmdSetDepthBias_IgnoreArg_commandBuffer() vkCmdSetDepthBias_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetDepthBias_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthBias_IgnoreArg_depthBiasConstantFactor() vkCmdSetDepthBias_CMockIgnoreArg_depthBiasConstantFactor(__LINE__) +void vkCmdSetDepthBias_CMockIgnoreArg_depthBiasConstantFactor(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthBias_IgnoreArg_depthBiasClamp() vkCmdSetDepthBias_CMockIgnoreArg_depthBiasClamp(__LINE__) +void vkCmdSetDepthBias_CMockIgnoreArg_depthBiasClamp(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthBias_IgnoreArg_depthBiasSlopeFactor() vkCmdSetDepthBias_CMockIgnoreArg_depthBiasSlopeFactor(__LINE__) +void vkCmdSetDepthBias_CMockIgnoreArg_depthBiasSlopeFactor(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetBlendConstants_Ignore() vkCmdSetBlendConstants_CMockIgnore() +void vkCmdSetBlendConstants_CMockIgnore(void); +#define vkCmdSetBlendConstants_StopIgnore() vkCmdSetBlendConstants_CMockStopIgnore() +void vkCmdSetBlendConstants_CMockStopIgnore(void); +#define vkCmdSetBlendConstants_ExpectAnyArgs() vkCmdSetBlendConstants_CMockExpectAnyArgs(__LINE__) +void vkCmdSetBlendConstants_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetBlendConstants_Expect(commandBuffer, blendConstants) vkCmdSetBlendConstants_CMockExpect(__LINE__, commandBuffer, blendConstants) +void vkCmdSetBlendConstants_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const float* blendConstants); +typedef void (* CMOCK_vkCmdSetBlendConstants_CALLBACK)(VkCommandBuffer commandBuffer, const float* blendConstants, int cmock_num_calls); +void vkCmdSetBlendConstants_AddCallback(CMOCK_vkCmdSetBlendConstants_CALLBACK Callback); +void vkCmdSetBlendConstants_Stub(CMOCK_vkCmdSetBlendConstants_CALLBACK Callback); +#define vkCmdSetBlendConstants_StubWithCallback vkCmdSetBlendConstants_AddCallback +#define vkCmdSetBlendConstants_IgnoreArg_commandBuffer() vkCmdSetBlendConstants_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetBlendConstants_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetBlendConstants_IgnoreArg_blendConstants() vkCmdSetBlendConstants_CMockIgnoreArg_blendConstants(__LINE__) +void vkCmdSetBlendConstants_CMockIgnoreArg_blendConstants(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthBounds_Ignore() vkCmdSetDepthBounds_CMockIgnore() +void vkCmdSetDepthBounds_CMockIgnore(void); +#define vkCmdSetDepthBounds_StopIgnore() vkCmdSetDepthBounds_CMockStopIgnore() +void vkCmdSetDepthBounds_CMockStopIgnore(void); +#define vkCmdSetDepthBounds_ExpectAnyArgs() vkCmdSetDepthBounds_CMockExpectAnyArgs(__LINE__) +void vkCmdSetDepthBounds_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthBounds_Expect(commandBuffer, minDepthBounds, maxDepthBounds) vkCmdSetDepthBounds_CMockExpect(__LINE__, commandBuffer, minDepthBounds, maxDepthBounds) +void vkCmdSetDepthBounds_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds); +typedef void (* CMOCK_vkCmdSetDepthBounds_CALLBACK)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds, int cmock_num_calls); +void vkCmdSetDepthBounds_AddCallback(CMOCK_vkCmdSetDepthBounds_CALLBACK Callback); +void vkCmdSetDepthBounds_Stub(CMOCK_vkCmdSetDepthBounds_CALLBACK Callback); +#define vkCmdSetDepthBounds_StubWithCallback vkCmdSetDepthBounds_AddCallback +#define vkCmdSetDepthBounds_IgnoreArg_commandBuffer() vkCmdSetDepthBounds_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetDepthBounds_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthBounds_IgnoreArg_minDepthBounds() vkCmdSetDepthBounds_CMockIgnoreArg_minDepthBounds(__LINE__) +void vkCmdSetDepthBounds_CMockIgnoreArg_minDepthBounds(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthBounds_IgnoreArg_maxDepthBounds() vkCmdSetDepthBounds_CMockIgnoreArg_maxDepthBounds(__LINE__) +void vkCmdSetDepthBounds_CMockIgnoreArg_maxDepthBounds(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilCompareMask_Ignore() vkCmdSetStencilCompareMask_CMockIgnore() +void vkCmdSetStencilCompareMask_CMockIgnore(void); +#define vkCmdSetStencilCompareMask_StopIgnore() vkCmdSetStencilCompareMask_CMockStopIgnore() +void vkCmdSetStencilCompareMask_CMockStopIgnore(void); +#define vkCmdSetStencilCompareMask_ExpectAnyArgs() vkCmdSetStencilCompareMask_CMockExpectAnyArgs(__LINE__) +void vkCmdSetStencilCompareMask_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilCompareMask_Expect(commandBuffer, faceMask, compareMask) vkCmdSetStencilCompareMask_CMockExpect(__LINE__, commandBuffer, faceMask, compareMask) +void vkCmdSetStencilCompareMask_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask); +typedef void (* CMOCK_vkCmdSetStencilCompareMask_CALLBACK)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask, int cmock_num_calls); +void vkCmdSetStencilCompareMask_AddCallback(CMOCK_vkCmdSetStencilCompareMask_CALLBACK Callback); +void vkCmdSetStencilCompareMask_Stub(CMOCK_vkCmdSetStencilCompareMask_CALLBACK Callback); +#define vkCmdSetStencilCompareMask_StubWithCallback vkCmdSetStencilCompareMask_AddCallback +#define vkCmdSetStencilCompareMask_IgnoreArg_commandBuffer() vkCmdSetStencilCompareMask_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetStencilCompareMask_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilCompareMask_IgnoreArg_faceMask() vkCmdSetStencilCompareMask_CMockIgnoreArg_faceMask(__LINE__) +void vkCmdSetStencilCompareMask_CMockIgnoreArg_faceMask(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilCompareMask_IgnoreArg_compareMask() vkCmdSetStencilCompareMask_CMockIgnoreArg_compareMask(__LINE__) +void vkCmdSetStencilCompareMask_CMockIgnoreArg_compareMask(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilWriteMask_Ignore() vkCmdSetStencilWriteMask_CMockIgnore() +void vkCmdSetStencilWriteMask_CMockIgnore(void); +#define vkCmdSetStencilWriteMask_StopIgnore() vkCmdSetStencilWriteMask_CMockStopIgnore() +void vkCmdSetStencilWriteMask_CMockStopIgnore(void); +#define vkCmdSetStencilWriteMask_ExpectAnyArgs() vkCmdSetStencilWriteMask_CMockExpectAnyArgs(__LINE__) +void vkCmdSetStencilWriteMask_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilWriteMask_Expect(commandBuffer, faceMask, writeMask) vkCmdSetStencilWriteMask_CMockExpect(__LINE__, commandBuffer, faceMask, writeMask) +void vkCmdSetStencilWriteMask_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask); +typedef void (* CMOCK_vkCmdSetStencilWriteMask_CALLBACK)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask, int cmock_num_calls); +void vkCmdSetStencilWriteMask_AddCallback(CMOCK_vkCmdSetStencilWriteMask_CALLBACK Callback); +void vkCmdSetStencilWriteMask_Stub(CMOCK_vkCmdSetStencilWriteMask_CALLBACK Callback); +#define vkCmdSetStencilWriteMask_StubWithCallback vkCmdSetStencilWriteMask_AddCallback +#define vkCmdSetStencilWriteMask_IgnoreArg_commandBuffer() vkCmdSetStencilWriteMask_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetStencilWriteMask_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilWriteMask_IgnoreArg_faceMask() vkCmdSetStencilWriteMask_CMockIgnoreArg_faceMask(__LINE__) +void vkCmdSetStencilWriteMask_CMockIgnoreArg_faceMask(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilWriteMask_IgnoreArg_writeMask() vkCmdSetStencilWriteMask_CMockIgnoreArg_writeMask(__LINE__) +void vkCmdSetStencilWriteMask_CMockIgnoreArg_writeMask(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilReference_Ignore() vkCmdSetStencilReference_CMockIgnore() +void vkCmdSetStencilReference_CMockIgnore(void); +#define vkCmdSetStencilReference_StopIgnore() vkCmdSetStencilReference_CMockStopIgnore() +void vkCmdSetStencilReference_CMockStopIgnore(void); +#define vkCmdSetStencilReference_ExpectAnyArgs() vkCmdSetStencilReference_CMockExpectAnyArgs(__LINE__) +void vkCmdSetStencilReference_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilReference_Expect(commandBuffer, faceMask, reference) vkCmdSetStencilReference_CMockExpect(__LINE__, commandBuffer, faceMask, reference) +void vkCmdSetStencilReference_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference); +typedef void (* CMOCK_vkCmdSetStencilReference_CALLBACK)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference, int cmock_num_calls); +void vkCmdSetStencilReference_AddCallback(CMOCK_vkCmdSetStencilReference_CALLBACK Callback); +void vkCmdSetStencilReference_Stub(CMOCK_vkCmdSetStencilReference_CALLBACK Callback); +#define vkCmdSetStencilReference_StubWithCallback vkCmdSetStencilReference_AddCallback +#define vkCmdSetStencilReference_IgnoreArg_commandBuffer() vkCmdSetStencilReference_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetStencilReference_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilReference_IgnoreArg_faceMask() vkCmdSetStencilReference_CMockIgnoreArg_faceMask(__LINE__) +void vkCmdSetStencilReference_CMockIgnoreArg_faceMask(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilReference_IgnoreArg_reference() vkCmdSetStencilReference_CMockIgnoreArg_reference(__LINE__) +void vkCmdSetStencilReference_CMockIgnoreArg_reference(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindDescriptorSets_Ignore() vkCmdBindDescriptorSets_CMockIgnore() +void vkCmdBindDescriptorSets_CMockIgnore(void); +#define vkCmdBindDescriptorSets_StopIgnore() vkCmdBindDescriptorSets_CMockStopIgnore() +void vkCmdBindDescriptorSets_CMockStopIgnore(void); +#define vkCmdBindDescriptorSets_ExpectAnyArgs() vkCmdBindDescriptorSets_CMockExpectAnyArgs(__LINE__) +void vkCmdBindDescriptorSets_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindDescriptorSets_Expect(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets) vkCmdBindDescriptorSets_CMockExpect(__LINE__, commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets) +void vkCmdBindDescriptorSets_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); +typedef void (* CMOCK_vkCmdBindDescriptorSets_CALLBACK)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets, int cmock_num_calls); +void vkCmdBindDescriptorSets_AddCallback(CMOCK_vkCmdBindDescriptorSets_CALLBACK Callback); +void vkCmdBindDescriptorSets_Stub(CMOCK_vkCmdBindDescriptorSets_CALLBACK Callback); +#define vkCmdBindDescriptorSets_StubWithCallback vkCmdBindDescriptorSets_AddCallback +#define vkCmdBindDescriptorSets_IgnoreArg_commandBuffer() vkCmdBindDescriptorSets_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBindDescriptorSets_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindDescriptorSets_IgnoreArg_pipelineBindPoint() vkCmdBindDescriptorSets_CMockIgnoreArg_pipelineBindPoint(__LINE__) +void vkCmdBindDescriptorSets_CMockIgnoreArg_pipelineBindPoint(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindDescriptorSets_IgnoreArg_layout() vkCmdBindDescriptorSets_CMockIgnoreArg_layout(__LINE__) +void vkCmdBindDescriptorSets_CMockIgnoreArg_layout(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindDescriptorSets_IgnoreArg_firstSet() vkCmdBindDescriptorSets_CMockIgnoreArg_firstSet(__LINE__) +void vkCmdBindDescriptorSets_CMockIgnoreArg_firstSet(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindDescriptorSets_IgnoreArg_descriptorSetCount() vkCmdBindDescriptorSets_CMockIgnoreArg_descriptorSetCount(__LINE__) +void vkCmdBindDescriptorSets_CMockIgnoreArg_descriptorSetCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindDescriptorSets_IgnoreArg_pDescriptorSets() vkCmdBindDescriptorSets_CMockIgnoreArg_pDescriptorSets(__LINE__) +void vkCmdBindDescriptorSets_CMockIgnoreArg_pDescriptorSets(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindDescriptorSets_IgnoreArg_dynamicOffsetCount() vkCmdBindDescriptorSets_CMockIgnoreArg_dynamicOffsetCount(__LINE__) +void vkCmdBindDescriptorSets_CMockIgnoreArg_dynamicOffsetCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindDescriptorSets_IgnoreArg_pDynamicOffsets() vkCmdBindDescriptorSets_CMockIgnoreArg_pDynamicOffsets(__LINE__) +void vkCmdBindDescriptorSets_CMockIgnoreArg_pDynamicOffsets(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindIndexBuffer_Ignore() vkCmdBindIndexBuffer_CMockIgnore() +void vkCmdBindIndexBuffer_CMockIgnore(void); +#define vkCmdBindIndexBuffer_StopIgnore() vkCmdBindIndexBuffer_CMockStopIgnore() +void vkCmdBindIndexBuffer_CMockStopIgnore(void); +#define vkCmdBindIndexBuffer_ExpectAnyArgs() vkCmdBindIndexBuffer_CMockExpectAnyArgs(__LINE__) +void vkCmdBindIndexBuffer_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindIndexBuffer_Expect(commandBuffer, buffer, offset, indexType) vkCmdBindIndexBuffer_CMockExpect(__LINE__, commandBuffer, buffer, offset, indexType) +void vkCmdBindIndexBuffer_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); +typedef void (* CMOCK_vkCmdBindIndexBuffer_CALLBACK)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType, int cmock_num_calls); +void vkCmdBindIndexBuffer_AddCallback(CMOCK_vkCmdBindIndexBuffer_CALLBACK Callback); +void vkCmdBindIndexBuffer_Stub(CMOCK_vkCmdBindIndexBuffer_CALLBACK Callback); +#define vkCmdBindIndexBuffer_StubWithCallback vkCmdBindIndexBuffer_AddCallback +#define vkCmdBindIndexBuffer_IgnoreArg_commandBuffer() vkCmdBindIndexBuffer_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBindIndexBuffer_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindIndexBuffer_IgnoreArg_buffer() vkCmdBindIndexBuffer_CMockIgnoreArg_buffer(__LINE__) +void vkCmdBindIndexBuffer_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindIndexBuffer_IgnoreArg_offset() vkCmdBindIndexBuffer_CMockIgnoreArg_offset(__LINE__) +void vkCmdBindIndexBuffer_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindIndexBuffer_IgnoreArg_indexType() vkCmdBindIndexBuffer_CMockIgnoreArg_indexType(__LINE__) +void vkCmdBindIndexBuffer_CMockIgnoreArg_indexType(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindVertexBuffers_Ignore() vkCmdBindVertexBuffers_CMockIgnore() +void vkCmdBindVertexBuffers_CMockIgnore(void); +#define vkCmdBindVertexBuffers_StopIgnore() vkCmdBindVertexBuffers_CMockStopIgnore() +void vkCmdBindVertexBuffers_CMockStopIgnore(void); +#define vkCmdBindVertexBuffers_ExpectAnyArgs() vkCmdBindVertexBuffers_CMockExpectAnyArgs(__LINE__) +void vkCmdBindVertexBuffers_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindVertexBuffers_Expect(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets) vkCmdBindVertexBuffers_CMockExpect(__LINE__, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets) +void vkCmdBindVertexBuffers_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); +typedef void (* CMOCK_vkCmdBindVertexBuffers_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, int cmock_num_calls); +void vkCmdBindVertexBuffers_AddCallback(CMOCK_vkCmdBindVertexBuffers_CALLBACK Callback); +void vkCmdBindVertexBuffers_Stub(CMOCK_vkCmdBindVertexBuffers_CALLBACK Callback); +#define vkCmdBindVertexBuffers_StubWithCallback vkCmdBindVertexBuffers_AddCallback +#define vkCmdBindVertexBuffers_IgnoreArg_commandBuffer() vkCmdBindVertexBuffers_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBindVertexBuffers_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindVertexBuffers_IgnoreArg_firstBinding() vkCmdBindVertexBuffers_CMockIgnoreArg_firstBinding(__LINE__) +void vkCmdBindVertexBuffers_CMockIgnoreArg_firstBinding(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindVertexBuffers_IgnoreArg_bindingCount() vkCmdBindVertexBuffers_CMockIgnoreArg_bindingCount(__LINE__) +void vkCmdBindVertexBuffers_CMockIgnoreArg_bindingCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindVertexBuffers_IgnoreArg_pBuffers() vkCmdBindVertexBuffers_CMockIgnoreArg_pBuffers(__LINE__) +void vkCmdBindVertexBuffers_CMockIgnoreArg_pBuffers(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindVertexBuffers_IgnoreArg_pOffsets() vkCmdBindVertexBuffers_CMockIgnoreArg_pOffsets(__LINE__) +void vkCmdBindVertexBuffers_CMockIgnoreArg_pOffsets(UNITY_LINE_TYPE cmock_line); +#define vkCmdDraw_Ignore() vkCmdDraw_CMockIgnore() +void vkCmdDraw_CMockIgnore(void); +#define vkCmdDraw_StopIgnore() vkCmdDraw_CMockStopIgnore() +void vkCmdDraw_CMockStopIgnore(void); +#define vkCmdDraw_ExpectAnyArgs() vkCmdDraw_CMockExpectAnyArgs(__LINE__) +void vkCmdDraw_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDraw_Expect(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance) vkCmdDraw_CMockExpect(__LINE__, commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance) +void vkCmdDraw_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); +typedef void (* CMOCK_vkCmdDraw_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, int cmock_num_calls); +void vkCmdDraw_AddCallback(CMOCK_vkCmdDraw_CALLBACK Callback); +void vkCmdDraw_Stub(CMOCK_vkCmdDraw_CALLBACK Callback); +#define vkCmdDraw_StubWithCallback vkCmdDraw_AddCallback +#define vkCmdDraw_IgnoreArg_commandBuffer() vkCmdDraw_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDraw_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDraw_IgnoreArg_vertexCount() vkCmdDraw_CMockIgnoreArg_vertexCount(__LINE__) +void vkCmdDraw_CMockIgnoreArg_vertexCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdDraw_IgnoreArg_instanceCount() vkCmdDraw_CMockIgnoreArg_instanceCount(__LINE__) +void vkCmdDraw_CMockIgnoreArg_instanceCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdDraw_IgnoreArg_firstVertex() vkCmdDraw_CMockIgnoreArg_firstVertex(__LINE__) +void vkCmdDraw_CMockIgnoreArg_firstVertex(UNITY_LINE_TYPE cmock_line); +#define vkCmdDraw_IgnoreArg_firstInstance() vkCmdDraw_CMockIgnoreArg_firstInstance(__LINE__) +void vkCmdDraw_CMockIgnoreArg_firstInstance(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexed_Ignore() vkCmdDrawIndexed_CMockIgnore() +void vkCmdDrawIndexed_CMockIgnore(void); +#define vkCmdDrawIndexed_StopIgnore() vkCmdDrawIndexed_CMockStopIgnore() +void vkCmdDrawIndexed_CMockStopIgnore(void); +#define vkCmdDrawIndexed_ExpectAnyArgs() vkCmdDrawIndexed_CMockExpectAnyArgs(__LINE__) +void vkCmdDrawIndexed_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexed_Expect(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance) vkCmdDrawIndexed_CMockExpect(__LINE__, commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance) +void vkCmdDrawIndexed_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); +typedef void (* CMOCK_vkCmdDrawIndexed_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance, int cmock_num_calls); +void vkCmdDrawIndexed_AddCallback(CMOCK_vkCmdDrawIndexed_CALLBACK Callback); +void vkCmdDrawIndexed_Stub(CMOCK_vkCmdDrawIndexed_CALLBACK Callback); +#define vkCmdDrawIndexed_StubWithCallback vkCmdDrawIndexed_AddCallback +#define vkCmdDrawIndexed_IgnoreArg_commandBuffer() vkCmdDrawIndexed_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDrawIndexed_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexed_IgnoreArg_indexCount() vkCmdDrawIndexed_CMockIgnoreArg_indexCount(__LINE__) +void vkCmdDrawIndexed_CMockIgnoreArg_indexCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexed_IgnoreArg_instanceCount() vkCmdDrawIndexed_CMockIgnoreArg_instanceCount(__LINE__) +void vkCmdDrawIndexed_CMockIgnoreArg_instanceCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexed_IgnoreArg_firstIndex() vkCmdDrawIndexed_CMockIgnoreArg_firstIndex(__LINE__) +void vkCmdDrawIndexed_CMockIgnoreArg_firstIndex(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexed_IgnoreArg_vertexOffset() vkCmdDrawIndexed_CMockIgnoreArg_vertexOffset(__LINE__) +void vkCmdDrawIndexed_CMockIgnoreArg_vertexOffset(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexed_IgnoreArg_firstInstance() vkCmdDrawIndexed_CMockIgnoreArg_firstInstance(__LINE__) +void vkCmdDrawIndexed_CMockIgnoreArg_firstInstance(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirect_Ignore() vkCmdDrawIndirect_CMockIgnore() +void vkCmdDrawIndirect_CMockIgnore(void); +#define vkCmdDrawIndirect_StopIgnore() vkCmdDrawIndirect_CMockStopIgnore() +void vkCmdDrawIndirect_CMockStopIgnore(void); +#define vkCmdDrawIndirect_ExpectAnyArgs() vkCmdDrawIndirect_CMockExpectAnyArgs(__LINE__) +void vkCmdDrawIndirect_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirect_Expect(commandBuffer, buffer, offset, drawCount, stride) vkCmdDrawIndirect_CMockExpect(__LINE__, commandBuffer, buffer, offset, drawCount, stride) +void vkCmdDrawIndirect_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void (* CMOCK_vkCmdDrawIndirect_CALLBACK)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride, int cmock_num_calls); +void vkCmdDrawIndirect_AddCallback(CMOCK_vkCmdDrawIndirect_CALLBACK Callback); +void vkCmdDrawIndirect_Stub(CMOCK_vkCmdDrawIndirect_CALLBACK Callback); +#define vkCmdDrawIndirect_StubWithCallback vkCmdDrawIndirect_AddCallback +#define vkCmdDrawIndirect_IgnoreArg_commandBuffer() vkCmdDrawIndirect_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDrawIndirect_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirect_IgnoreArg_buffer() vkCmdDrawIndirect_CMockIgnoreArg_buffer(__LINE__) +void vkCmdDrawIndirect_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirect_IgnoreArg_offset() vkCmdDrawIndirect_CMockIgnoreArg_offset(__LINE__) +void vkCmdDrawIndirect_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirect_IgnoreArg_drawCount() vkCmdDrawIndirect_CMockIgnoreArg_drawCount(__LINE__) +void vkCmdDrawIndirect_CMockIgnoreArg_drawCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirect_IgnoreArg_stride() vkCmdDrawIndirect_CMockIgnoreArg_stride(__LINE__) +void vkCmdDrawIndirect_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexedIndirect_Ignore() vkCmdDrawIndexedIndirect_CMockIgnore() +void vkCmdDrawIndexedIndirect_CMockIgnore(void); +#define vkCmdDrawIndexedIndirect_StopIgnore() vkCmdDrawIndexedIndirect_CMockStopIgnore() +void vkCmdDrawIndexedIndirect_CMockStopIgnore(void); +#define vkCmdDrawIndexedIndirect_ExpectAnyArgs() vkCmdDrawIndexedIndirect_CMockExpectAnyArgs(__LINE__) +void vkCmdDrawIndexedIndirect_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexedIndirect_Expect(commandBuffer, buffer, offset, drawCount, stride) vkCmdDrawIndexedIndirect_CMockExpect(__LINE__, commandBuffer, buffer, offset, drawCount, stride) +void vkCmdDrawIndexedIndirect_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void (* CMOCK_vkCmdDrawIndexedIndirect_CALLBACK)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride, int cmock_num_calls); +void vkCmdDrawIndexedIndirect_AddCallback(CMOCK_vkCmdDrawIndexedIndirect_CALLBACK Callback); +void vkCmdDrawIndexedIndirect_Stub(CMOCK_vkCmdDrawIndexedIndirect_CALLBACK Callback); +#define vkCmdDrawIndexedIndirect_StubWithCallback vkCmdDrawIndexedIndirect_AddCallback +#define vkCmdDrawIndexedIndirect_IgnoreArg_commandBuffer() vkCmdDrawIndexedIndirect_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDrawIndexedIndirect_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexedIndirect_IgnoreArg_buffer() vkCmdDrawIndexedIndirect_CMockIgnoreArg_buffer(__LINE__) +void vkCmdDrawIndexedIndirect_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexedIndirect_IgnoreArg_offset() vkCmdDrawIndexedIndirect_CMockIgnoreArg_offset(__LINE__) +void vkCmdDrawIndexedIndirect_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexedIndirect_IgnoreArg_drawCount() vkCmdDrawIndexedIndirect_CMockIgnoreArg_drawCount(__LINE__) +void vkCmdDrawIndexedIndirect_CMockIgnoreArg_drawCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexedIndirect_IgnoreArg_stride() vkCmdDrawIndexedIndirect_CMockIgnoreArg_stride(__LINE__) +void vkCmdDrawIndexedIndirect_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line); +#define vkCmdDispatch_Ignore() vkCmdDispatch_CMockIgnore() +void vkCmdDispatch_CMockIgnore(void); +#define vkCmdDispatch_StopIgnore() vkCmdDispatch_CMockStopIgnore() +void vkCmdDispatch_CMockStopIgnore(void); +#define vkCmdDispatch_ExpectAnyArgs() vkCmdDispatch_CMockExpectAnyArgs(__LINE__) +void vkCmdDispatch_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDispatch_Expect(commandBuffer, groupCountX, groupCountY, groupCountZ) vkCmdDispatch_CMockExpect(__LINE__, commandBuffer, groupCountX, groupCountY, groupCountZ) +void vkCmdDispatch_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef void (* CMOCK_vkCmdDispatch_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, int cmock_num_calls); +void vkCmdDispatch_AddCallback(CMOCK_vkCmdDispatch_CALLBACK Callback); +void vkCmdDispatch_Stub(CMOCK_vkCmdDispatch_CALLBACK Callback); +#define vkCmdDispatch_StubWithCallback vkCmdDispatch_AddCallback +#define vkCmdDispatch_IgnoreArg_commandBuffer() vkCmdDispatch_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDispatch_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDispatch_IgnoreArg_groupCountX() vkCmdDispatch_CMockIgnoreArg_groupCountX(__LINE__) +void vkCmdDispatch_CMockIgnoreArg_groupCountX(UNITY_LINE_TYPE cmock_line); +#define vkCmdDispatch_IgnoreArg_groupCountY() vkCmdDispatch_CMockIgnoreArg_groupCountY(__LINE__) +void vkCmdDispatch_CMockIgnoreArg_groupCountY(UNITY_LINE_TYPE cmock_line); +#define vkCmdDispatch_IgnoreArg_groupCountZ() vkCmdDispatch_CMockIgnoreArg_groupCountZ(__LINE__) +void vkCmdDispatch_CMockIgnoreArg_groupCountZ(UNITY_LINE_TYPE cmock_line); +#define vkCmdDispatchIndirect_Ignore() vkCmdDispatchIndirect_CMockIgnore() +void vkCmdDispatchIndirect_CMockIgnore(void); +#define vkCmdDispatchIndirect_StopIgnore() vkCmdDispatchIndirect_CMockStopIgnore() +void vkCmdDispatchIndirect_CMockStopIgnore(void); +#define vkCmdDispatchIndirect_ExpectAnyArgs() vkCmdDispatchIndirect_CMockExpectAnyArgs(__LINE__) +void vkCmdDispatchIndirect_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDispatchIndirect_Expect(commandBuffer, buffer, offset) vkCmdDispatchIndirect_CMockExpect(__LINE__, commandBuffer, buffer, offset) +void vkCmdDispatchIndirect_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); +typedef void (* CMOCK_vkCmdDispatchIndirect_CALLBACK)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, int cmock_num_calls); +void vkCmdDispatchIndirect_AddCallback(CMOCK_vkCmdDispatchIndirect_CALLBACK Callback); +void vkCmdDispatchIndirect_Stub(CMOCK_vkCmdDispatchIndirect_CALLBACK Callback); +#define vkCmdDispatchIndirect_StubWithCallback vkCmdDispatchIndirect_AddCallback +#define vkCmdDispatchIndirect_IgnoreArg_commandBuffer() vkCmdDispatchIndirect_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDispatchIndirect_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDispatchIndirect_IgnoreArg_buffer() vkCmdDispatchIndirect_CMockIgnoreArg_buffer(__LINE__) +void vkCmdDispatchIndirect_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDispatchIndirect_IgnoreArg_offset() vkCmdDispatchIndirect_CMockIgnoreArg_offset(__LINE__) +void vkCmdDispatchIndirect_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyBuffer_Ignore() vkCmdCopyBuffer_CMockIgnore() +void vkCmdCopyBuffer_CMockIgnore(void); +#define vkCmdCopyBuffer_StopIgnore() vkCmdCopyBuffer_CMockStopIgnore() +void vkCmdCopyBuffer_CMockStopIgnore(void); +#define vkCmdCopyBuffer_ExpectAnyArgs() vkCmdCopyBuffer_CMockExpectAnyArgs(__LINE__) +void vkCmdCopyBuffer_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyBuffer_Expect(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions) vkCmdCopyBuffer_CMockExpect(__LINE__, commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions) +void vkCmdCopyBuffer_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); +typedef void (* CMOCK_vkCmdCopyBuffer_CALLBACK)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions, int cmock_num_calls); +void vkCmdCopyBuffer_AddCallback(CMOCK_vkCmdCopyBuffer_CALLBACK Callback); +void vkCmdCopyBuffer_Stub(CMOCK_vkCmdCopyBuffer_CALLBACK Callback); +#define vkCmdCopyBuffer_StubWithCallback vkCmdCopyBuffer_AddCallback +#define vkCmdCopyBuffer_IgnoreArg_commandBuffer() vkCmdCopyBuffer_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdCopyBuffer_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyBuffer_IgnoreArg_srcBuffer() vkCmdCopyBuffer_CMockIgnoreArg_srcBuffer(__LINE__) +void vkCmdCopyBuffer_CMockIgnoreArg_srcBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyBuffer_IgnoreArg_dstBuffer() vkCmdCopyBuffer_CMockIgnoreArg_dstBuffer(__LINE__) +void vkCmdCopyBuffer_CMockIgnoreArg_dstBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyBuffer_IgnoreArg_regionCount() vkCmdCopyBuffer_CMockIgnoreArg_regionCount(__LINE__) +void vkCmdCopyBuffer_CMockIgnoreArg_regionCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyBuffer_IgnoreArg_pRegions() vkCmdCopyBuffer_CMockIgnoreArg_pRegions(__LINE__) +void vkCmdCopyBuffer_CMockIgnoreArg_pRegions(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyImage_Ignore() vkCmdCopyImage_CMockIgnore() +void vkCmdCopyImage_CMockIgnore(void); +#define vkCmdCopyImage_StopIgnore() vkCmdCopyImage_CMockStopIgnore() +void vkCmdCopyImage_CMockStopIgnore(void); +#define vkCmdCopyImage_ExpectAnyArgs() vkCmdCopyImage_CMockExpectAnyArgs(__LINE__) +void vkCmdCopyImage_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyImage_Expect(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions) vkCmdCopyImage_CMockExpect(__LINE__, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions) +void vkCmdCopyImage_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); +typedef void (* CMOCK_vkCmdCopyImage_CALLBACK)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions, int cmock_num_calls); +void vkCmdCopyImage_AddCallback(CMOCK_vkCmdCopyImage_CALLBACK Callback); +void vkCmdCopyImage_Stub(CMOCK_vkCmdCopyImage_CALLBACK Callback); +#define vkCmdCopyImage_StubWithCallback vkCmdCopyImage_AddCallback +#define vkCmdCopyImage_IgnoreArg_commandBuffer() vkCmdCopyImage_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdCopyImage_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyImage_IgnoreArg_srcImage() vkCmdCopyImage_CMockIgnoreArg_srcImage(__LINE__) +void vkCmdCopyImage_CMockIgnoreArg_srcImage(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyImage_IgnoreArg_srcImageLayout() vkCmdCopyImage_CMockIgnoreArg_srcImageLayout(__LINE__) +void vkCmdCopyImage_CMockIgnoreArg_srcImageLayout(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyImage_IgnoreArg_dstImage() vkCmdCopyImage_CMockIgnoreArg_dstImage(__LINE__) +void vkCmdCopyImage_CMockIgnoreArg_dstImage(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyImage_IgnoreArg_dstImageLayout() vkCmdCopyImage_CMockIgnoreArg_dstImageLayout(__LINE__) +void vkCmdCopyImage_CMockIgnoreArg_dstImageLayout(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyImage_IgnoreArg_regionCount() vkCmdCopyImage_CMockIgnoreArg_regionCount(__LINE__) +void vkCmdCopyImage_CMockIgnoreArg_regionCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyImage_IgnoreArg_pRegions() vkCmdCopyImage_CMockIgnoreArg_pRegions(__LINE__) +void vkCmdCopyImage_CMockIgnoreArg_pRegions(UNITY_LINE_TYPE cmock_line); +#define vkCmdBlitImage_Ignore() vkCmdBlitImage_CMockIgnore() +void vkCmdBlitImage_CMockIgnore(void); +#define vkCmdBlitImage_StopIgnore() vkCmdBlitImage_CMockStopIgnore() +void vkCmdBlitImage_CMockStopIgnore(void); +#define vkCmdBlitImage_ExpectAnyArgs() vkCmdBlitImage_CMockExpectAnyArgs(__LINE__) +void vkCmdBlitImage_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBlitImage_Expect(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter) vkCmdBlitImage_CMockExpect(__LINE__, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter) +void vkCmdBlitImage_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter); +typedef void (* CMOCK_vkCmdBlitImage_CALLBACK)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter, int cmock_num_calls); +void vkCmdBlitImage_AddCallback(CMOCK_vkCmdBlitImage_CALLBACK Callback); +void vkCmdBlitImage_Stub(CMOCK_vkCmdBlitImage_CALLBACK Callback); +#define vkCmdBlitImage_StubWithCallback vkCmdBlitImage_AddCallback +#define vkCmdBlitImage_IgnoreArg_commandBuffer() vkCmdBlitImage_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBlitImage_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBlitImage_IgnoreArg_srcImage() vkCmdBlitImage_CMockIgnoreArg_srcImage(__LINE__) +void vkCmdBlitImage_CMockIgnoreArg_srcImage(UNITY_LINE_TYPE cmock_line); +#define vkCmdBlitImage_IgnoreArg_srcImageLayout() vkCmdBlitImage_CMockIgnoreArg_srcImageLayout(__LINE__) +void vkCmdBlitImage_CMockIgnoreArg_srcImageLayout(UNITY_LINE_TYPE cmock_line); +#define vkCmdBlitImage_IgnoreArg_dstImage() vkCmdBlitImage_CMockIgnoreArg_dstImage(__LINE__) +void vkCmdBlitImage_CMockIgnoreArg_dstImage(UNITY_LINE_TYPE cmock_line); +#define vkCmdBlitImage_IgnoreArg_dstImageLayout() vkCmdBlitImage_CMockIgnoreArg_dstImageLayout(__LINE__) +void vkCmdBlitImage_CMockIgnoreArg_dstImageLayout(UNITY_LINE_TYPE cmock_line); +#define vkCmdBlitImage_IgnoreArg_regionCount() vkCmdBlitImage_CMockIgnoreArg_regionCount(__LINE__) +void vkCmdBlitImage_CMockIgnoreArg_regionCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdBlitImage_IgnoreArg_pRegions() vkCmdBlitImage_CMockIgnoreArg_pRegions(__LINE__) +void vkCmdBlitImage_CMockIgnoreArg_pRegions(UNITY_LINE_TYPE cmock_line); +#define vkCmdBlitImage_IgnoreArg_filter() vkCmdBlitImage_CMockIgnoreArg_filter(__LINE__) +void vkCmdBlitImage_CMockIgnoreArg_filter(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyBufferToImage_Ignore() vkCmdCopyBufferToImage_CMockIgnore() +void vkCmdCopyBufferToImage_CMockIgnore(void); +#define vkCmdCopyBufferToImage_StopIgnore() vkCmdCopyBufferToImage_CMockStopIgnore() +void vkCmdCopyBufferToImage_CMockStopIgnore(void); +#define vkCmdCopyBufferToImage_ExpectAnyArgs() vkCmdCopyBufferToImage_CMockExpectAnyArgs(__LINE__) +void vkCmdCopyBufferToImage_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyBufferToImage_Expect(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions) vkCmdCopyBufferToImage_CMockExpect(__LINE__, commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions) +void vkCmdCopyBufferToImage_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); +typedef void (* CMOCK_vkCmdCopyBufferToImage_CALLBACK)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions, int cmock_num_calls); +void vkCmdCopyBufferToImage_AddCallback(CMOCK_vkCmdCopyBufferToImage_CALLBACK Callback); +void vkCmdCopyBufferToImage_Stub(CMOCK_vkCmdCopyBufferToImage_CALLBACK Callback); +#define vkCmdCopyBufferToImage_StubWithCallback vkCmdCopyBufferToImage_AddCallback +#define vkCmdCopyBufferToImage_IgnoreArg_commandBuffer() vkCmdCopyBufferToImage_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdCopyBufferToImage_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyBufferToImage_IgnoreArg_srcBuffer() vkCmdCopyBufferToImage_CMockIgnoreArg_srcBuffer(__LINE__) +void vkCmdCopyBufferToImage_CMockIgnoreArg_srcBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyBufferToImage_IgnoreArg_dstImage() vkCmdCopyBufferToImage_CMockIgnoreArg_dstImage(__LINE__) +void vkCmdCopyBufferToImage_CMockIgnoreArg_dstImage(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyBufferToImage_IgnoreArg_dstImageLayout() vkCmdCopyBufferToImage_CMockIgnoreArg_dstImageLayout(__LINE__) +void vkCmdCopyBufferToImage_CMockIgnoreArg_dstImageLayout(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyBufferToImage_IgnoreArg_regionCount() vkCmdCopyBufferToImage_CMockIgnoreArg_regionCount(__LINE__) +void vkCmdCopyBufferToImage_CMockIgnoreArg_regionCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyBufferToImage_IgnoreArg_pRegions() vkCmdCopyBufferToImage_CMockIgnoreArg_pRegions(__LINE__) +void vkCmdCopyBufferToImage_CMockIgnoreArg_pRegions(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyImageToBuffer_Ignore() vkCmdCopyImageToBuffer_CMockIgnore() +void vkCmdCopyImageToBuffer_CMockIgnore(void); +#define vkCmdCopyImageToBuffer_StopIgnore() vkCmdCopyImageToBuffer_CMockStopIgnore() +void vkCmdCopyImageToBuffer_CMockStopIgnore(void); +#define vkCmdCopyImageToBuffer_ExpectAnyArgs() vkCmdCopyImageToBuffer_CMockExpectAnyArgs(__LINE__) +void vkCmdCopyImageToBuffer_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyImageToBuffer_Expect(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions) vkCmdCopyImageToBuffer_CMockExpect(__LINE__, commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions) +void vkCmdCopyImageToBuffer_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); +typedef void (* CMOCK_vkCmdCopyImageToBuffer_CALLBACK)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions, int cmock_num_calls); +void vkCmdCopyImageToBuffer_AddCallback(CMOCK_vkCmdCopyImageToBuffer_CALLBACK Callback); +void vkCmdCopyImageToBuffer_Stub(CMOCK_vkCmdCopyImageToBuffer_CALLBACK Callback); +#define vkCmdCopyImageToBuffer_StubWithCallback vkCmdCopyImageToBuffer_AddCallback +#define vkCmdCopyImageToBuffer_IgnoreArg_commandBuffer() vkCmdCopyImageToBuffer_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdCopyImageToBuffer_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyImageToBuffer_IgnoreArg_srcImage() vkCmdCopyImageToBuffer_CMockIgnoreArg_srcImage(__LINE__) +void vkCmdCopyImageToBuffer_CMockIgnoreArg_srcImage(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyImageToBuffer_IgnoreArg_srcImageLayout() vkCmdCopyImageToBuffer_CMockIgnoreArg_srcImageLayout(__LINE__) +void vkCmdCopyImageToBuffer_CMockIgnoreArg_srcImageLayout(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyImageToBuffer_IgnoreArg_dstBuffer() vkCmdCopyImageToBuffer_CMockIgnoreArg_dstBuffer(__LINE__) +void vkCmdCopyImageToBuffer_CMockIgnoreArg_dstBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyImageToBuffer_IgnoreArg_regionCount() vkCmdCopyImageToBuffer_CMockIgnoreArg_regionCount(__LINE__) +void vkCmdCopyImageToBuffer_CMockIgnoreArg_regionCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyImageToBuffer_IgnoreArg_pRegions() vkCmdCopyImageToBuffer_CMockIgnoreArg_pRegions(__LINE__) +void vkCmdCopyImageToBuffer_CMockIgnoreArg_pRegions(UNITY_LINE_TYPE cmock_line); +#define vkCmdUpdateBuffer_Ignore() vkCmdUpdateBuffer_CMockIgnore() +void vkCmdUpdateBuffer_CMockIgnore(void); +#define vkCmdUpdateBuffer_StopIgnore() vkCmdUpdateBuffer_CMockStopIgnore() +void vkCmdUpdateBuffer_CMockStopIgnore(void); +#define vkCmdUpdateBuffer_ExpectAnyArgs() vkCmdUpdateBuffer_CMockExpectAnyArgs(__LINE__) +void vkCmdUpdateBuffer_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdUpdateBuffer_Expect(commandBuffer, dstBuffer, dstOffset, dataSize, pData) vkCmdUpdateBuffer_CMockExpect(__LINE__, commandBuffer, dstBuffer, dstOffset, dataSize, pData) +void vkCmdUpdateBuffer_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData); +typedef void (* CMOCK_vkCmdUpdateBuffer_CALLBACK)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData, int cmock_num_calls); +void vkCmdUpdateBuffer_AddCallback(CMOCK_vkCmdUpdateBuffer_CALLBACK Callback); +void vkCmdUpdateBuffer_Stub(CMOCK_vkCmdUpdateBuffer_CALLBACK Callback); +#define vkCmdUpdateBuffer_StubWithCallback vkCmdUpdateBuffer_AddCallback +#define vkCmdUpdateBuffer_IgnoreArg_commandBuffer() vkCmdUpdateBuffer_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdUpdateBuffer_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdUpdateBuffer_IgnoreArg_dstBuffer() vkCmdUpdateBuffer_CMockIgnoreArg_dstBuffer(__LINE__) +void vkCmdUpdateBuffer_CMockIgnoreArg_dstBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdUpdateBuffer_IgnoreArg_dstOffset() vkCmdUpdateBuffer_CMockIgnoreArg_dstOffset(__LINE__) +void vkCmdUpdateBuffer_CMockIgnoreArg_dstOffset(UNITY_LINE_TYPE cmock_line); +#define vkCmdUpdateBuffer_IgnoreArg_dataSize() vkCmdUpdateBuffer_CMockIgnoreArg_dataSize(__LINE__) +void vkCmdUpdateBuffer_CMockIgnoreArg_dataSize(UNITY_LINE_TYPE cmock_line); +#define vkCmdUpdateBuffer_IgnoreArg_pData() vkCmdUpdateBuffer_CMockIgnoreArg_pData(__LINE__) +void vkCmdUpdateBuffer_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line); +#define vkCmdFillBuffer_Ignore() vkCmdFillBuffer_CMockIgnore() +void vkCmdFillBuffer_CMockIgnore(void); +#define vkCmdFillBuffer_StopIgnore() vkCmdFillBuffer_CMockStopIgnore() +void vkCmdFillBuffer_CMockStopIgnore(void); +#define vkCmdFillBuffer_ExpectAnyArgs() vkCmdFillBuffer_CMockExpectAnyArgs(__LINE__) +void vkCmdFillBuffer_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdFillBuffer_Expect(commandBuffer, dstBuffer, dstOffset, size, data) vkCmdFillBuffer_CMockExpect(__LINE__, commandBuffer, dstBuffer, dstOffset, size, data) +void vkCmdFillBuffer_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); +typedef void (* CMOCK_vkCmdFillBuffer_CALLBACK)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data, int cmock_num_calls); +void vkCmdFillBuffer_AddCallback(CMOCK_vkCmdFillBuffer_CALLBACK Callback); +void vkCmdFillBuffer_Stub(CMOCK_vkCmdFillBuffer_CALLBACK Callback); +#define vkCmdFillBuffer_StubWithCallback vkCmdFillBuffer_AddCallback +#define vkCmdFillBuffer_IgnoreArg_commandBuffer() vkCmdFillBuffer_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdFillBuffer_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdFillBuffer_IgnoreArg_dstBuffer() vkCmdFillBuffer_CMockIgnoreArg_dstBuffer(__LINE__) +void vkCmdFillBuffer_CMockIgnoreArg_dstBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdFillBuffer_IgnoreArg_dstOffset() vkCmdFillBuffer_CMockIgnoreArg_dstOffset(__LINE__) +void vkCmdFillBuffer_CMockIgnoreArg_dstOffset(UNITY_LINE_TYPE cmock_line); +#define vkCmdFillBuffer_IgnoreArg_size() vkCmdFillBuffer_CMockIgnoreArg_size(__LINE__) +void vkCmdFillBuffer_CMockIgnoreArg_size(UNITY_LINE_TYPE cmock_line); +#define vkCmdFillBuffer_IgnoreArg_data() vkCmdFillBuffer_CMockIgnoreArg_data(__LINE__) +void vkCmdFillBuffer_CMockIgnoreArg_data(UNITY_LINE_TYPE cmock_line); +#define vkCmdClearColorImage_Ignore() vkCmdClearColorImage_CMockIgnore() +void vkCmdClearColorImage_CMockIgnore(void); +#define vkCmdClearColorImage_StopIgnore() vkCmdClearColorImage_CMockStopIgnore() +void vkCmdClearColorImage_CMockStopIgnore(void); +#define vkCmdClearColorImage_ExpectAnyArgs() vkCmdClearColorImage_CMockExpectAnyArgs(__LINE__) +void vkCmdClearColorImage_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdClearColorImage_Expect(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges) vkCmdClearColorImage_CMockExpect(__LINE__, commandBuffer, image, imageLayout, pColor, rangeCount, pRanges) +void vkCmdClearColorImage_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +typedef void (* CMOCK_vkCmdClearColorImage_CALLBACK)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges, int cmock_num_calls); +void vkCmdClearColorImage_AddCallback(CMOCK_vkCmdClearColorImage_CALLBACK Callback); +void vkCmdClearColorImage_Stub(CMOCK_vkCmdClearColorImage_CALLBACK Callback); +#define vkCmdClearColorImage_StubWithCallback vkCmdClearColorImage_AddCallback +#define vkCmdClearColorImage_IgnoreArg_commandBuffer() vkCmdClearColorImage_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdClearColorImage_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdClearColorImage_IgnoreArg_image() vkCmdClearColorImage_CMockIgnoreArg_image(__LINE__) +void vkCmdClearColorImage_CMockIgnoreArg_image(UNITY_LINE_TYPE cmock_line); +#define vkCmdClearColorImage_IgnoreArg_imageLayout() vkCmdClearColorImage_CMockIgnoreArg_imageLayout(__LINE__) +void vkCmdClearColorImage_CMockIgnoreArg_imageLayout(UNITY_LINE_TYPE cmock_line); +#define vkCmdClearColorImage_IgnoreArg_pColor() vkCmdClearColorImage_CMockIgnoreArg_pColor(__LINE__) +void vkCmdClearColorImage_CMockIgnoreArg_pColor(UNITY_LINE_TYPE cmock_line); +#define vkCmdClearColorImage_IgnoreArg_rangeCount() vkCmdClearColorImage_CMockIgnoreArg_rangeCount(__LINE__) +void vkCmdClearColorImage_CMockIgnoreArg_rangeCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdClearColorImage_IgnoreArg_pRanges() vkCmdClearColorImage_CMockIgnoreArg_pRanges(__LINE__) +void vkCmdClearColorImage_CMockIgnoreArg_pRanges(UNITY_LINE_TYPE cmock_line); +#define vkCmdClearDepthStencilImage_Ignore() vkCmdClearDepthStencilImage_CMockIgnore() +void vkCmdClearDepthStencilImage_CMockIgnore(void); +#define vkCmdClearDepthStencilImage_StopIgnore() vkCmdClearDepthStencilImage_CMockStopIgnore() +void vkCmdClearDepthStencilImage_CMockStopIgnore(void); +#define vkCmdClearDepthStencilImage_ExpectAnyArgs() vkCmdClearDepthStencilImage_CMockExpectAnyArgs(__LINE__) +void vkCmdClearDepthStencilImage_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdClearDepthStencilImage_Expect(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges) vkCmdClearDepthStencilImage_CMockExpect(__LINE__, commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges) +void vkCmdClearDepthStencilImage_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +typedef void (* CMOCK_vkCmdClearDepthStencilImage_CALLBACK)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges, int cmock_num_calls); +void vkCmdClearDepthStencilImage_AddCallback(CMOCK_vkCmdClearDepthStencilImage_CALLBACK Callback); +void vkCmdClearDepthStencilImage_Stub(CMOCK_vkCmdClearDepthStencilImage_CALLBACK Callback); +#define vkCmdClearDepthStencilImage_StubWithCallback vkCmdClearDepthStencilImage_AddCallback +#define vkCmdClearDepthStencilImage_IgnoreArg_commandBuffer() vkCmdClearDepthStencilImage_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdClearDepthStencilImage_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdClearDepthStencilImage_IgnoreArg_image() vkCmdClearDepthStencilImage_CMockIgnoreArg_image(__LINE__) +void vkCmdClearDepthStencilImage_CMockIgnoreArg_image(UNITY_LINE_TYPE cmock_line); +#define vkCmdClearDepthStencilImage_IgnoreArg_imageLayout() vkCmdClearDepthStencilImage_CMockIgnoreArg_imageLayout(__LINE__) +void vkCmdClearDepthStencilImage_CMockIgnoreArg_imageLayout(UNITY_LINE_TYPE cmock_line); +#define vkCmdClearDepthStencilImage_IgnoreArg_pDepthStencil() vkCmdClearDepthStencilImage_CMockIgnoreArg_pDepthStencil(__LINE__) +void vkCmdClearDepthStencilImage_CMockIgnoreArg_pDepthStencil(UNITY_LINE_TYPE cmock_line); +#define vkCmdClearDepthStencilImage_IgnoreArg_rangeCount() vkCmdClearDepthStencilImage_CMockIgnoreArg_rangeCount(__LINE__) +void vkCmdClearDepthStencilImage_CMockIgnoreArg_rangeCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdClearDepthStencilImage_IgnoreArg_pRanges() vkCmdClearDepthStencilImage_CMockIgnoreArg_pRanges(__LINE__) +void vkCmdClearDepthStencilImage_CMockIgnoreArg_pRanges(UNITY_LINE_TYPE cmock_line); +#define vkCmdClearAttachments_Ignore() vkCmdClearAttachments_CMockIgnore() +void vkCmdClearAttachments_CMockIgnore(void); +#define vkCmdClearAttachments_StopIgnore() vkCmdClearAttachments_CMockStopIgnore() +void vkCmdClearAttachments_CMockStopIgnore(void); +#define vkCmdClearAttachments_ExpectAnyArgs() vkCmdClearAttachments_CMockExpectAnyArgs(__LINE__) +void vkCmdClearAttachments_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdClearAttachments_Expect(commandBuffer, attachmentCount, pAttachments, rectCount, pRects) vkCmdClearAttachments_CMockExpect(__LINE__, commandBuffer, attachmentCount, pAttachments, rectCount, pRects) +void vkCmdClearAttachments_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects); +typedef void (* CMOCK_vkCmdClearAttachments_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects, int cmock_num_calls); +void vkCmdClearAttachments_AddCallback(CMOCK_vkCmdClearAttachments_CALLBACK Callback); +void vkCmdClearAttachments_Stub(CMOCK_vkCmdClearAttachments_CALLBACK Callback); +#define vkCmdClearAttachments_StubWithCallback vkCmdClearAttachments_AddCallback +#define vkCmdClearAttachments_IgnoreArg_commandBuffer() vkCmdClearAttachments_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdClearAttachments_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdClearAttachments_IgnoreArg_attachmentCount() vkCmdClearAttachments_CMockIgnoreArg_attachmentCount(__LINE__) +void vkCmdClearAttachments_CMockIgnoreArg_attachmentCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdClearAttachments_IgnoreArg_pAttachments() vkCmdClearAttachments_CMockIgnoreArg_pAttachments(__LINE__) +void vkCmdClearAttachments_CMockIgnoreArg_pAttachments(UNITY_LINE_TYPE cmock_line); +#define vkCmdClearAttachments_IgnoreArg_rectCount() vkCmdClearAttachments_CMockIgnoreArg_rectCount(__LINE__) +void vkCmdClearAttachments_CMockIgnoreArg_rectCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdClearAttachments_IgnoreArg_pRects() vkCmdClearAttachments_CMockIgnoreArg_pRects(__LINE__) +void vkCmdClearAttachments_CMockIgnoreArg_pRects(UNITY_LINE_TYPE cmock_line); +#define vkCmdResolveImage_Ignore() vkCmdResolveImage_CMockIgnore() +void vkCmdResolveImage_CMockIgnore(void); +#define vkCmdResolveImage_StopIgnore() vkCmdResolveImage_CMockStopIgnore() +void vkCmdResolveImage_CMockStopIgnore(void); +#define vkCmdResolveImage_ExpectAnyArgs() vkCmdResolveImage_CMockExpectAnyArgs(__LINE__) +void vkCmdResolveImage_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdResolveImage_Expect(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions) vkCmdResolveImage_CMockExpect(__LINE__, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions) +void vkCmdResolveImage_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); +typedef void (* CMOCK_vkCmdResolveImage_CALLBACK)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions, int cmock_num_calls); +void vkCmdResolveImage_AddCallback(CMOCK_vkCmdResolveImage_CALLBACK Callback); +void vkCmdResolveImage_Stub(CMOCK_vkCmdResolveImage_CALLBACK Callback); +#define vkCmdResolveImage_StubWithCallback vkCmdResolveImage_AddCallback +#define vkCmdResolveImage_IgnoreArg_commandBuffer() vkCmdResolveImage_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdResolveImage_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdResolveImage_IgnoreArg_srcImage() vkCmdResolveImage_CMockIgnoreArg_srcImage(__LINE__) +void vkCmdResolveImage_CMockIgnoreArg_srcImage(UNITY_LINE_TYPE cmock_line); +#define vkCmdResolveImage_IgnoreArg_srcImageLayout() vkCmdResolveImage_CMockIgnoreArg_srcImageLayout(__LINE__) +void vkCmdResolveImage_CMockIgnoreArg_srcImageLayout(UNITY_LINE_TYPE cmock_line); +#define vkCmdResolveImage_IgnoreArg_dstImage() vkCmdResolveImage_CMockIgnoreArg_dstImage(__LINE__) +void vkCmdResolveImage_CMockIgnoreArg_dstImage(UNITY_LINE_TYPE cmock_line); +#define vkCmdResolveImage_IgnoreArg_dstImageLayout() vkCmdResolveImage_CMockIgnoreArg_dstImageLayout(__LINE__) +void vkCmdResolveImage_CMockIgnoreArg_dstImageLayout(UNITY_LINE_TYPE cmock_line); +#define vkCmdResolveImage_IgnoreArg_regionCount() vkCmdResolveImage_CMockIgnoreArg_regionCount(__LINE__) +void vkCmdResolveImage_CMockIgnoreArg_regionCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdResolveImage_IgnoreArg_pRegions() vkCmdResolveImage_CMockIgnoreArg_pRegions(__LINE__) +void vkCmdResolveImage_CMockIgnoreArg_pRegions(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetEvent_Ignore() vkCmdSetEvent_CMockIgnore() +void vkCmdSetEvent_CMockIgnore(void); +#define vkCmdSetEvent_StopIgnore() vkCmdSetEvent_CMockStopIgnore() +void vkCmdSetEvent_CMockStopIgnore(void); +#define vkCmdSetEvent_ExpectAnyArgs() vkCmdSetEvent_CMockExpectAnyArgs(__LINE__) +void vkCmdSetEvent_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetEvent_Expect(commandBuffer, event, stageMask) vkCmdSetEvent_CMockExpect(__LINE__, commandBuffer, event, stageMask) +void vkCmdSetEvent_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); +typedef void (* CMOCK_vkCmdSetEvent_CALLBACK)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask, int cmock_num_calls); +void vkCmdSetEvent_AddCallback(CMOCK_vkCmdSetEvent_CALLBACK Callback); +void vkCmdSetEvent_Stub(CMOCK_vkCmdSetEvent_CALLBACK Callback); +#define vkCmdSetEvent_StubWithCallback vkCmdSetEvent_AddCallback +#define vkCmdSetEvent_IgnoreArg_commandBuffer() vkCmdSetEvent_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetEvent_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetEvent_IgnoreArg_event() vkCmdSetEvent_CMockIgnoreArg_event(__LINE__) +void vkCmdSetEvent_CMockIgnoreArg_event(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetEvent_IgnoreArg_stageMask() vkCmdSetEvent_CMockIgnoreArg_stageMask(__LINE__) +void vkCmdSetEvent_CMockIgnoreArg_stageMask(UNITY_LINE_TYPE cmock_line); +#define vkCmdResetEvent_Ignore() vkCmdResetEvent_CMockIgnore() +void vkCmdResetEvent_CMockIgnore(void); +#define vkCmdResetEvent_StopIgnore() vkCmdResetEvent_CMockStopIgnore() +void vkCmdResetEvent_CMockStopIgnore(void); +#define vkCmdResetEvent_ExpectAnyArgs() vkCmdResetEvent_CMockExpectAnyArgs(__LINE__) +void vkCmdResetEvent_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdResetEvent_Expect(commandBuffer, event, stageMask) vkCmdResetEvent_CMockExpect(__LINE__, commandBuffer, event, stageMask) +void vkCmdResetEvent_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); +typedef void (* CMOCK_vkCmdResetEvent_CALLBACK)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask, int cmock_num_calls); +void vkCmdResetEvent_AddCallback(CMOCK_vkCmdResetEvent_CALLBACK Callback); +void vkCmdResetEvent_Stub(CMOCK_vkCmdResetEvent_CALLBACK Callback); +#define vkCmdResetEvent_StubWithCallback vkCmdResetEvent_AddCallback +#define vkCmdResetEvent_IgnoreArg_commandBuffer() vkCmdResetEvent_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdResetEvent_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdResetEvent_IgnoreArg_event() vkCmdResetEvent_CMockIgnoreArg_event(__LINE__) +void vkCmdResetEvent_CMockIgnoreArg_event(UNITY_LINE_TYPE cmock_line); +#define vkCmdResetEvent_IgnoreArg_stageMask() vkCmdResetEvent_CMockIgnoreArg_stageMask(__LINE__) +void vkCmdResetEvent_CMockIgnoreArg_stageMask(UNITY_LINE_TYPE cmock_line); +#define vkCmdWaitEvents_Ignore() vkCmdWaitEvents_CMockIgnore() +void vkCmdWaitEvents_CMockIgnore(void); +#define vkCmdWaitEvents_StopIgnore() vkCmdWaitEvents_CMockStopIgnore() +void vkCmdWaitEvents_CMockStopIgnore(void); +#define vkCmdWaitEvents_ExpectAnyArgs() vkCmdWaitEvents_CMockExpectAnyArgs(__LINE__) +void vkCmdWaitEvents_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdWaitEvents_Expect(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers) vkCmdWaitEvents_CMockExpect(__LINE__, commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers) +void vkCmdWaitEvents_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); +typedef void (* CMOCK_vkCmdWaitEvents_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers, int cmock_num_calls); +void vkCmdWaitEvents_AddCallback(CMOCK_vkCmdWaitEvents_CALLBACK Callback); +void vkCmdWaitEvents_Stub(CMOCK_vkCmdWaitEvents_CALLBACK Callback); +#define vkCmdWaitEvents_StubWithCallback vkCmdWaitEvents_AddCallback +#define vkCmdWaitEvents_IgnoreArg_commandBuffer() vkCmdWaitEvents_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdWaitEvents_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdWaitEvents_IgnoreArg_eventCount() vkCmdWaitEvents_CMockIgnoreArg_eventCount(__LINE__) +void vkCmdWaitEvents_CMockIgnoreArg_eventCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdWaitEvents_IgnoreArg_pEvents() vkCmdWaitEvents_CMockIgnoreArg_pEvents(__LINE__) +void vkCmdWaitEvents_CMockIgnoreArg_pEvents(UNITY_LINE_TYPE cmock_line); +#define vkCmdWaitEvents_IgnoreArg_srcStageMask() vkCmdWaitEvents_CMockIgnoreArg_srcStageMask(__LINE__) +void vkCmdWaitEvents_CMockIgnoreArg_srcStageMask(UNITY_LINE_TYPE cmock_line); +#define vkCmdWaitEvents_IgnoreArg_dstStageMask() vkCmdWaitEvents_CMockIgnoreArg_dstStageMask(__LINE__) +void vkCmdWaitEvents_CMockIgnoreArg_dstStageMask(UNITY_LINE_TYPE cmock_line); +#define vkCmdWaitEvents_IgnoreArg_memoryBarrierCount() vkCmdWaitEvents_CMockIgnoreArg_memoryBarrierCount(__LINE__) +void vkCmdWaitEvents_CMockIgnoreArg_memoryBarrierCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdWaitEvents_IgnoreArg_pMemoryBarriers() vkCmdWaitEvents_CMockIgnoreArg_pMemoryBarriers(__LINE__) +void vkCmdWaitEvents_CMockIgnoreArg_pMemoryBarriers(UNITY_LINE_TYPE cmock_line); +#define vkCmdWaitEvents_IgnoreArg_bufferMemoryBarrierCount() vkCmdWaitEvents_CMockIgnoreArg_bufferMemoryBarrierCount(__LINE__) +void vkCmdWaitEvents_CMockIgnoreArg_bufferMemoryBarrierCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdWaitEvents_IgnoreArg_pBufferMemoryBarriers() vkCmdWaitEvents_CMockIgnoreArg_pBufferMemoryBarriers(__LINE__) +void vkCmdWaitEvents_CMockIgnoreArg_pBufferMemoryBarriers(UNITY_LINE_TYPE cmock_line); +#define vkCmdWaitEvents_IgnoreArg_imageMemoryBarrierCount() vkCmdWaitEvents_CMockIgnoreArg_imageMemoryBarrierCount(__LINE__) +void vkCmdWaitEvents_CMockIgnoreArg_imageMemoryBarrierCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdWaitEvents_IgnoreArg_pImageMemoryBarriers() vkCmdWaitEvents_CMockIgnoreArg_pImageMemoryBarriers(__LINE__) +void vkCmdWaitEvents_CMockIgnoreArg_pImageMemoryBarriers(UNITY_LINE_TYPE cmock_line); +#define vkCmdPipelineBarrier_Ignore() vkCmdPipelineBarrier_CMockIgnore() +void vkCmdPipelineBarrier_CMockIgnore(void); +#define vkCmdPipelineBarrier_StopIgnore() vkCmdPipelineBarrier_CMockStopIgnore() +void vkCmdPipelineBarrier_CMockStopIgnore(void); +#define vkCmdPipelineBarrier_ExpectAnyArgs() vkCmdPipelineBarrier_CMockExpectAnyArgs(__LINE__) +void vkCmdPipelineBarrier_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdPipelineBarrier_Expect(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers) vkCmdPipelineBarrier_CMockExpect(__LINE__, commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers) +void vkCmdPipelineBarrier_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); +typedef void (* CMOCK_vkCmdPipelineBarrier_CALLBACK)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers, int cmock_num_calls); +void vkCmdPipelineBarrier_AddCallback(CMOCK_vkCmdPipelineBarrier_CALLBACK Callback); +void vkCmdPipelineBarrier_Stub(CMOCK_vkCmdPipelineBarrier_CALLBACK Callback); +#define vkCmdPipelineBarrier_StubWithCallback vkCmdPipelineBarrier_AddCallback +#define vkCmdPipelineBarrier_IgnoreArg_commandBuffer() vkCmdPipelineBarrier_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdPipelineBarrier_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdPipelineBarrier_IgnoreArg_srcStageMask() vkCmdPipelineBarrier_CMockIgnoreArg_srcStageMask(__LINE__) +void vkCmdPipelineBarrier_CMockIgnoreArg_srcStageMask(UNITY_LINE_TYPE cmock_line); +#define vkCmdPipelineBarrier_IgnoreArg_dstStageMask() vkCmdPipelineBarrier_CMockIgnoreArg_dstStageMask(__LINE__) +void vkCmdPipelineBarrier_CMockIgnoreArg_dstStageMask(UNITY_LINE_TYPE cmock_line); +#define vkCmdPipelineBarrier_IgnoreArg_dependencyFlags() vkCmdPipelineBarrier_CMockIgnoreArg_dependencyFlags(__LINE__) +void vkCmdPipelineBarrier_CMockIgnoreArg_dependencyFlags(UNITY_LINE_TYPE cmock_line); +#define vkCmdPipelineBarrier_IgnoreArg_memoryBarrierCount() vkCmdPipelineBarrier_CMockIgnoreArg_memoryBarrierCount(__LINE__) +void vkCmdPipelineBarrier_CMockIgnoreArg_memoryBarrierCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdPipelineBarrier_IgnoreArg_pMemoryBarriers() vkCmdPipelineBarrier_CMockIgnoreArg_pMemoryBarriers(__LINE__) +void vkCmdPipelineBarrier_CMockIgnoreArg_pMemoryBarriers(UNITY_LINE_TYPE cmock_line); +#define vkCmdPipelineBarrier_IgnoreArg_bufferMemoryBarrierCount() vkCmdPipelineBarrier_CMockIgnoreArg_bufferMemoryBarrierCount(__LINE__) +void vkCmdPipelineBarrier_CMockIgnoreArg_bufferMemoryBarrierCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdPipelineBarrier_IgnoreArg_pBufferMemoryBarriers() vkCmdPipelineBarrier_CMockIgnoreArg_pBufferMemoryBarriers(__LINE__) +void vkCmdPipelineBarrier_CMockIgnoreArg_pBufferMemoryBarriers(UNITY_LINE_TYPE cmock_line); +#define vkCmdPipelineBarrier_IgnoreArg_imageMemoryBarrierCount() vkCmdPipelineBarrier_CMockIgnoreArg_imageMemoryBarrierCount(__LINE__) +void vkCmdPipelineBarrier_CMockIgnoreArg_imageMemoryBarrierCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdPipelineBarrier_IgnoreArg_pImageMemoryBarriers() vkCmdPipelineBarrier_CMockIgnoreArg_pImageMemoryBarriers(__LINE__) +void vkCmdPipelineBarrier_CMockIgnoreArg_pImageMemoryBarriers(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginQuery_Ignore() vkCmdBeginQuery_CMockIgnore() +void vkCmdBeginQuery_CMockIgnore(void); +#define vkCmdBeginQuery_StopIgnore() vkCmdBeginQuery_CMockStopIgnore() +void vkCmdBeginQuery_CMockStopIgnore(void); +#define vkCmdBeginQuery_ExpectAnyArgs() vkCmdBeginQuery_CMockExpectAnyArgs(__LINE__) +void vkCmdBeginQuery_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginQuery_Expect(commandBuffer, queryPool, query, flags) vkCmdBeginQuery_CMockExpect(__LINE__, commandBuffer, queryPool, query, flags) +void vkCmdBeginQuery_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags); +typedef void (* CMOCK_vkCmdBeginQuery_CALLBACK)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, int cmock_num_calls); +void vkCmdBeginQuery_AddCallback(CMOCK_vkCmdBeginQuery_CALLBACK Callback); +void vkCmdBeginQuery_Stub(CMOCK_vkCmdBeginQuery_CALLBACK Callback); +#define vkCmdBeginQuery_StubWithCallback vkCmdBeginQuery_AddCallback +#define vkCmdBeginQuery_IgnoreArg_commandBuffer() vkCmdBeginQuery_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBeginQuery_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginQuery_IgnoreArg_queryPool() vkCmdBeginQuery_CMockIgnoreArg_queryPool(__LINE__) +void vkCmdBeginQuery_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginQuery_IgnoreArg_query() vkCmdBeginQuery_CMockIgnoreArg_query(__LINE__) +void vkCmdBeginQuery_CMockIgnoreArg_query(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginQuery_IgnoreArg_flags() vkCmdBeginQuery_CMockIgnoreArg_flags(__LINE__) +void vkCmdBeginQuery_CMockIgnoreArg_flags(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndQuery_Ignore() vkCmdEndQuery_CMockIgnore() +void vkCmdEndQuery_CMockIgnore(void); +#define vkCmdEndQuery_StopIgnore() vkCmdEndQuery_CMockStopIgnore() +void vkCmdEndQuery_CMockStopIgnore(void); +#define vkCmdEndQuery_ExpectAnyArgs() vkCmdEndQuery_CMockExpectAnyArgs(__LINE__) +void vkCmdEndQuery_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndQuery_Expect(commandBuffer, queryPool, query) vkCmdEndQuery_CMockExpect(__LINE__, commandBuffer, queryPool, query) +void vkCmdEndQuery_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query); +typedef void (* CMOCK_vkCmdEndQuery_CALLBACK)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, int cmock_num_calls); +void vkCmdEndQuery_AddCallback(CMOCK_vkCmdEndQuery_CALLBACK Callback); +void vkCmdEndQuery_Stub(CMOCK_vkCmdEndQuery_CALLBACK Callback); +#define vkCmdEndQuery_StubWithCallback vkCmdEndQuery_AddCallback +#define vkCmdEndQuery_IgnoreArg_commandBuffer() vkCmdEndQuery_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdEndQuery_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndQuery_IgnoreArg_queryPool() vkCmdEndQuery_CMockIgnoreArg_queryPool(__LINE__) +void vkCmdEndQuery_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndQuery_IgnoreArg_query() vkCmdEndQuery_CMockIgnoreArg_query(__LINE__) +void vkCmdEndQuery_CMockIgnoreArg_query(UNITY_LINE_TYPE cmock_line); +#define vkCmdResetQueryPool_Ignore() vkCmdResetQueryPool_CMockIgnore() +void vkCmdResetQueryPool_CMockIgnore(void); +#define vkCmdResetQueryPool_StopIgnore() vkCmdResetQueryPool_CMockStopIgnore() +void vkCmdResetQueryPool_CMockStopIgnore(void); +#define vkCmdResetQueryPool_ExpectAnyArgs() vkCmdResetQueryPool_CMockExpectAnyArgs(__LINE__) +void vkCmdResetQueryPool_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdResetQueryPool_Expect(commandBuffer, queryPool, firstQuery, queryCount) vkCmdResetQueryPool_CMockExpect(__LINE__, commandBuffer, queryPool, firstQuery, queryCount) +void vkCmdResetQueryPool_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); +typedef void (* CMOCK_vkCmdResetQueryPool_CALLBACK)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, int cmock_num_calls); +void vkCmdResetQueryPool_AddCallback(CMOCK_vkCmdResetQueryPool_CALLBACK Callback); +void vkCmdResetQueryPool_Stub(CMOCK_vkCmdResetQueryPool_CALLBACK Callback); +#define vkCmdResetQueryPool_StubWithCallback vkCmdResetQueryPool_AddCallback +#define vkCmdResetQueryPool_IgnoreArg_commandBuffer() vkCmdResetQueryPool_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdResetQueryPool_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdResetQueryPool_IgnoreArg_queryPool() vkCmdResetQueryPool_CMockIgnoreArg_queryPool(__LINE__) +void vkCmdResetQueryPool_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line); +#define vkCmdResetQueryPool_IgnoreArg_firstQuery() vkCmdResetQueryPool_CMockIgnoreArg_firstQuery(__LINE__) +void vkCmdResetQueryPool_CMockIgnoreArg_firstQuery(UNITY_LINE_TYPE cmock_line); +#define vkCmdResetQueryPool_IgnoreArg_queryCount() vkCmdResetQueryPool_CMockIgnoreArg_queryCount(__LINE__) +void vkCmdResetQueryPool_CMockIgnoreArg_queryCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteTimestamp_Ignore() vkCmdWriteTimestamp_CMockIgnore() +void vkCmdWriteTimestamp_CMockIgnore(void); +#define vkCmdWriteTimestamp_StopIgnore() vkCmdWriteTimestamp_CMockStopIgnore() +void vkCmdWriteTimestamp_CMockStopIgnore(void); +#define vkCmdWriteTimestamp_ExpectAnyArgs() vkCmdWriteTimestamp_CMockExpectAnyArgs(__LINE__) +void vkCmdWriteTimestamp_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteTimestamp_Expect(commandBuffer, pipelineStage, queryPool, query) vkCmdWriteTimestamp_CMockExpect(__LINE__, commandBuffer, pipelineStage, queryPool, query) +void vkCmdWriteTimestamp_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query); +typedef void (* CMOCK_vkCmdWriteTimestamp_CALLBACK)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query, int cmock_num_calls); +void vkCmdWriteTimestamp_AddCallback(CMOCK_vkCmdWriteTimestamp_CALLBACK Callback); +void vkCmdWriteTimestamp_Stub(CMOCK_vkCmdWriteTimestamp_CALLBACK Callback); +#define vkCmdWriteTimestamp_StubWithCallback vkCmdWriteTimestamp_AddCallback +#define vkCmdWriteTimestamp_IgnoreArg_commandBuffer() vkCmdWriteTimestamp_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdWriteTimestamp_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteTimestamp_IgnoreArg_pipelineStage() vkCmdWriteTimestamp_CMockIgnoreArg_pipelineStage(__LINE__) +void vkCmdWriteTimestamp_CMockIgnoreArg_pipelineStage(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteTimestamp_IgnoreArg_queryPool() vkCmdWriteTimestamp_CMockIgnoreArg_queryPool(__LINE__) +void vkCmdWriteTimestamp_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteTimestamp_IgnoreArg_query() vkCmdWriteTimestamp_CMockIgnoreArg_query(__LINE__) +void vkCmdWriteTimestamp_CMockIgnoreArg_query(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyQueryPoolResults_Ignore() vkCmdCopyQueryPoolResults_CMockIgnore() +void vkCmdCopyQueryPoolResults_CMockIgnore(void); +#define vkCmdCopyQueryPoolResults_StopIgnore() vkCmdCopyQueryPoolResults_CMockStopIgnore() +void vkCmdCopyQueryPoolResults_CMockStopIgnore(void); +#define vkCmdCopyQueryPoolResults_ExpectAnyArgs() vkCmdCopyQueryPoolResults_CMockExpectAnyArgs(__LINE__) +void vkCmdCopyQueryPoolResults_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyQueryPoolResults_Expect(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags) vkCmdCopyQueryPoolResults_CMockExpect(__LINE__, commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags) +void vkCmdCopyQueryPoolResults_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags); +typedef void (* CMOCK_vkCmdCopyQueryPoolResults_CALLBACK)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags, int cmock_num_calls); +void vkCmdCopyQueryPoolResults_AddCallback(CMOCK_vkCmdCopyQueryPoolResults_CALLBACK Callback); +void vkCmdCopyQueryPoolResults_Stub(CMOCK_vkCmdCopyQueryPoolResults_CALLBACK Callback); +#define vkCmdCopyQueryPoolResults_StubWithCallback vkCmdCopyQueryPoolResults_AddCallback +#define vkCmdCopyQueryPoolResults_IgnoreArg_commandBuffer() vkCmdCopyQueryPoolResults_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdCopyQueryPoolResults_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyQueryPoolResults_IgnoreArg_queryPool() vkCmdCopyQueryPoolResults_CMockIgnoreArg_queryPool(__LINE__) +void vkCmdCopyQueryPoolResults_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyQueryPoolResults_IgnoreArg_firstQuery() vkCmdCopyQueryPoolResults_CMockIgnoreArg_firstQuery(__LINE__) +void vkCmdCopyQueryPoolResults_CMockIgnoreArg_firstQuery(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyQueryPoolResults_IgnoreArg_queryCount() vkCmdCopyQueryPoolResults_CMockIgnoreArg_queryCount(__LINE__) +void vkCmdCopyQueryPoolResults_CMockIgnoreArg_queryCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyQueryPoolResults_IgnoreArg_dstBuffer() vkCmdCopyQueryPoolResults_CMockIgnoreArg_dstBuffer(__LINE__) +void vkCmdCopyQueryPoolResults_CMockIgnoreArg_dstBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyQueryPoolResults_IgnoreArg_dstOffset() vkCmdCopyQueryPoolResults_CMockIgnoreArg_dstOffset(__LINE__) +void vkCmdCopyQueryPoolResults_CMockIgnoreArg_dstOffset(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyQueryPoolResults_IgnoreArg_stride() vkCmdCopyQueryPoolResults_CMockIgnoreArg_stride(__LINE__) +void vkCmdCopyQueryPoolResults_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyQueryPoolResults_IgnoreArg_flags() vkCmdCopyQueryPoolResults_CMockIgnoreArg_flags(__LINE__) +void vkCmdCopyQueryPoolResults_CMockIgnoreArg_flags(UNITY_LINE_TYPE cmock_line); +#define vkCmdPushConstants_Ignore() vkCmdPushConstants_CMockIgnore() +void vkCmdPushConstants_CMockIgnore(void); +#define vkCmdPushConstants_StopIgnore() vkCmdPushConstants_CMockStopIgnore() +void vkCmdPushConstants_CMockStopIgnore(void); +#define vkCmdPushConstants_ExpectAnyArgs() vkCmdPushConstants_CMockExpectAnyArgs(__LINE__) +void vkCmdPushConstants_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdPushConstants_Expect(commandBuffer, layout, stageFlags, offset, size, pValues) vkCmdPushConstants_CMockExpect(__LINE__, commandBuffer, layout, stageFlags, offset, size, pValues) +void vkCmdPushConstants_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues); +typedef void (* CMOCK_vkCmdPushConstants_CALLBACK)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues, int cmock_num_calls); +void vkCmdPushConstants_AddCallback(CMOCK_vkCmdPushConstants_CALLBACK Callback); +void vkCmdPushConstants_Stub(CMOCK_vkCmdPushConstants_CALLBACK Callback); +#define vkCmdPushConstants_StubWithCallback vkCmdPushConstants_AddCallback +#define vkCmdPushConstants_IgnoreArg_commandBuffer() vkCmdPushConstants_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdPushConstants_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdPushConstants_IgnoreArg_layout() vkCmdPushConstants_CMockIgnoreArg_layout(__LINE__) +void vkCmdPushConstants_CMockIgnoreArg_layout(UNITY_LINE_TYPE cmock_line); +#define vkCmdPushConstants_IgnoreArg_stageFlags() vkCmdPushConstants_CMockIgnoreArg_stageFlags(__LINE__) +void vkCmdPushConstants_CMockIgnoreArg_stageFlags(UNITY_LINE_TYPE cmock_line); +#define vkCmdPushConstants_IgnoreArg_offset() vkCmdPushConstants_CMockIgnoreArg_offset(__LINE__) +void vkCmdPushConstants_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line); +#define vkCmdPushConstants_IgnoreArg_size() vkCmdPushConstants_CMockIgnoreArg_size(__LINE__) +void vkCmdPushConstants_CMockIgnoreArg_size(UNITY_LINE_TYPE cmock_line); +#define vkCmdPushConstants_IgnoreArg_pValues() vkCmdPushConstants_CMockIgnoreArg_pValues(__LINE__) +void vkCmdPushConstants_CMockIgnoreArg_pValues(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginRenderPass_Ignore() vkCmdBeginRenderPass_CMockIgnore() +void vkCmdBeginRenderPass_CMockIgnore(void); +#define vkCmdBeginRenderPass_StopIgnore() vkCmdBeginRenderPass_CMockStopIgnore() +void vkCmdBeginRenderPass_CMockStopIgnore(void); +#define vkCmdBeginRenderPass_ExpectAnyArgs() vkCmdBeginRenderPass_CMockExpectAnyArgs(__LINE__) +void vkCmdBeginRenderPass_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginRenderPass_Expect(commandBuffer, pRenderPassBegin, contents) vkCmdBeginRenderPass_CMockExpect(__LINE__, commandBuffer, pRenderPassBegin, contents) +void vkCmdBeginRenderPass_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents); +typedef void (* CMOCK_vkCmdBeginRenderPass_CALLBACK)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents, int cmock_num_calls); +void vkCmdBeginRenderPass_AddCallback(CMOCK_vkCmdBeginRenderPass_CALLBACK Callback); +void vkCmdBeginRenderPass_Stub(CMOCK_vkCmdBeginRenderPass_CALLBACK Callback); +#define vkCmdBeginRenderPass_StubWithCallback vkCmdBeginRenderPass_AddCallback +#define vkCmdBeginRenderPass_IgnoreArg_commandBuffer() vkCmdBeginRenderPass_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBeginRenderPass_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginRenderPass_IgnoreArg_pRenderPassBegin() vkCmdBeginRenderPass_CMockIgnoreArg_pRenderPassBegin(__LINE__) +void vkCmdBeginRenderPass_CMockIgnoreArg_pRenderPassBegin(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginRenderPass_IgnoreArg_contents() vkCmdBeginRenderPass_CMockIgnoreArg_contents(__LINE__) +void vkCmdBeginRenderPass_CMockIgnoreArg_contents(UNITY_LINE_TYPE cmock_line); +#define vkCmdNextSubpass_Ignore() vkCmdNextSubpass_CMockIgnore() +void vkCmdNextSubpass_CMockIgnore(void); +#define vkCmdNextSubpass_StopIgnore() vkCmdNextSubpass_CMockStopIgnore() +void vkCmdNextSubpass_CMockStopIgnore(void); +#define vkCmdNextSubpass_ExpectAnyArgs() vkCmdNextSubpass_CMockExpectAnyArgs(__LINE__) +void vkCmdNextSubpass_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdNextSubpass_Expect(commandBuffer, contents) vkCmdNextSubpass_CMockExpect(__LINE__, commandBuffer, contents) +void vkCmdNextSubpass_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkSubpassContents contents); +typedef void (* CMOCK_vkCmdNextSubpass_CALLBACK)(VkCommandBuffer commandBuffer, VkSubpassContents contents, int cmock_num_calls); +void vkCmdNextSubpass_AddCallback(CMOCK_vkCmdNextSubpass_CALLBACK Callback); +void vkCmdNextSubpass_Stub(CMOCK_vkCmdNextSubpass_CALLBACK Callback); +#define vkCmdNextSubpass_StubWithCallback vkCmdNextSubpass_AddCallback +#define vkCmdNextSubpass_IgnoreArg_commandBuffer() vkCmdNextSubpass_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdNextSubpass_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdNextSubpass_IgnoreArg_contents() vkCmdNextSubpass_CMockIgnoreArg_contents(__LINE__) +void vkCmdNextSubpass_CMockIgnoreArg_contents(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndRenderPass_Ignore() vkCmdEndRenderPass_CMockIgnore() +void vkCmdEndRenderPass_CMockIgnore(void); +#define vkCmdEndRenderPass_StopIgnore() vkCmdEndRenderPass_CMockStopIgnore() +void vkCmdEndRenderPass_CMockStopIgnore(void); +#define vkCmdEndRenderPass_ExpectAnyArgs() vkCmdEndRenderPass_CMockExpectAnyArgs(__LINE__) +void vkCmdEndRenderPass_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndRenderPass_Expect(commandBuffer) vkCmdEndRenderPass_CMockExpect(__LINE__, commandBuffer) +void vkCmdEndRenderPass_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer); +typedef void (* CMOCK_vkCmdEndRenderPass_CALLBACK)(VkCommandBuffer commandBuffer, int cmock_num_calls); +void vkCmdEndRenderPass_AddCallback(CMOCK_vkCmdEndRenderPass_CALLBACK Callback); +void vkCmdEndRenderPass_Stub(CMOCK_vkCmdEndRenderPass_CALLBACK Callback); +#define vkCmdEndRenderPass_StubWithCallback vkCmdEndRenderPass_AddCallback +#define vkCmdEndRenderPass_IgnoreArg_commandBuffer() vkCmdEndRenderPass_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdEndRenderPass_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdExecuteCommands_Ignore() vkCmdExecuteCommands_CMockIgnore() +void vkCmdExecuteCommands_CMockIgnore(void); +#define vkCmdExecuteCommands_StopIgnore() vkCmdExecuteCommands_CMockStopIgnore() +void vkCmdExecuteCommands_CMockStopIgnore(void); +#define vkCmdExecuteCommands_ExpectAnyArgs() vkCmdExecuteCommands_CMockExpectAnyArgs(__LINE__) +void vkCmdExecuteCommands_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdExecuteCommands_Expect(commandBuffer, commandBufferCount, pCommandBuffers) vkCmdExecuteCommands_CMockExpect(__LINE__, commandBuffer, commandBufferCount, pCommandBuffers) +void vkCmdExecuteCommands_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); +typedef void (* CMOCK_vkCmdExecuteCommands_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers, int cmock_num_calls); +void vkCmdExecuteCommands_AddCallback(CMOCK_vkCmdExecuteCommands_CALLBACK Callback); +void vkCmdExecuteCommands_Stub(CMOCK_vkCmdExecuteCommands_CALLBACK Callback); +#define vkCmdExecuteCommands_StubWithCallback vkCmdExecuteCommands_AddCallback +#define vkCmdExecuteCommands_IgnoreArg_commandBuffer() vkCmdExecuteCommands_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdExecuteCommands_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdExecuteCommands_IgnoreArg_commandBufferCount() vkCmdExecuteCommands_CMockIgnoreArg_commandBufferCount(__LINE__) +void vkCmdExecuteCommands_CMockIgnoreArg_commandBufferCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdExecuteCommands_IgnoreArg_pCommandBuffers() vkCmdExecuteCommands_CMockIgnoreArg_pCommandBuffers(__LINE__) +void vkCmdExecuteCommands_CMockIgnoreArg_pCommandBuffers(UNITY_LINE_TYPE cmock_line); +#define vkEnumerateInstanceVersion_IgnoreAndReturn(cmock_retval) vkEnumerateInstanceVersion_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkEnumerateInstanceVersion_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkEnumerateInstanceVersion_StopIgnore() vkEnumerateInstanceVersion_CMockStopIgnore() +void vkEnumerateInstanceVersion_CMockStopIgnore(void); +#define vkEnumerateInstanceVersion_ExpectAnyArgsAndReturn(cmock_retval) vkEnumerateInstanceVersion_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkEnumerateInstanceVersion_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkEnumerateInstanceVersion_ExpectAndReturn(pApiVersion, cmock_retval) vkEnumerateInstanceVersion_CMockExpectAndReturn(__LINE__, pApiVersion, cmock_retval) +void vkEnumerateInstanceVersion_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, uint32_t* pApiVersion, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkEnumerateInstanceVersion_CALLBACK)(uint32_t* pApiVersion, int cmock_num_calls); +void vkEnumerateInstanceVersion_AddCallback(CMOCK_vkEnumerateInstanceVersion_CALLBACK Callback); +void vkEnumerateInstanceVersion_Stub(CMOCK_vkEnumerateInstanceVersion_CALLBACK Callback); +#define vkEnumerateInstanceVersion_StubWithCallback vkEnumerateInstanceVersion_AddCallback +#define vkEnumerateInstanceVersion_ReturnThruPtr_pApiVersion(pApiVersion) vkEnumerateInstanceVersion_CMockReturnMemThruPtr_pApiVersion(__LINE__, pApiVersion, sizeof(uint32_t)) +#define vkEnumerateInstanceVersion_ReturnArrayThruPtr_pApiVersion(pApiVersion, cmock_len) vkEnumerateInstanceVersion_CMockReturnMemThruPtr_pApiVersion(__LINE__, pApiVersion, cmock_len * sizeof(*pApiVersion)) +#define vkEnumerateInstanceVersion_ReturnMemThruPtr_pApiVersion(pApiVersion, cmock_size) vkEnumerateInstanceVersion_CMockReturnMemThruPtr_pApiVersion(__LINE__, pApiVersion, cmock_size) +void vkEnumerateInstanceVersion_CMockReturnMemThruPtr_pApiVersion(UNITY_LINE_TYPE cmock_line, uint32_t const* pApiVersion, size_t cmock_size); +#define vkEnumerateInstanceVersion_IgnoreArg_pApiVersion() vkEnumerateInstanceVersion_CMockIgnoreArg_pApiVersion(__LINE__) +void vkEnumerateInstanceVersion_CMockIgnoreArg_pApiVersion(UNITY_LINE_TYPE cmock_line); +#define vkBindBufferMemory2_IgnoreAndReturn(cmock_retval) vkBindBufferMemory2_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkBindBufferMemory2_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkBindBufferMemory2_StopIgnore() vkBindBufferMemory2_CMockStopIgnore() +void vkBindBufferMemory2_CMockStopIgnore(void); +#define vkBindBufferMemory2_ExpectAnyArgsAndReturn(cmock_retval) vkBindBufferMemory2_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkBindBufferMemory2_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkBindBufferMemory2_ExpectAndReturn(device, bindInfoCount, pBindInfos, cmock_retval) vkBindBufferMemory2_CMockExpectAndReturn(__LINE__, device, bindInfoCount, pBindInfos, cmock_retval) +void vkBindBufferMemory2_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkBindBufferMemory2_CALLBACK)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos, int cmock_num_calls); +void vkBindBufferMemory2_AddCallback(CMOCK_vkBindBufferMemory2_CALLBACK Callback); +void vkBindBufferMemory2_Stub(CMOCK_vkBindBufferMemory2_CALLBACK Callback); +#define vkBindBufferMemory2_StubWithCallback vkBindBufferMemory2_AddCallback +#define vkBindBufferMemory2_IgnoreArg_device() vkBindBufferMemory2_CMockIgnoreArg_device(__LINE__) +void vkBindBufferMemory2_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkBindBufferMemory2_IgnoreArg_bindInfoCount() vkBindBufferMemory2_CMockIgnoreArg_bindInfoCount(__LINE__) +void vkBindBufferMemory2_CMockIgnoreArg_bindInfoCount(UNITY_LINE_TYPE cmock_line); +#define vkBindBufferMemory2_IgnoreArg_pBindInfos() vkBindBufferMemory2_CMockIgnoreArg_pBindInfos(__LINE__) +void vkBindBufferMemory2_CMockIgnoreArg_pBindInfos(UNITY_LINE_TYPE cmock_line); +#define vkBindImageMemory2_IgnoreAndReturn(cmock_retval) vkBindImageMemory2_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkBindImageMemory2_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkBindImageMemory2_StopIgnore() vkBindImageMemory2_CMockStopIgnore() +void vkBindImageMemory2_CMockStopIgnore(void); +#define vkBindImageMemory2_ExpectAnyArgsAndReturn(cmock_retval) vkBindImageMemory2_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkBindImageMemory2_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkBindImageMemory2_ExpectAndReturn(device, bindInfoCount, pBindInfos, cmock_retval) vkBindImageMemory2_CMockExpectAndReturn(__LINE__, device, bindInfoCount, pBindInfos, cmock_retval) +void vkBindImageMemory2_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkBindImageMemory2_CALLBACK)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos, int cmock_num_calls); +void vkBindImageMemory2_AddCallback(CMOCK_vkBindImageMemory2_CALLBACK Callback); +void vkBindImageMemory2_Stub(CMOCK_vkBindImageMemory2_CALLBACK Callback); +#define vkBindImageMemory2_StubWithCallback vkBindImageMemory2_AddCallback +#define vkBindImageMemory2_IgnoreArg_device() vkBindImageMemory2_CMockIgnoreArg_device(__LINE__) +void vkBindImageMemory2_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkBindImageMemory2_IgnoreArg_bindInfoCount() vkBindImageMemory2_CMockIgnoreArg_bindInfoCount(__LINE__) +void vkBindImageMemory2_CMockIgnoreArg_bindInfoCount(UNITY_LINE_TYPE cmock_line); +#define vkBindImageMemory2_IgnoreArg_pBindInfos() vkBindImageMemory2_CMockIgnoreArg_pBindInfos(__LINE__) +void vkBindImageMemory2_CMockIgnoreArg_pBindInfos(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceGroupPeerMemoryFeatures_Ignore() vkGetDeviceGroupPeerMemoryFeatures_CMockIgnore() +void vkGetDeviceGroupPeerMemoryFeatures_CMockIgnore(void); +#define vkGetDeviceGroupPeerMemoryFeatures_StopIgnore() vkGetDeviceGroupPeerMemoryFeatures_CMockStopIgnore() +void vkGetDeviceGroupPeerMemoryFeatures_CMockStopIgnore(void); +#define vkGetDeviceGroupPeerMemoryFeatures_ExpectAnyArgs() vkGetDeviceGroupPeerMemoryFeatures_CMockExpectAnyArgs(__LINE__) +void vkGetDeviceGroupPeerMemoryFeatures_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceGroupPeerMemoryFeatures_Expect(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures) vkGetDeviceGroupPeerMemoryFeatures_CMockExpect(__LINE__, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures) +void vkGetDeviceGroupPeerMemoryFeatures_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); +typedef void (* CMOCK_vkGetDeviceGroupPeerMemoryFeatures_CALLBACK)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures, int cmock_num_calls); +void vkGetDeviceGroupPeerMemoryFeatures_AddCallback(CMOCK_vkGetDeviceGroupPeerMemoryFeatures_CALLBACK Callback); +void vkGetDeviceGroupPeerMemoryFeatures_Stub(CMOCK_vkGetDeviceGroupPeerMemoryFeatures_CALLBACK Callback); +#define vkGetDeviceGroupPeerMemoryFeatures_StubWithCallback vkGetDeviceGroupPeerMemoryFeatures_AddCallback +#define vkGetDeviceGroupPeerMemoryFeatures_ReturnThruPtr_pPeerMemoryFeatures(pPeerMemoryFeatures) vkGetDeviceGroupPeerMemoryFeatures_CMockReturnMemThruPtr_pPeerMemoryFeatures(__LINE__, pPeerMemoryFeatures, sizeof(VkPeerMemoryFeatureFlags)) +#define vkGetDeviceGroupPeerMemoryFeatures_ReturnArrayThruPtr_pPeerMemoryFeatures(pPeerMemoryFeatures, cmock_len) vkGetDeviceGroupPeerMemoryFeatures_CMockReturnMemThruPtr_pPeerMemoryFeatures(__LINE__, pPeerMemoryFeatures, cmock_len * sizeof(*pPeerMemoryFeatures)) +#define vkGetDeviceGroupPeerMemoryFeatures_ReturnMemThruPtr_pPeerMemoryFeatures(pPeerMemoryFeatures, cmock_size) vkGetDeviceGroupPeerMemoryFeatures_CMockReturnMemThruPtr_pPeerMemoryFeatures(__LINE__, pPeerMemoryFeatures, cmock_size) +void vkGetDeviceGroupPeerMemoryFeatures_CMockReturnMemThruPtr_pPeerMemoryFeatures(UNITY_LINE_TYPE cmock_line, VkPeerMemoryFeatureFlags const* pPeerMemoryFeatures, size_t cmock_size); +#define vkGetDeviceGroupPeerMemoryFeatures_IgnoreArg_device() vkGetDeviceGroupPeerMemoryFeatures_CMockIgnoreArg_device(__LINE__) +void vkGetDeviceGroupPeerMemoryFeatures_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceGroupPeerMemoryFeatures_IgnoreArg_heapIndex() vkGetDeviceGroupPeerMemoryFeatures_CMockIgnoreArg_heapIndex(__LINE__) +void vkGetDeviceGroupPeerMemoryFeatures_CMockIgnoreArg_heapIndex(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceGroupPeerMemoryFeatures_IgnoreArg_localDeviceIndex() vkGetDeviceGroupPeerMemoryFeatures_CMockIgnoreArg_localDeviceIndex(__LINE__) +void vkGetDeviceGroupPeerMemoryFeatures_CMockIgnoreArg_localDeviceIndex(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceGroupPeerMemoryFeatures_IgnoreArg_remoteDeviceIndex() vkGetDeviceGroupPeerMemoryFeatures_CMockIgnoreArg_remoteDeviceIndex(__LINE__) +void vkGetDeviceGroupPeerMemoryFeatures_CMockIgnoreArg_remoteDeviceIndex(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceGroupPeerMemoryFeatures_IgnoreArg_pPeerMemoryFeatures() vkGetDeviceGroupPeerMemoryFeatures_CMockIgnoreArg_pPeerMemoryFeatures(__LINE__) +void vkGetDeviceGroupPeerMemoryFeatures_CMockIgnoreArg_pPeerMemoryFeatures(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDeviceMask_Ignore() vkCmdSetDeviceMask_CMockIgnore() +void vkCmdSetDeviceMask_CMockIgnore(void); +#define vkCmdSetDeviceMask_StopIgnore() vkCmdSetDeviceMask_CMockStopIgnore() +void vkCmdSetDeviceMask_CMockStopIgnore(void); +#define vkCmdSetDeviceMask_ExpectAnyArgs() vkCmdSetDeviceMask_CMockExpectAnyArgs(__LINE__) +void vkCmdSetDeviceMask_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDeviceMask_Expect(commandBuffer, deviceMask) vkCmdSetDeviceMask_CMockExpect(__LINE__, commandBuffer, deviceMask) +void vkCmdSetDeviceMask_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t deviceMask); +typedef void (* CMOCK_vkCmdSetDeviceMask_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t deviceMask, int cmock_num_calls); +void vkCmdSetDeviceMask_AddCallback(CMOCK_vkCmdSetDeviceMask_CALLBACK Callback); +void vkCmdSetDeviceMask_Stub(CMOCK_vkCmdSetDeviceMask_CALLBACK Callback); +#define vkCmdSetDeviceMask_StubWithCallback vkCmdSetDeviceMask_AddCallback +#define vkCmdSetDeviceMask_IgnoreArg_commandBuffer() vkCmdSetDeviceMask_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetDeviceMask_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDeviceMask_IgnoreArg_deviceMask() vkCmdSetDeviceMask_CMockIgnoreArg_deviceMask(__LINE__) +void vkCmdSetDeviceMask_CMockIgnoreArg_deviceMask(UNITY_LINE_TYPE cmock_line); +#define vkCmdDispatchBase_Ignore() vkCmdDispatchBase_CMockIgnore() +void vkCmdDispatchBase_CMockIgnore(void); +#define vkCmdDispatchBase_StopIgnore() vkCmdDispatchBase_CMockStopIgnore() +void vkCmdDispatchBase_CMockStopIgnore(void); +#define vkCmdDispatchBase_ExpectAnyArgs() vkCmdDispatchBase_CMockExpectAnyArgs(__LINE__) +void vkCmdDispatchBase_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDispatchBase_Expect(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ) vkCmdDispatchBase_CMockExpect(__LINE__, commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ) +void vkCmdDispatchBase_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef void (* CMOCK_vkCmdDispatchBase_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, int cmock_num_calls); +void vkCmdDispatchBase_AddCallback(CMOCK_vkCmdDispatchBase_CALLBACK Callback); +void vkCmdDispatchBase_Stub(CMOCK_vkCmdDispatchBase_CALLBACK Callback); +#define vkCmdDispatchBase_StubWithCallback vkCmdDispatchBase_AddCallback +#define vkCmdDispatchBase_IgnoreArg_commandBuffer() vkCmdDispatchBase_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDispatchBase_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDispatchBase_IgnoreArg_baseGroupX() vkCmdDispatchBase_CMockIgnoreArg_baseGroupX(__LINE__) +void vkCmdDispatchBase_CMockIgnoreArg_baseGroupX(UNITY_LINE_TYPE cmock_line); +#define vkCmdDispatchBase_IgnoreArg_baseGroupY() vkCmdDispatchBase_CMockIgnoreArg_baseGroupY(__LINE__) +void vkCmdDispatchBase_CMockIgnoreArg_baseGroupY(UNITY_LINE_TYPE cmock_line); +#define vkCmdDispatchBase_IgnoreArg_baseGroupZ() vkCmdDispatchBase_CMockIgnoreArg_baseGroupZ(__LINE__) +void vkCmdDispatchBase_CMockIgnoreArg_baseGroupZ(UNITY_LINE_TYPE cmock_line); +#define vkCmdDispatchBase_IgnoreArg_groupCountX() vkCmdDispatchBase_CMockIgnoreArg_groupCountX(__LINE__) +void vkCmdDispatchBase_CMockIgnoreArg_groupCountX(UNITY_LINE_TYPE cmock_line); +#define vkCmdDispatchBase_IgnoreArg_groupCountY() vkCmdDispatchBase_CMockIgnoreArg_groupCountY(__LINE__) +void vkCmdDispatchBase_CMockIgnoreArg_groupCountY(UNITY_LINE_TYPE cmock_line); +#define vkCmdDispatchBase_IgnoreArg_groupCountZ() vkCmdDispatchBase_CMockIgnoreArg_groupCountZ(__LINE__) +void vkCmdDispatchBase_CMockIgnoreArg_groupCountZ(UNITY_LINE_TYPE cmock_line); +#define vkEnumeratePhysicalDeviceGroups_IgnoreAndReturn(cmock_retval) vkEnumeratePhysicalDeviceGroups_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkEnumeratePhysicalDeviceGroups_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkEnumeratePhysicalDeviceGroups_StopIgnore() vkEnumeratePhysicalDeviceGroups_CMockStopIgnore() +void vkEnumeratePhysicalDeviceGroups_CMockStopIgnore(void); +#define vkEnumeratePhysicalDeviceGroups_ExpectAnyArgsAndReturn(cmock_retval) vkEnumeratePhysicalDeviceGroups_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkEnumeratePhysicalDeviceGroups_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkEnumeratePhysicalDeviceGroups_ExpectAndReturn(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, cmock_retval) vkEnumeratePhysicalDeviceGroups_CMockExpectAndReturn(__LINE__, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, cmock_retval) +void vkEnumeratePhysicalDeviceGroups_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkEnumeratePhysicalDeviceGroups_CALLBACK)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, int cmock_num_calls); +void vkEnumeratePhysicalDeviceGroups_AddCallback(CMOCK_vkEnumeratePhysicalDeviceGroups_CALLBACK Callback); +void vkEnumeratePhysicalDeviceGroups_Stub(CMOCK_vkEnumeratePhysicalDeviceGroups_CALLBACK Callback); +#define vkEnumeratePhysicalDeviceGroups_StubWithCallback vkEnumeratePhysicalDeviceGroups_AddCallback +#define vkEnumeratePhysicalDeviceGroups_ReturnThruPtr_pPhysicalDeviceGroupCount(pPhysicalDeviceGroupCount) vkEnumeratePhysicalDeviceGroups_CMockReturnMemThruPtr_pPhysicalDeviceGroupCount(__LINE__, pPhysicalDeviceGroupCount, sizeof(uint32_t)) +#define vkEnumeratePhysicalDeviceGroups_ReturnArrayThruPtr_pPhysicalDeviceGroupCount(pPhysicalDeviceGroupCount, cmock_len) vkEnumeratePhysicalDeviceGroups_CMockReturnMemThruPtr_pPhysicalDeviceGroupCount(__LINE__, pPhysicalDeviceGroupCount, cmock_len * sizeof(*pPhysicalDeviceGroupCount)) +#define vkEnumeratePhysicalDeviceGroups_ReturnMemThruPtr_pPhysicalDeviceGroupCount(pPhysicalDeviceGroupCount, cmock_size) vkEnumeratePhysicalDeviceGroups_CMockReturnMemThruPtr_pPhysicalDeviceGroupCount(__LINE__, pPhysicalDeviceGroupCount, cmock_size) +void vkEnumeratePhysicalDeviceGroups_CMockReturnMemThruPtr_pPhysicalDeviceGroupCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPhysicalDeviceGroupCount, size_t cmock_size); +#define vkEnumeratePhysicalDeviceGroups_ReturnThruPtr_pPhysicalDeviceGroupProperties(pPhysicalDeviceGroupProperties) vkEnumeratePhysicalDeviceGroups_CMockReturnMemThruPtr_pPhysicalDeviceGroupProperties(__LINE__, pPhysicalDeviceGroupProperties, sizeof(VkPhysicalDeviceGroupProperties)) +#define vkEnumeratePhysicalDeviceGroups_ReturnArrayThruPtr_pPhysicalDeviceGroupProperties(pPhysicalDeviceGroupProperties, cmock_len) vkEnumeratePhysicalDeviceGroups_CMockReturnMemThruPtr_pPhysicalDeviceGroupProperties(__LINE__, pPhysicalDeviceGroupProperties, cmock_len * sizeof(*pPhysicalDeviceGroupProperties)) +#define vkEnumeratePhysicalDeviceGroups_ReturnMemThruPtr_pPhysicalDeviceGroupProperties(pPhysicalDeviceGroupProperties, cmock_size) vkEnumeratePhysicalDeviceGroups_CMockReturnMemThruPtr_pPhysicalDeviceGroupProperties(__LINE__, pPhysicalDeviceGroupProperties, cmock_size) +void vkEnumeratePhysicalDeviceGroups_CMockReturnMemThruPtr_pPhysicalDeviceGroupProperties(UNITY_LINE_TYPE cmock_line, VkPhysicalDeviceGroupProperties const* pPhysicalDeviceGroupProperties, size_t cmock_size); +#define vkEnumeratePhysicalDeviceGroups_IgnoreArg_instance() vkEnumeratePhysicalDeviceGroups_CMockIgnoreArg_instance(__LINE__) +void vkEnumeratePhysicalDeviceGroups_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line); +#define vkEnumeratePhysicalDeviceGroups_IgnoreArg_pPhysicalDeviceGroupCount() vkEnumeratePhysicalDeviceGroups_CMockIgnoreArg_pPhysicalDeviceGroupCount(__LINE__) +void vkEnumeratePhysicalDeviceGroups_CMockIgnoreArg_pPhysicalDeviceGroupCount(UNITY_LINE_TYPE cmock_line); +#define vkEnumeratePhysicalDeviceGroups_IgnoreArg_pPhysicalDeviceGroupProperties() vkEnumeratePhysicalDeviceGroups_CMockIgnoreArg_pPhysicalDeviceGroupProperties(__LINE__) +void vkEnumeratePhysicalDeviceGroups_CMockIgnoreArg_pPhysicalDeviceGroupProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetImageMemoryRequirements2_Ignore() vkGetImageMemoryRequirements2_CMockIgnore() +void vkGetImageMemoryRequirements2_CMockIgnore(void); +#define vkGetImageMemoryRequirements2_StopIgnore() vkGetImageMemoryRequirements2_CMockStopIgnore() +void vkGetImageMemoryRequirements2_CMockStopIgnore(void); +#define vkGetImageMemoryRequirements2_ExpectAnyArgs() vkGetImageMemoryRequirements2_CMockExpectAnyArgs(__LINE__) +void vkGetImageMemoryRequirements2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetImageMemoryRequirements2_Expect(device, pInfo, pMemoryRequirements) vkGetImageMemoryRequirements2_CMockExpect(__LINE__, device, pInfo, pMemoryRequirements) +void vkGetImageMemoryRequirements2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (* CMOCK_vkGetImageMemoryRequirements2_CALLBACK)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements, int cmock_num_calls); +void vkGetImageMemoryRequirements2_AddCallback(CMOCK_vkGetImageMemoryRequirements2_CALLBACK Callback); +void vkGetImageMemoryRequirements2_Stub(CMOCK_vkGetImageMemoryRequirements2_CALLBACK Callback); +#define vkGetImageMemoryRequirements2_StubWithCallback vkGetImageMemoryRequirements2_AddCallback +#define vkGetImageMemoryRequirements2_ReturnThruPtr_pMemoryRequirements(pMemoryRequirements) vkGetImageMemoryRequirements2_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, sizeof(VkMemoryRequirements2)) +#define vkGetImageMemoryRequirements2_ReturnArrayThruPtr_pMemoryRequirements(pMemoryRequirements, cmock_len) vkGetImageMemoryRequirements2_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, cmock_len * sizeof(*pMemoryRequirements)) +#define vkGetImageMemoryRequirements2_ReturnMemThruPtr_pMemoryRequirements(pMemoryRequirements, cmock_size) vkGetImageMemoryRequirements2_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, cmock_size) +void vkGetImageMemoryRequirements2_CMockReturnMemThruPtr_pMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkMemoryRequirements2 const* pMemoryRequirements, size_t cmock_size); +#define vkGetImageMemoryRequirements2_IgnoreArg_device() vkGetImageMemoryRequirements2_CMockIgnoreArg_device(__LINE__) +void vkGetImageMemoryRequirements2_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetImageMemoryRequirements2_IgnoreArg_pInfo() vkGetImageMemoryRequirements2_CMockIgnoreArg_pInfo(__LINE__) +void vkGetImageMemoryRequirements2_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetImageMemoryRequirements2_IgnoreArg_pMemoryRequirements() vkGetImageMemoryRequirements2_CMockIgnoreArg_pMemoryRequirements(__LINE__) +void vkGetImageMemoryRequirements2_CMockIgnoreArg_pMemoryRequirements(UNITY_LINE_TYPE cmock_line); +#define vkGetBufferMemoryRequirements2_Ignore() vkGetBufferMemoryRequirements2_CMockIgnore() +void vkGetBufferMemoryRequirements2_CMockIgnore(void); +#define vkGetBufferMemoryRequirements2_StopIgnore() vkGetBufferMemoryRequirements2_CMockStopIgnore() +void vkGetBufferMemoryRequirements2_CMockStopIgnore(void); +#define vkGetBufferMemoryRequirements2_ExpectAnyArgs() vkGetBufferMemoryRequirements2_CMockExpectAnyArgs(__LINE__) +void vkGetBufferMemoryRequirements2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetBufferMemoryRequirements2_Expect(device, pInfo, pMemoryRequirements) vkGetBufferMemoryRequirements2_CMockExpect(__LINE__, device, pInfo, pMemoryRequirements) +void vkGetBufferMemoryRequirements2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (* CMOCK_vkGetBufferMemoryRequirements2_CALLBACK)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements, int cmock_num_calls); +void vkGetBufferMemoryRequirements2_AddCallback(CMOCK_vkGetBufferMemoryRequirements2_CALLBACK Callback); +void vkGetBufferMemoryRequirements2_Stub(CMOCK_vkGetBufferMemoryRequirements2_CALLBACK Callback); +#define vkGetBufferMemoryRequirements2_StubWithCallback vkGetBufferMemoryRequirements2_AddCallback +#define vkGetBufferMemoryRequirements2_ReturnThruPtr_pMemoryRequirements(pMemoryRequirements) vkGetBufferMemoryRequirements2_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, sizeof(VkMemoryRequirements2)) +#define vkGetBufferMemoryRequirements2_ReturnArrayThruPtr_pMemoryRequirements(pMemoryRequirements, cmock_len) vkGetBufferMemoryRequirements2_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, cmock_len * sizeof(*pMemoryRequirements)) +#define vkGetBufferMemoryRequirements2_ReturnMemThruPtr_pMemoryRequirements(pMemoryRequirements, cmock_size) vkGetBufferMemoryRequirements2_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, cmock_size) +void vkGetBufferMemoryRequirements2_CMockReturnMemThruPtr_pMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkMemoryRequirements2 const* pMemoryRequirements, size_t cmock_size); +#define vkGetBufferMemoryRequirements2_IgnoreArg_device() vkGetBufferMemoryRequirements2_CMockIgnoreArg_device(__LINE__) +void vkGetBufferMemoryRequirements2_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetBufferMemoryRequirements2_IgnoreArg_pInfo() vkGetBufferMemoryRequirements2_CMockIgnoreArg_pInfo(__LINE__) +void vkGetBufferMemoryRequirements2_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetBufferMemoryRequirements2_IgnoreArg_pMemoryRequirements() vkGetBufferMemoryRequirements2_CMockIgnoreArg_pMemoryRequirements(__LINE__) +void vkGetBufferMemoryRequirements2_CMockIgnoreArg_pMemoryRequirements(UNITY_LINE_TYPE cmock_line); +#define vkGetImageSparseMemoryRequirements2_Ignore() vkGetImageSparseMemoryRequirements2_CMockIgnore() +void vkGetImageSparseMemoryRequirements2_CMockIgnore(void); +#define vkGetImageSparseMemoryRequirements2_StopIgnore() vkGetImageSparseMemoryRequirements2_CMockStopIgnore() +void vkGetImageSparseMemoryRequirements2_CMockStopIgnore(void); +#define vkGetImageSparseMemoryRequirements2_ExpectAnyArgs() vkGetImageSparseMemoryRequirements2_CMockExpectAnyArgs(__LINE__) +void vkGetImageSparseMemoryRequirements2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetImageSparseMemoryRequirements2_Expect(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements) vkGetImageSparseMemoryRequirements2_CMockExpect(__LINE__, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements) +void vkGetImageSparseMemoryRequirements2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +typedef void (* CMOCK_vkGetImageSparseMemoryRequirements2_CALLBACK)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, int cmock_num_calls); +void vkGetImageSparseMemoryRequirements2_AddCallback(CMOCK_vkGetImageSparseMemoryRequirements2_CALLBACK Callback); +void vkGetImageSparseMemoryRequirements2_Stub(CMOCK_vkGetImageSparseMemoryRequirements2_CALLBACK Callback); +#define vkGetImageSparseMemoryRequirements2_StubWithCallback vkGetImageSparseMemoryRequirements2_AddCallback +#define vkGetImageSparseMemoryRequirements2_ReturnThruPtr_pSparseMemoryRequirementCount(pSparseMemoryRequirementCount) vkGetImageSparseMemoryRequirements2_CMockReturnMemThruPtr_pSparseMemoryRequirementCount(__LINE__, pSparseMemoryRequirementCount, sizeof(uint32_t)) +#define vkGetImageSparseMemoryRequirements2_ReturnArrayThruPtr_pSparseMemoryRequirementCount(pSparseMemoryRequirementCount, cmock_len) vkGetImageSparseMemoryRequirements2_CMockReturnMemThruPtr_pSparseMemoryRequirementCount(__LINE__, pSparseMemoryRequirementCount, cmock_len * sizeof(*pSparseMemoryRequirementCount)) +#define vkGetImageSparseMemoryRequirements2_ReturnMemThruPtr_pSparseMemoryRequirementCount(pSparseMemoryRequirementCount, cmock_size) vkGetImageSparseMemoryRequirements2_CMockReturnMemThruPtr_pSparseMemoryRequirementCount(__LINE__, pSparseMemoryRequirementCount, cmock_size) +void vkGetImageSparseMemoryRequirements2_CMockReturnMemThruPtr_pSparseMemoryRequirementCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pSparseMemoryRequirementCount, size_t cmock_size); +#define vkGetImageSparseMemoryRequirements2_ReturnThruPtr_pSparseMemoryRequirements(pSparseMemoryRequirements) vkGetImageSparseMemoryRequirements2_CMockReturnMemThruPtr_pSparseMemoryRequirements(__LINE__, pSparseMemoryRequirements, sizeof(VkSparseImageMemoryRequirements2)) +#define vkGetImageSparseMemoryRequirements2_ReturnArrayThruPtr_pSparseMemoryRequirements(pSparseMemoryRequirements, cmock_len) vkGetImageSparseMemoryRequirements2_CMockReturnMemThruPtr_pSparseMemoryRequirements(__LINE__, pSparseMemoryRequirements, cmock_len * sizeof(*pSparseMemoryRequirements)) +#define vkGetImageSparseMemoryRequirements2_ReturnMemThruPtr_pSparseMemoryRequirements(pSparseMemoryRequirements, cmock_size) vkGetImageSparseMemoryRequirements2_CMockReturnMemThruPtr_pSparseMemoryRequirements(__LINE__, pSparseMemoryRequirements, cmock_size) +void vkGetImageSparseMemoryRequirements2_CMockReturnMemThruPtr_pSparseMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkSparseImageMemoryRequirements2 const* pSparseMemoryRequirements, size_t cmock_size); +#define vkGetImageSparseMemoryRequirements2_IgnoreArg_device() vkGetImageSparseMemoryRequirements2_CMockIgnoreArg_device(__LINE__) +void vkGetImageSparseMemoryRequirements2_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetImageSparseMemoryRequirements2_IgnoreArg_pInfo() vkGetImageSparseMemoryRequirements2_CMockIgnoreArg_pInfo(__LINE__) +void vkGetImageSparseMemoryRequirements2_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetImageSparseMemoryRequirements2_IgnoreArg_pSparseMemoryRequirementCount() vkGetImageSparseMemoryRequirements2_CMockIgnoreArg_pSparseMemoryRequirementCount(__LINE__) +void vkGetImageSparseMemoryRequirements2_CMockIgnoreArg_pSparseMemoryRequirementCount(UNITY_LINE_TYPE cmock_line); +#define vkGetImageSparseMemoryRequirements2_IgnoreArg_pSparseMemoryRequirements() vkGetImageSparseMemoryRequirements2_CMockIgnoreArg_pSparseMemoryRequirements(__LINE__) +void vkGetImageSparseMemoryRequirements2_CMockIgnoreArg_pSparseMemoryRequirements(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceFeatures2_Ignore() vkGetPhysicalDeviceFeatures2_CMockIgnore() +void vkGetPhysicalDeviceFeatures2_CMockIgnore(void); +#define vkGetPhysicalDeviceFeatures2_StopIgnore() vkGetPhysicalDeviceFeatures2_CMockStopIgnore() +void vkGetPhysicalDeviceFeatures2_CMockStopIgnore(void); +#define vkGetPhysicalDeviceFeatures2_ExpectAnyArgs() vkGetPhysicalDeviceFeatures2_CMockExpectAnyArgs(__LINE__) +void vkGetPhysicalDeviceFeatures2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceFeatures2_Expect(physicalDevice, pFeatures) vkGetPhysicalDeviceFeatures2_CMockExpect(__LINE__, physicalDevice, pFeatures) +void vkGetPhysicalDeviceFeatures2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); +typedef void (* CMOCK_vkGetPhysicalDeviceFeatures2_CALLBACK)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures, int cmock_num_calls); +void vkGetPhysicalDeviceFeatures2_AddCallback(CMOCK_vkGetPhysicalDeviceFeatures2_CALLBACK Callback); +void vkGetPhysicalDeviceFeatures2_Stub(CMOCK_vkGetPhysicalDeviceFeatures2_CALLBACK Callback); +#define vkGetPhysicalDeviceFeatures2_StubWithCallback vkGetPhysicalDeviceFeatures2_AddCallback +#define vkGetPhysicalDeviceFeatures2_ReturnThruPtr_pFeatures(pFeatures) vkGetPhysicalDeviceFeatures2_CMockReturnMemThruPtr_pFeatures(__LINE__, pFeatures, sizeof(VkPhysicalDeviceFeatures2)) +#define vkGetPhysicalDeviceFeatures2_ReturnArrayThruPtr_pFeatures(pFeatures, cmock_len) vkGetPhysicalDeviceFeatures2_CMockReturnMemThruPtr_pFeatures(__LINE__, pFeatures, cmock_len * sizeof(*pFeatures)) +#define vkGetPhysicalDeviceFeatures2_ReturnMemThruPtr_pFeatures(pFeatures, cmock_size) vkGetPhysicalDeviceFeatures2_CMockReturnMemThruPtr_pFeatures(__LINE__, pFeatures, cmock_size) +void vkGetPhysicalDeviceFeatures2_CMockReturnMemThruPtr_pFeatures(UNITY_LINE_TYPE cmock_line, VkPhysicalDeviceFeatures2 const* pFeatures, size_t cmock_size); +#define vkGetPhysicalDeviceFeatures2_IgnoreArg_physicalDevice() vkGetPhysicalDeviceFeatures2_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceFeatures2_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceFeatures2_IgnoreArg_pFeatures() vkGetPhysicalDeviceFeatures2_CMockIgnoreArg_pFeatures(__LINE__) +void vkGetPhysicalDeviceFeatures2_CMockIgnoreArg_pFeatures(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceProperties2_Ignore() vkGetPhysicalDeviceProperties2_CMockIgnore() +void vkGetPhysicalDeviceProperties2_CMockIgnore(void); +#define vkGetPhysicalDeviceProperties2_StopIgnore() vkGetPhysicalDeviceProperties2_CMockStopIgnore() +void vkGetPhysicalDeviceProperties2_CMockStopIgnore(void); +#define vkGetPhysicalDeviceProperties2_ExpectAnyArgs() vkGetPhysicalDeviceProperties2_CMockExpectAnyArgs(__LINE__) +void vkGetPhysicalDeviceProperties2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceProperties2_Expect(physicalDevice, pProperties) vkGetPhysicalDeviceProperties2_CMockExpect(__LINE__, physicalDevice, pProperties) +void vkGetPhysicalDeviceProperties2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); +typedef void (* CMOCK_vkGetPhysicalDeviceProperties2_CALLBACK)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties, int cmock_num_calls); +void vkGetPhysicalDeviceProperties2_AddCallback(CMOCK_vkGetPhysicalDeviceProperties2_CALLBACK Callback); +void vkGetPhysicalDeviceProperties2_Stub(CMOCK_vkGetPhysicalDeviceProperties2_CALLBACK Callback); +#define vkGetPhysicalDeviceProperties2_StubWithCallback vkGetPhysicalDeviceProperties2_AddCallback +#define vkGetPhysicalDeviceProperties2_ReturnThruPtr_pProperties(pProperties) vkGetPhysicalDeviceProperties2_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, sizeof(VkPhysicalDeviceProperties2)) +#define vkGetPhysicalDeviceProperties2_ReturnArrayThruPtr_pProperties(pProperties, cmock_len) vkGetPhysicalDeviceProperties2_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_len * sizeof(*pProperties)) +#define vkGetPhysicalDeviceProperties2_ReturnMemThruPtr_pProperties(pProperties, cmock_size) vkGetPhysicalDeviceProperties2_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_size) +void vkGetPhysicalDeviceProperties2_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkPhysicalDeviceProperties2 const* pProperties, size_t cmock_size); +#define vkGetPhysicalDeviceProperties2_IgnoreArg_physicalDevice() vkGetPhysicalDeviceProperties2_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceProperties2_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceProperties2_IgnoreArg_pProperties() vkGetPhysicalDeviceProperties2_CMockIgnoreArg_pProperties(__LINE__) +void vkGetPhysicalDeviceProperties2_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceFormatProperties2_Ignore() vkGetPhysicalDeviceFormatProperties2_CMockIgnore() +void vkGetPhysicalDeviceFormatProperties2_CMockIgnore(void); +#define vkGetPhysicalDeviceFormatProperties2_StopIgnore() vkGetPhysicalDeviceFormatProperties2_CMockStopIgnore() +void vkGetPhysicalDeviceFormatProperties2_CMockStopIgnore(void); +#define vkGetPhysicalDeviceFormatProperties2_ExpectAnyArgs() vkGetPhysicalDeviceFormatProperties2_CMockExpectAnyArgs(__LINE__) +void vkGetPhysicalDeviceFormatProperties2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceFormatProperties2_Expect(physicalDevice, format, pFormatProperties) vkGetPhysicalDeviceFormatProperties2_CMockExpect(__LINE__, physicalDevice, format, pFormatProperties) +void vkGetPhysicalDeviceFormatProperties2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); +typedef void (* CMOCK_vkGetPhysicalDeviceFormatProperties2_CALLBACK)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties, int cmock_num_calls); +void vkGetPhysicalDeviceFormatProperties2_AddCallback(CMOCK_vkGetPhysicalDeviceFormatProperties2_CALLBACK Callback); +void vkGetPhysicalDeviceFormatProperties2_Stub(CMOCK_vkGetPhysicalDeviceFormatProperties2_CALLBACK Callback); +#define vkGetPhysicalDeviceFormatProperties2_StubWithCallback vkGetPhysicalDeviceFormatProperties2_AddCallback +#define vkGetPhysicalDeviceFormatProperties2_ReturnThruPtr_pFormatProperties(pFormatProperties) vkGetPhysicalDeviceFormatProperties2_CMockReturnMemThruPtr_pFormatProperties(__LINE__, pFormatProperties, sizeof(VkFormatProperties2)) +#define vkGetPhysicalDeviceFormatProperties2_ReturnArrayThruPtr_pFormatProperties(pFormatProperties, cmock_len) vkGetPhysicalDeviceFormatProperties2_CMockReturnMemThruPtr_pFormatProperties(__LINE__, pFormatProperties, cmock_len * sizeof(*pFormatProperties)) +#define vkGetPhysicalDeviceFormatProperties2_ReturnMemThruPtr_pFormatProperties(pFormatProperties, cmock_size) vkGetPhysicalDeviceFormatProperties2_CMockReturnMemThruPtr_pFormatProperties(__LINE__, pFormatProperties, cmock_size) +void vkGetPhysicalDeviceFormatProperties2_CMockReturnMemThruPtr_pFormatProperties(UNITY_LINE_TYPE cmock_line, VkFormatProperties2 const* pFormatProperties, size_t cmock_size); +#define vkGetPhysicalDeviceFormatProperties2_IgnoreArg_physicalDevice() vkGetPhysicalDeviceFormatProperties2_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceFormatProperties2_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceFormatProperties2_IgnoreArg_format() vkGetPhysicalDeviceFormatProperties2_CMockIgnoreArg_format(__LINE__) +void vkGetPhysicalDeviceFormatProperties2_CMockIgnoreArg_format(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceFormatProperties2_IgnoreArg_pFormatProperties() vkGetPhysicalDeviceFormatProperties2_CMockIgnoreArg_pFormatProperties(__LINE__) +void vkGetPhysicalDeviceFormatProperties2_CMockIgnoreArg_pFormatProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceImageFormatProperties2_IgnoreAndReturn(cmock_retval) vkGetPhysicalDeviceImageFormatProperties2_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceImageFormatProperties2_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceImageFormatProperties2_StopIgnore() vkGetPhysicalDeviceImageFormatProperties2_CMockStopIgnore() +void vkGetPhysicalDeviceImageFormatProperties2_CMockStopIgnore(void); +#define vkGetPhysicalDeviceImageFormatProperties2_ExpectAnyArgsAndReturn(cmock_retval) vkGetPhysicalDeviceImageFormatProperties2_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceImageFormatProperties2_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceImageFormatProperties2_ExpectAndReturn(physicalDevice, pImageFormatInfo, pImageFormatProperties, cmock_retval) vkGetPhysicalDeviceImageFormatProperties2_CMockExpectAndReturn(__LINE__, physicalDevice, pImageFormatInfo, pImageFormatProperties, cmock_retval) +void vkGetPhysicalDeviceImageFormatProperties2_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPhysicalDeviceImageFormatProperties2_CALLBACK)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties, int cmock_num_calls); +void vkGetPhysicalDeviceImageFormatProperties2_AddCallback(CMOCK_vkGetPhysicalDeviceImageFormatProperties2_CALLBACK Callback); +void vkGetPhysicalDeviceImageFormatProperties2_Stub(CMOCK_vkGetPhysicalDeviceImageFormatProperties2_CALLBACK Callback); +#define vkGetPhysicalDeviceImageFormatProperties2_StubWithCallback vkGetPhysicalDeviceImageFormatProperties2_AddCallback +#define vkGetPhysicalDeviceImageFormatProperties2_ReturnThruPtr_pImageFormatProperties(pImageFormatProperties) vkGetPhysicalDeviceImageFormatProperties2_CMockReturnMemThruPtr_pImageFormatProperties(__LINE__, pImageFormatProperties, sizeof(VkImageFormatProperties2)) +#define vkGetPhysicalDeviceImageFormatProperties2_ReturnArrayThruPtr_pImageFormatProperties(pImageFormatProperties, cmock_len) vkGetPhysicalDeviceImageFormatProperties2_CMockReturnMemThruPtr_pImageFormatProperties(__LINE__, pImageFormatProperties, cmock_len * sizeof(*pImageFormatProperties)) +#define vkGetPhysicalDeviceImageFormatProperties2_ReturnMemThruPtr_pImageFormatProperties(pImageFormatProperties, cmock_size) vkGetPhysicalDeviceImageFormatProperties2_CMockReturnMemThruPtr_pImageFormatProperties(__LINE__, pImageFormatProperties, cmock_size) +void vkGetPhysicalDeviceImageFormatProperties2_CMockReturnMemThruPtr_pImageFormatProperties(UNITY_LINE_TYPE cmock_line, VkImageFormatProperties2 const* pImageFormatProperties, size_t cmock_size); +#define vkGetPhysicalDeviceImageFormatProperties2_IgnoreArg_physicalDevice() vkGetPhysicalDeviceImageFormatProperties2_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceImageFormatProperties2_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceImageFormatProperties2_IgnoreArg_pImageFormatInfo() vkGetPhysicalDeviceImageFormatProperties2_CMockIgnoreArg_pImageFormatInfo(__LINE__) +void vkGetPhysicalDeviceImageFormatProperties2_CMockIgnoreArg_pImageFormatInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceImageFormatProperties2_IgnoreArg_pImageFormatProperties() vkGetPhysicalDeviceImageFormatProperties2_CMockIgnoreArg_pImageFormatProperties(__LINE__) +void vkGetPhysicalDeviceImageFormatProperties2_CMockIgnoreArg_pImageFormatProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceQueueFamilyProperties2_Ignore() vkGetPhysicalDeviceQueueFamilyProperties2_CMockIgnore() +void vkGetPhysicalDeviceQueueFamilyProperties2_CMockIgnore(void); +#define vkGetPhysicalDeviceQueueFamilyProperties2_StopIgnore() vkGetPhysicalDeviceQueueFamilyProperties2_CMockStopIgnore() +void vkGetPhysicalDeviceQueueFamilyProperties2_CMockStopIgnore(void); +#define vkGetPhysicalDeviceQueueFamilyProperties2_ExpectAnyArgs() vkGetPhysicalDeviceQueueFamilyProperties2_CMockExpectAnyArgs(__LINE__) +void vkGetPhysicalDeviceQueueFamilyProperties2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceQueueFamilyProperties2_Expect(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties) vkGetPhysicalDeviceQueueFamilyProperties2_CMockExpect(__LINE__, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties) +void vkGetPhysicalDeviceQueueFamilyProperties2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); +typedef void (* CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2_CALLBACK)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties, int cmock_num_calls); +void vkGetPhysicalDeviceQueueFamilyProperties2_AddCallback(CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2_CALLBACK Callback); +void vkGetPhysicalDeviceQueueFamilyProperties2_Stub(CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2_CALLBACK Callback); +#define vkGetPhysicalDeviceQueueFamilyProperties2_StubWithCallback vkGetPhysicalDeviceQueueFamilyProperties2_AddCallback +#define vkGetPhysicalDeviceQueueFamilyProperties2_ReturnThruPtr_pQueueFamilyPropertyCount(pQueueFamilyPropertyCount) vkGetPhysicalDeviceQueueFamilyProperties2_CMockReturnMemThruPtr_pQueueFamilyPropertyCount(__LINE__, pQueueFamilyPropertyCount, sizeof(uint32_t)) +#define vkGetPhysicalDeviceQueueFamilyProperties2_ReturnArrayThruPtr_pQueueFamilyPropertyCount(pQueueFamilyPropertyCount, cmock_len) vkGetPhysicalDeviceQueueFamilyProperties2_CMockReturnMemThruPtr_pQueueFamilyPropertyCount(__LINE__, pQueueFamilyPropertyCount, cmock_len * sizeof(*pQueueFamilyPropertyCount)) +#define vkGetPhysicalDeviceQueueFamilyProperties2_ReturnMemThruPtr_pQueueFamilyPropertyCount(pQueueFamilyPropertyCount, cmock_size) vkGetPhysicalDeviceQueueFamilyProperties2_CMockReturnMemThruPtr_pQueueFamilyPropertyCount(__LINE__, pQueueFamilyPropertyCount, cmock_size) +void vkGetPhysicalDeviceQueueFamilyProperties2_CMockReturnMemThruPtr_pQueueFamilyPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pQueueFamilyPropertyCount, size_t cmock_size); +#define vkGetPhysicalDeviceQueueFamilyProperties2_ReturnThruPtr_pQueueFamilyProperties(pQueueFamilyProperties) vkGetPhysicalDeviceQueueFamilyProperties2_CMockReturnMemThruPtr_pQueueFamilyProperties(__LINE__, pQueueFamilyProperties, sizeof(VkQueueFamilyProperties2)) +#define vkGetPhysicalDeviceQueueFamilyProperties2_ReturnArrayThruPtr_pQueueFamilyProperties(pQueueFamilyProperties, cmock_len) vkGetPhysicalDeviceQueueFamilyProperties2_CMockReturnMemThruPtr_pQueueFamilyProperties(__LINE__, pQueueFamilyProperties, cmock_len * sizeof(*pQueueFamilyProperties)) +#define vkGetPhysicalDeviceQueueFamilyProperties2_ReturnMemThruPtr_pQueueFamilyProperties(pQueueFamilyProperties, cmock_size) vkGetPhysicalDeviceQueueFamilyProperties2_CMockReturnMemThruPtr_pQueueFamilyProperties(__LINE__, pQueueFamilyProperties, cmock_size) +void vkGetPhysicalDeviceQueueFamilyProperties2_CMockReturnMemThruPtr_pQueueFamilyProperties(UNITY_LINE_TYPE cmock_line, VkQueueFamilyProperties2 const* pQueueFamilyProperties, size_t cmock_size); +#define vkGetPhysicalDeviceQueueFamilyProperties2_IgnoreArg_physicalDevice() vkGetPhysicalDeviceQueueFamilyProperties2_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceQueueFamilyProperties2_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceQueueFamilyProperties2_IgnoreArg_pQueueFamilyPropertyCount() vkGetPhysicalDeviceQueueFamilyProperties2_CMockIgnoreArg_pQueueFamilyPropertyCount(__LINE__) +void vkGetPhysicalDeviceQueueFamilyProperties2_CMockIgnoreArg_pQueueFamilyPropertyCount(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceQueueFamilyProperties2_IgnoreArg_pQueueFamilyProperties() vkGetPhysicalDeviceQueueFamilyProperties2_CMockIgnoreArg_pQueueFamilyProperties(__LINE__) +void vkGetPhysicalDeviceQueueFamilyProperties2_CMockIgnoreArg_pQueueFamilyProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceMemoryProperties2_Ignore() vkGetPhysicalDeviceMemoryProperties2_CMockIgnore() +void vkGetPhysicalDeviceMemoryProperties2_CMockIgnore(void); +#define vkGetPhysicalDeviceMemoryProperties2_StopIgnore() vkGetPhysicalDeviceMemoryProperties2_CMockStopIgnore() +void vkGetPhysicalDeviceMemoryProperties2_CMockStopIgnore(void); +#define vkGetPhysicalDeviceMemoryProperties2_ExpectAnyArgs() vkGetPhysicalDeviceMemoryProperties2_CMockExpectAnyArgs(__LINE__) +void vkGetPhysicalDeviceMemoryProperties2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceMemoryProperties2_Expect(physicalDevice, pMemoryProperties) vkGetPhysicalDeviceMemoryProperties2_CMockExpect(__LINE__, physicalDevice, pMemoryProperties) +void vkGetPhysicalDeviceMemoryProperties2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); +typedef void (* CMOCK_vkGetPhysicalDeviceMemoryProperties2_CALLBACK)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties, int cmock_num_calls); +void vkGetPhysicalDeviceMemoryProperties2_AddCallback(CMOCK_vkGetPhysicalDeviceMemoryProperties2_CALLBACK Callback); +void vkGetPhysicalDeviceMemoryProperties2_Stub(CMOCK_vkGetPhysicalDeviceMemoryProperties2_CALLBACK Callback); +#define vkGetPhysicalDeviceMemoryProperties2_StubWithCallback vkGetPhysicalDeviceMemoryProperties2_AddCallback +#define vkGetPhysicalDeviceMemoryProperties2_ReturnThruPtr_pMemoryProperties(pMemoryProperties) vkGetPhysicalDeviceMemoryProperties2_CMockReturnMemThruPtr_pMemoryProperties(__LINE__, pMemoryProperties, sizeof(VkPhysicalDeviceMemoryProperties2)) +#define vkGetPhysicalDeviceMemoryProperties2_ReturnArrayThruPtr_pMemoryProperties(pMemoryProperties, cmock_len) vkGetPhysicalDeviceMemoryProperties2_CMockReturnMemThruPtr_pMemoryProperties(__LINE__, pMemoryProperties, cmock_len * sizeof(*pMemoryProperties)) +#define vkGetPhysicalDeviceMemoryProperties2_ReturnMemThruPtr_pMemoryProperties(pMemoryProperties, cmock_size) vkGetPhysicalDeviceMemoryProperties2_CMockReturnMemThruPtr_pMemoryProperties(__LINE__, pMemoryProperties, cmock_size) +void vkGetPhysicalDeviceMemoryProperties2_CMockReturnMemThruPtr_pMemoryProperties(UNITY_LINE_TYPE cmock_line, VkPhysicalDeviceMemoryProperties2 const* pMemoryProperties, size_t cmock_size); +#define vkGetPhysicalDeviceMemoryProperties2_IgnoreArg_physicalDevice() vkGetPhysicalDeviceMemoryProperties2_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceMemoryProperties2_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceMemoryProperties2_IgnoreArg_pMemoryProperties() vkGetPhysicalDeviceMemoryProperties2_CMockIgnoreArg_pMemoryProperties(__LINE__) +void vkGetPhysicalDeviceMemoryProperties2_CMockIgnoreArg_pMemoryProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSparseImageFormatProperties2_Ignore() vkGetPhysicalDeviceSparseImageFormatProperties2_CMockIgnore() +void vkGetPhysicalDeviceSparseImageFormatProperties2_CMockIgnore(void); +#define vkGetPhysicalDeviceSparseImageFormatProperties2_StopIgnore() vkGetPhysicalDeviceSparseImageFormatProperties2_CMockStopIgnore() +void vkGetPhysicalDeviceSparseImageFormatProperties2_CMockStopIgnore(void); +#define vkGetPhysicalDeviceSparseImageFormatProperties2_ExpectAnyArgs() vkGetPhysicalDeviceSparseImageFormatProperties2_CMockExpectAnyArgs(__LINE__) +void vkGetPhysicalDeviceSparseImageFormatProperties2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSparseImageFormatProperties2_Expect(physicalDevice, pFormatInfo, pPropertyCount, pProperties) vkGetPhysicalDeviceSparseImageFormatProperties2_CMockExpect(__LINE__, physicalDevice, pFormatInfo, pPropertyCount, pProperties) +void vkGetPhysicalDeviceSparseImageFormatProperties2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); +typedef void (* CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2_CALLBACK)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties, int cmock_num_calls); +void vkGetPhysicalDeviceSparseImageFormatProperties2_AddCallback(CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2_CALLBACK Callback); +void vkGetPhysicalDeviceSparseImageFormatProperties2_Stub(CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2_CALLBACK Callback); +#define vkGetPhysicalDeviceSparseImageFormatProperties2_StubWithCallback vkGetPhysicalDeviceSparseImageFormatProperties2_AddCallback +#define vkGetPhysicalDeviceSparseImageFormatProperties2_ReturnThruPtr_pPropertyCount(pPropertyCount) vkGetPhysicalDeviceSparseImageFormatProperties2_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, sizeof(uint32_t)) +#define vkGetPhysicalDeviceSparseImageFormatProperties2_ReturnArrayThruPtr_pPropertyCount(pPropertyCount, cmock_len) vkGetPhysicalDeviceSparseImageFormatProperties2_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, cmock_len * sizeof(*pPropertyCount)) +#define vkGetPhysicalDeviceSparseImageFormatProperties2_ReturnMemThruPtr_pPropertyCount(pPropertyCount, cmock_size) vkGetPhysicalDeviceSparseImageFormatProperties2_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, cmock_size) +void vkGetPhysicalDeviceSparseImageFormatProperties2_CMockReturnMemThruPtr_pPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPropertyCount, size_t cmock_size); +#define vkGetPhysicalDeviceSparseImageFormatProperties2_ReturnThruPtr_pProperties(pProperties) vkGetPhysicalDeviceSparseImageFormatProperties2_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, sizeof(VkSparseImageFormatProperties2)) +#define vkGetPhysicalDeviceSparseImageFormatProperties2_ReturnArrayThruPtr_pProperties(pProperties, cmock_len) vkGetPhysicalDeviceSparseImageFormatProperties2_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_len * sizeof(*pProperties)) +#define vkGetPhysicalDeviceSparseImageFormatProperties2_ReturnMemThruPtr_pProperties(pProperties, cmock_size) vkGetPhysicalDeviceSparseImageFormatProperties2_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_size) +void vkGetPhysicalDeviceSparseImageFormatProperties2_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkSparseImageFormatProperties2 const* pProperties, size_t cmock_size); +#define vkGetPhysicalDeviceSparseImageFormatProperties2_IgnoreArg_physicalDevice() vkGetPhysicalDeviceSparseImageFormatProperties2_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceSparseImageFormatProperties2_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSparseImageFormatProperties2_IgnoreArg_pFormatInfo() vkGetPhysicalDeviceSparseImageFormatProperties2_CMockIgnoreArg_pFormatInfo(__LINE__) +void vkGetPhysicalDeviceSparseImageFormatProperties2_CMockIgnoreArg_pFormatInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSparseImageFormatProperties2_IgnoreArg_pPropertyCount() vkGetPhysicalDeviceSparseImageFormatProperties2_CMockIgnoreArg_pPropertyCount(__LINE__) +void vkGetPhysicalDeviceSparseImageFormatProperties2_CMockIgnoreArg_pPropertyCount(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSparseImageFormatProperties2_IgnoreArg_pProperties() vkGetPhysicalDeviceSparseImageFormatProperties2_CMockIgnoreArg_pProperties(__LINE__) +void vkGetPhysicalDeviceSparseImageFormatProperties2_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line); +#define vkTrimCommandPool_Ignore() vkTrimCommandPool_CMockIgnore() +void vkTrimCommandPool_CMockIgnore(void); +#define vkTrimCommandPool_StopIgnore() vkTrimCommandPool_CMockStopIgnore() +void vkTrimCommandPool_CMockStopIgnore(void); +#define vkTrimCommandPool_ExpectAnyArgs() vkTrimCommandPool_CMockExpectAnyArgs(__LINE__) +void vkTrimCommandPool_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkTrimCommandPool_Expect(device, commandPool, flags) vkTrimCommandPool_CMockExpect(__LINE__, device, commandPool, flags) +void vkTrimCommandPool_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); +typedef void (* CMOCK_vkTrimCommandPool_CALLBACK)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags, int cmock_num_calls); +void vkTrimCommandPool_AddCallback(CMOCK_vkTrimCommandPool_CALLBACK Callback); +void vkTrimCommandPool_Stub(CMOCK_vkTrimCommandPool_CALLBACK Callback); +#define vkTrimCommandPool_StubWithCallback vkTrimCommandPool_AddCallback +#define vkTrimCommandPool_IgnoreArg_device() vkTrimCommandPool_CMockIgnoreArg_device(__LINE__) +void vkTrimCommandPool_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkTrimCommandPool_IgnoreArg_commandPool() vkTrimCommandPool_CMockIgnoreArg_commandPool(__LINE__) +void vkTrimCommandPool_CMockIgnoreArg_commandPool(UNITY_LINE_TYPE cmock_line); +#define vkTrimCommandPool_IgnoreArg_flags() vkTrimCommandPool_CMockIgnoreArg_flags(__LINE__) +void vkTrimCommandPool_CMockIgnoreArg_flags(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceQueue2_Ignore() vkGetDeviceQueue2_CMockIgnore() +void vkGetDeviceQueue2_CMockIgnore(void); +#define vkGetDeviceQueue2_StopIgnore() vkGetDeviceQueue2_CMockStopIgnore() +void vkGetDeviceQueue2_CMockStopIgnore(void); +#define vkGetDeviceQueue2_ExpectAnyArgs() vkGetDeviceQueue2_CMockExpectAnyArgs(__LINE__) +void vkGetDeviceQueue2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceQueue2_Expect(device, pQueueInfo, pQueue) vkGetDeviceQueue2_CMockExpect(__LINE__, device, pQueueInfo, pQueue) +void vkGetDeviceQueue2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue); +typedef void (* CMOCK_vkGetDeviceQueue2_CALLBACK)(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue, int cmock_num_calls); +void vkGetDeviceQueue2_AddCallback(CMOCK_vkGetDeviceQueue2_CALLBACK Callback); +void vkGetDeviceQueue2_Stub(CMOCK_vkGetDeviceQueue2_CALLBACK Callback); +#define vkGetDeviceQueue2_StubWithCallback vkGetDeviceQueue2_AddCallback +#define vkGetDeviceQueue2_ReturnThruPtr_pQueue(pQueue) vkGetDeviceQueue2_CMockReturnMemThruPtr_pQueue(__LINE__, pQueue, sizeof(VkQueue)) +#define vkGetDeviceQueue2_ReturnArrayThruPtr_pQueue(pQueue, cmock_len) vkGetDeviceQueue2_CMockReturnMemThruPtr_pQueue(__LINE__, pQueue, cmock_len * sizeof(*pQueue)) +#define vkGetDeviceQueue2_ReturnMemThruPtr_pQueue(pQueue, cmock_size) vkGetDeviceQueue2_CMockReturnMemThruPtr_pQueue(__LINE__, pQueue, cmock_size) +void vkGetDeviceQueue2_CMockReturnMemThruPtr_pQueue(UNITY_LINE_TYPE cmock_line, VkQueue const* pQueue, size_t cmock_size); +#define vkGetDeviceQueue2_IgnoreArg_device() vkGetDeviceQueue2_CMockIgnoreArg_device(__LINE__) +void vkGetDeviceQueue2_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceQueue2_IgnoreArg_pQueueInfo() vkGetDeviceQueue2_CMockIgnoreArg_pQueueInfo(__LINE__) +void vkGetDeviceQueue2_CMockIgnoreArg_pQueueInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceQueue2_IgnoreArg_pQueue() vkGetDeviceQueue2_CMockIgnoreArg_pQueue(__LINE__) +void vkGetDeviceQueue2_CMockIgnoreArg_pQueue(UNITY_LINE_TYPE cmock_line); +#define vkCreateSamplerYcbcrConversion_IgnoreAndReturn(cmock_retval) vkCreateSamplerYcbcrConversion_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateSamplerYcbcrConversion_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateSamplerYcbcrConversion_StopIgnore() vkCreateSamplerYcbcrConversion_CMockStopIgnore() +void vkCreateSamplerYcbcrConversion_CMockStopIgnore(void); +#define vkCreateSamplerYcbcrConversion_ExpectAnyArgsAndReturn(cmock_retval) vkCreateSamplerYcbcrConversion_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateSamplerYcbcrConversion_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateSamplerYcbcrConversion_ExpectAndReturn(device, pCreateInfo, pAllocator, pYcbcrConversion, cmock_retval) vkCreateSamplerYcbcrConversion_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pYcbcrConversion, cmock_retval) +void vkCreateSamplerYcbcrConversion_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateSamplerYcbcrConversion_CALLBACK)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion, int cmock_num_calls); +void vkCreateSamplerYcbcrConversion_AddCallback(CMOCK_vkCreateSamplerYcbcrConversion_CALLBACK Callback); +void vkCreateSamplerYcbcrConversion_Stub(CMOCK_vkCreateSamplerYcbcrConversion_CALLBACK Callback); +#define vkCreateSamplerYcbcrConversion_StubWithCallback vkCreateSamplerYcbcrConversion_AddCallback +#define vkCreateSamplerYcbcrConversion_ReturnThruPtr_pYcbcrConversion(pYcbcrConversion) vkCreateSamplerYcbcrConversion_CMockReturnMemThruPtr_pYcbcrConversion(__LINE__, pYcbcrConversion, sizeof(VkSamplerYcbcrConversion)) +#define vkCreateSamplerYcbcrConversion_ReturnArrayThruPtr_pYcbcrConversion(pYcbcrConversion, cmock_len) vkCreateSamplerYcbcrConversion_CMockReturnMemThruPtr_pYcbcrConversion(__LINE__, pYcbcrConversion, cmock_len * sizeof(*pYcbcrConversion)) +#define vkCreateSamplerYcbcrConversion_ReturnMemThruPtr_pYcbcrConversion(pYcbcrConversion, cmock_size) vkCreateSamplerYcbcrConversion_CMockReturnMemThruPtr_pYcbcrConversion(__LINE__, pYcbcrConversion, cmock_size) +void vkCreateSamplerYcbcrConversion_CMockReturnMemThruPtr_pYcbcrConversion(UNITY_LINE_TYPE cmock_line, VkSamplerYcbcrConversion const* pYcbcrConversion, size_t cmock_size); +#define vkCreateSamplerYcbcrConversion_IgnoreArg_device() vkCreateSamplerYcbcrConversion_CMockIgnoreArg_device(__LINE__) +void vkCreateSamplerYcbcrConversion_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateSamplerYcbcrConversion_IgnoreArg_pCreateInfo() vkCreateSamplerYcbcrConversion_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateSamplerYcbcrConversion_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateSamplerYcbcrConversion_IgnoreArg_pAllocator() vkCreateSamplerYcbcrConversion_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateSamplerYcbcrConversion_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateSamplerYcbcrConversion_IgnoreArg_pYcbcrConversion() vkCreateSamplerYcbcrConversion_CMockIgnoreArg_pYcbcrConversion(__LINE__) +void vkCreateSamplerYcbcrConversion_CMockIgnoreArg_pYcbcrConversion(UNITY_LINE_TYPE cmock_line); +#define vkDestroySamplerYcbcrConversion_Ignore() vkDestroySamplerYcbcrConversion_CMockIgnore() +void vkDestroySamplerYcbcrConversion_CMockIgnore(void); +#define vkDestroySamplerYcbcrConversion_StopIgnore() vkDestroySamplerYcbcrConversion_CMockStopIgnore() +void vkDestroySamplerYcbcrConversion_CMockStopIgnore(void); +#define vkDestroySamplerYcbcrConversion_ExpectAnyArgs() vkDestroySamplerYcbcrConversion_CMockExpectAnyArgs(__LINE__) +void vkDestroySamplerYcbcrConversion_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroySamplerYcbcrConversion_Expect(device, ycbcrConversion, pAllocator) vkDestroySamplerYcbcrConversion_CMockExpect(__LINE__, device, ycbcrConversion, pAllocator) +void vkDestroySamplerYcbcrConversion_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroySamplerYcbcrConversion_CALLBACK)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroySamplerYcbcrConversion_AddCallback(CMOCK_vkDestroySamplerYcbcrConversion_CALLBACK Callback); +void vkDestroySamplerYcbcrConversion_Stub(CMOCK_vkDestroySamplerYcbcrConversion_CALLBACK Callback); +#define vkDestroySamplerYcbcrConversion_StubWithCallback vkDestroySamplerYcbcrConversion_AddCallback +#define vkDestroySamplerYcbcrConversion_IgnoreArg_device() vkDestroySamplerYcbcrConversion_CMockIgnoreArg_device(__LINE__) +void vkDestroySamplerYcbcrConversion_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroySamplerYcbcrConversion_IgnoreArg_ycbcrConversion() vkDestroySamplerYcbcrConversion_CMockIgnoreArg_ycbcrConversion(__LINE__) +void vkDestroySamplerYcbcrConversion_CMockIgnoreArg_ycbcrConversion(UNITY_LINE_TYPE cmock_line); +#define vkDestroySamplerYcbcrConversion_IgnoreArg_pAllocator() vkDestroySamplerYcbcrConversion_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroySamplerYcbcrConversion_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateDescriptorUpdateTemplate_IgnoreAndReturn(cmock_retval) vkCreateDescriptorUpdateTemplate_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateDescriptorUpdateTemplate_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateDescriptorUpdateTemplate_StopIgnore() vkCreateDescriptorUpdateTemplate_CMockStopIgnore() +void vkCreateDescriptorUpdateTemplate_CMockStopIgnore(void); +#define vkCreateDescriptorUpdateTemplate_ExpectAnyArgsAndReturn(cmock_retval) vkCreateDescriptorUpdateTemplate_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateDescriptorUpdateTemplate_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateDescriptorUpdateTemplate_ExpectAndReturn(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, cmock_retval) vkCreateDescriptorUpdateTemplate_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, cmock_retval) +void vkCreateDescriptorUpdateTemplate_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateDescriptorUpdateTemplate_CALLBACK)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate, int cmock_num_calls); +void vkCreateDescriptorUpdateTemplate_AddCallback(CMOCK_vkCreateDescriptorUpdateTemplate_CALLBACK Callback); +void vkCreateDescriptorUpdateTemplate_Stub(CMOCK_vkCreateDescriptorUpdateTemplate_CALLBACK Callback); +#define vkCreateDescriptorUpdateTemplate_StubWithCallback vkCreateDescriptorUpdateTemplate_AddCallback +#define vkCreateDescriptorUpdateTemplate_ReturnThruPtr_pDescriptorUpdateTemplate(pDescriptorUpdateTemplate) vkCreateDescriptorUpdateTemplate_CMockReturnMemThruPtr_pDescriptorUpdateTemplate(__LINE__, pDescriptorUpdateTemplate, sizeof(VkDescriptorUpdateTemplate)) +#define vkCreateDescriptorUpdateTemplate_ReturnArrayThruPtr_pDescriptorUpdateTemplate(pDescriptorUpdateTemplate, cmock_len) vkCreateDescriptorUpdateTemplate_CMockReturnMemThruPtr_pDescriptorUpdateTemplate(__LINE__, pDescriptorUpdateTemplate, cmock_len * sizeof(*pDescriptorUpdateTemplate)) +#define vkCreateDescriptorUpdateTemplate_ReturnMemThruPtr_pDescriptorUpdateTemplate(pDescriptorUpdateTemplate, cmock_size) vkCreateDescriptorUpdateTemplate_CMockReturnMemThruPtr_pDescriptorUpdateTemplate(__LINE__, pDescriptorUpdateTemplate, cmock_size) +void vkCreateDescriptorUpdateTemplate_CMockReturnMemThruPtr_pDescriptorUpdateTemplate(UNITY_LINE_TYPE cmock_line, VkDescriptorUpdateTemplate const* pDescriptorUpdateTemplate, size_t cmock_size); +#define vkCreateDescriptorUpdateTemplate_IgnoreArg_device() vkCreateDescriptorUpdateTemplate_CMockIgnoreArg_device(__LINE__) +void vkCreateDescriptorUpdateTemplate_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateDescriptorUpdateTemplate_IgnoreArg_pCreateInfo() vkCreateDescriptorUpdateTemplate_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateDescriptorUpdateTemplate_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateDescriptorUpdateTemplate_IgnoreArg_pAllocator() vkCreateDescriptorUpdateTemplate_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateDescriptorUpdateTemplate_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateDescriptorUpdateTemplate_IgnoreArg_pDescriptorUpdateTemplate() vkCreateDescriptorUpdateTemplate_CMockIgnoreArg_pDescriptorUpdateTemplate(__LINE__) +void vkCreateDescriptorUpdateTemplate_CMockIgnoreArg_pDescriptorUpdateTemplate(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDescriptorUpdateTemplate_Ignore() vkDestroyDescriptorUpdateTemplate_CMockIgnore() +void vkDestroyDescriptorUpdateTemplate_CMockIgnore(void); +#define vkDestroyDescriptorUpdateTemplate_StopIgnore() vkDestroyDescriptorUpdateTemplate_CMockStopIgnore() +void vkDestroyDescriptorUpdateTemplate_CMockStopIgnore(void); +#define vkDestroyDescriptorUpdateTemplate_ExpectAnyArgs() vkDestroyDescriptorUpdateTemplate_CMockExpectAnyArgs(__LINE__) +void vkDestroyDescriptorUpdateTemplate_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDescriptorUpdateTemplate_Expect(device, descriptorUpdateTemplate, pAllocator) vkDestroyDescriptorUpdateTemplate_CMockExpect(__LINE__, device, descriptorUpdateTemplate, pAllocator) +void vkDestroyDescriptorUpdateTemplate_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyDescriptorUpdateTemplate_CALLBACK)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyDescriptorUpdateTemplate_AddCallback(CMOCK_vkDestroyDescriptorUpdateTemplate_CALLBACK Callback); +void vkDestroyDescriptorUpdateTemplate_Stub(CMOCK_vkDestroyDescriptorUpdateTemplate_CALLBACK Callback); +#define vkDestroyDescriptorUpdateTemplate_StubWithCallback vkDestroyDescriptorUpdateTemplate_AddCallback +#define vkDestroyDescriptorUpdateTemplate_IgnoreArg_device() vkDestroyDescriptorUpdateTemplate_CMockIgnoreArg_device(__LINE__) +void vkDestroyDescriptorUpdateTemplate_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDescriptorUpdateTemplate_IgnoreArg_descriptorUpdateTemplate() vkDestroyDescriptorUpdateTemplate_CMockIgnoreArg_descriptorUpdateTemplate(__LINE__) +void vkDestroyDescriptorUpdateTemplate_CMockIgnoreArg_descriptorUpdateTemplate(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDescriptorUpdateTemplate_IgnoreArg_pAllocator() vkDestroyDescriptorUpdateTemplate_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyDescriptorUpdateTemplate_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkUpdateDescriptorSetWithTemplate_Ignore() vkUpdateDescriptorSetWithTemplate_CMockIgnore() +void vkUpdateDescriptorSetWithTemplate_CMockIgnore(void); +#define vkUpdateDescriptorSetWithTemplate_StopIgnore() vkUpdateDescriptorSetWithTemplate_CMockStopIgnore() +void vkUpdateDescriptorSetWithTemplate_CMockStopIgnore(void); +#define vkUpdateDescriptorSetWithTemplate_ExpectAnyArgs() vkUpdateDescriptorSetWithTemplate_CMockExpectAnyArgs(__LINE__) +void vkUpdateDescriptorSetWithTemplate_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkUpdateDescriptorSetWithTemplate_Expect(device, descriptorSet, descriptorUpdateTemplate, pData) vkUpdateDescriptorSetWithTemplate_CMockExpect(__LINE__, device, descriptorSet, descriptorUpdateTemplate, pData) +void vkUpdateDescriptorSetWithTemplate_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); +typedef void (* CMOCK_vkUpdateDescriptorSetWithTemplate_CALLBACK)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, int cmock_num_calls); +void vkUpdateDescriptorSetWithTemplate_AddCallback(CMOCK_vkUpdateDescriptorSetWithTemplate_CALLBACK Callback); +void vkUpdateDescriptorSetWithTemplate_Stub(CMOCK_vkUpdateDescriptorSetWithTemplate_CALLBACK Callback); +#define vkUpdateDescriptorSetWithTemplate_StubWithCallback vkUpdateDescriptorSetWithTemplate_AddCallback +#define vkUpdateDescriptorSetWithTemplate_IgnoreArg_device() vkUpdateDescriptorSetWithTemplate_CMockIgnoreArg_device(__LINE__) +void vkUpdateDescriptorSetWithTemplate_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkUpdateDescriptorSetWithTemplate_IgnoreArg_descriptorSet() vkUpdateDescriptorSetWithTemplate_CMockIgnoreArg_descriptorSet(__LINE__) +void vkUpdateDescriptorSetWithTemplate_CMockIgnoreArg_descriptorSet(UNITY_LINE_TYPE cmock_line); +#define vkUpdateDescriptorSetWithTemplate_IgnoreArg_descriptorUpdateTemplate() vkUpdateDescriptorSetWithTemplate_CMockIgnoreArg_descriptorUpdateTemplate(__LINE__) +void vkUpdateDescriptorSetWithTemplate_CMockIgnoreArg_descriptorUpdateTemplate(UNITY_LINE_TYPE cmock_line); +#define vkUpdateDescriptorSetWithTemplate_IgnoreArg_pData() vkUpdateDescriptorSetWithTemplate_CMockIgnoreArg_pData(__LINE__) +void vkUpdateDescriptorSetWithTemplate_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalBufferProperties_Ignore() vkGetPhysicalDeviceExternalBufferProperties_CMockIgnore() +void vkGetPhysicalDeviceExternalBufferProperties_CMockIgnore(void); +#define vkGetPhysicalDeviceExternalBufferProperties_StopIgnore() vkGetPhysicalDeviceExternalBufferProperties_CMockStopIgnore() +void vkGetPhysicalDeviceExternalBufferProperties_CMockStopIgnore(void); +#define vkGetPhysicalDeviceExternalBufferProperties_ExpectAnyArgs() vkGetPhysicalDeviceExternalBufferProperties_CMockExpectAnyArgs(__LINE__) +void vkGetPhysicalDeviceExternalBufferProperties_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalBufferProperties_Expect(physicalDevice, pExternalBufferInfo, pExternalBufferProperties) vkGetPhysicalDeviceExternalBufferProperties_CMockExpect(__LINE__, physicalDevice, pExternalBufferInfo, pExternalBufferProperties) +void vkGetPhysicalDeviceExternalBufferProperties_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); +typedef void (* CMOCK_vkGetPhysicalDeviceExternalBufferProperties_CALLBACK)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties, int cmock_num_calls); +void vkGetPhysicalDeviceExternalBufferProperties_AddCallback(CMOCK_vkGetPhysicalDeviceExternalBufferProperties_CALLBACK Callback); +void vkGetPhysicalDeviceExternalBufferProperties_Stub(CMOCK_vkGetPhysicalDeviceExternalBufferProperties_CALLBACK Callback); +#define vkGetPhysicalDeviceExternalBufferProperties_StubWithCallback vkGetPhysicalDeviceExternalBufferProperties_AddCallback +#define vkGetPhysicalDeviceExternalBufferProperties_ReturnThruPtr_pExternalBufferProperties(pExternalBufferProperties) vkGetPhysicalDeviceExternalBufferProperties_CMockReturnMemThruPtr_pExternalBufferProperties(__LINE__, pExternalBufferProperties, sizeof(VkExternalBufferProperties)) +#define vkGetPhysicalDeviceExternalBufferProperties_ReturnArrayThruPtr_pExternalBufferProperties(pExternalBufferProperties, cmock_len) vkGetPhysicalDeviceExternalBufferProperties_CMockReturnMemThruPtr_pExternalBufferProperties(__LINE__, pExternalBufferProperties, cmock_len * sizeof(*pExternalBufferProperties)) +#define vkGetPhysicalDeviceExternalBufferProperties_ReturnMemThruPtr_pExternalBufferProperties(pExternalBufferProperties, cmock_size) vkGetPhysicalDeviceExternalBufferProperties_CMockReturnMemThruPtr_pExternalBufferProperties(__LINE__, pExternalBufferProperties, cmock_size) +void vkGetPhysicalDeviceExternalBufferProperties_CMockReturnMemThruPtr_pExternalBufferProperties(UNITY_LINE_TYPE cmock_line, VkExternalBufferProperties const* pExternalBufferProperties, size_t cmock_size); +#define vkGetPhysicalDeviceExternalBufferProperties_IgnoreArg_physicalDevice() vkGetPhysicalDeviceExternalBufferProperties_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceExternalBufferProperties_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalBufferProperties_IgnoreArg_pExternalBufferInfo() vkGetPhysicalDeviceExternalBufferProperties_CMockIgnoreArg_pExternalBufferInfo(__LINE__) +void vkGetPhysicalDeviceExternalBufferProperties_CMockIgnoreArg_pExternalBufferInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalBufferProperties_IgnoreArg_pExternalBufferProperties() vkGetPhysicalDeviceExternalBufferProperties_CMockIgnoreArg_pExternalBufferProperties(__LINE__) +void vkGetPhysicalDeviceExternalBufferProperties_CMockIgnoreArg_pExternalBufferProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalFenceProperties_Ignore() vkGetPhysicalDeviceExternalFenceProperties_CMockIgnore() +void vkGetPhysicalDeviceExternalFenceProperties_CMockIgnore(void); +#define vkGetPhysicalDeviceExternalFenceProperties_StopIgnore() vkGetPhysicalDeviceExternalFenceProperties_CMockStopIgnore() +void vkGetPhysicalDeviceExternalFenceProperties_CMockStopIgnore(void); +#define vkGetPhysicalDeviceExternalFenceProperties_ExpectAnyArgs() vkGetPhysicalDeviceExternalFenceProperties_CMockExpectAnyArgs(__LINE__) +void vkGetPhysicalDeviceExternalFenceProperties_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalFenceProperties_Expect(physicalDevice, pExternalFenceInfo, pExternalFenceProperties) vkGetPhysicalDeviceExternalFenceProperties_CMockExpect(__LINE__, physicalDevice, pExternalFenceInfo, pExternalFenceProperties) +void vkGetPhysicalDeviceExternalFenceProperties_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); +typedef void (* CMOCK_vkGetPhysicalDeviceExternalFenceProperties_CALLBACK)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties, int cmock_num_calls); +void vkGetPhysicalDeviceExternalFenceProperties_AddCallback(CMOCK_vkGetPhysicalDeviceExternalFenceProperties_CALLBACK Callback); +void vkGetPhysicalDeviceExternalFenceProperties_Stub(CMOCK_vkGetPhysicalDeviceExternalFenceProperties_CALLBACK Callback); +#define vkGetPhysicalDeviceExternalFenceProperties_StubWithCallback vkGetPhysicalDeviceExternalFenceProperties_AddCallback +#define vkGetPhysicalDeviceExternalFenceProperties_ReturnThruPtr_pExternalFenceProperties(pExternalFenceProperties) vkGetPhysicalDeviceExternalFenceProperties_CMockReturnMemThruPtr_pExternalFenceProperties(__LINE__, pExternalFenceProperties, sizeof(VkExternalFenceProperties)) +#define vkGetPhysicalDeviceExternalFenceProperties_ReturnArrayThruPtr_pExternalFenceProperties(pExternalFenceProperties, cmock_len) vkGetPhysicalDeviceExternalFenceProperties_CMockReturnMemThruPtr_pExternalFenceProperties(__LINE__, pExternalFenceProperties, cmock_len * sizeof(*pExternalFenceProperties)) +#define vkGetPhysicalDeviceExternalFenceProperties_ReturnMemThruPtr_pExternalFenceProperties(pExternalFenceProperties, cmock_size) vkGetPhysicalDeviceExternalFenceProperties_CMockReturnMemThruPtr_pExternalFenceProperties(__LINE__, pExternalFenceProperties, cmock_size) +void vkGetPhysicalDeviceExternalFenceProperties_CMockReturnMemThruPtr_pExternalFenceProperties(UNITY_LINE_TYPE cmock_line, VkExternalFenceProperties const* pExternalFenceProperties, size_t cmock_size); +#define vkGetPhysicalDeviceExternalFenceProperties_IgnoreArg_physicalDevice() vkGetPhysicalDeviceExternalFenceProperties_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceExternalFenceProperties_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalFenceProperties_IgnoreArg_pExternalFenceInfo() vkGetPhysicalDeviceExternalFenceProperties_CMockIgnoreArg_pExternalFenceInfo(__LINE__) +void vkGetPhysicalDeviceExternalFenceProperties_CMockIgnoreArg_pExternalFenceInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalFenceProperties_IgnoreArg_pExternalFenceProperties() vkGetPhysicalDeviceExternalFenceProperties_CMockIgnoreArg_pExternalFenceProperties(__LINE__) +void vkGetPhysicalDeviceExternalFenceProperties_CMockIgnoreArg_pExternalFenceProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalSemaphoreProperties_Ignore() vkGetPhysicalDeviceExternalSemaphoreProperties_CMockIgnore() +void vkGetPhysicalDeviceExternalSemaphoreProperties_CMockIgnore(void); +#define vkGetPhysicalDeviceExternalSemaphoreProperties_StopIgnore() vkGetPhysicalDeviceExternalSemaphoreProperties_CMockStopIgnore() +void vkGetPhysicalDeviceExternalSemaphoreProperties_CMockStopIgnore(void); +#define vkGetPhysicalDeviceExternalSemaphoreProperties_ExpectAnyArgs() vkGetPhysicalDeviceExternalSemaphoreProperties_CMockExpectAnyArgs(__LINE__) +void vkGetPhysicalDeviceExternalSemaphoreProperties_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalSemaphoreProperties_Expect(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties) vkGetPhysicalDeviceExternalSemaphoreProperties_CMockExpect(__LINE__, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties) +void vkGetPhysicalDeviceExternalSemaphoreProperties_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); +typedef void (* CMOCK_vkGetPhysicalDeviceExternalSemaphoreProperties_CALLBACK)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties, int cmock_num_calls); +void vkGetPhysicalDeviceExternalSemaphoreProperties_AddCallback(CMOCK_vkGetPhysicalDeviceExternalSemaphoreProperties_CALLBACK Callback); +void vkGetPhysicalDeviceExternalSemaphoreProperties_Stub(CMOCK_vkGetPhysicalDeviceExternalSemaphoreProperties_CALLBACK Callback); +#define vkGetPhysicalDeviceExternalSemaphoreProperties_StubWithCallback vkGetPhysicalDeviceExternalSemaphoreProperties_AddCallback +#define vkGetPhysicalDeviceExternalSemaphoreProperties_ReturnThruPtr_pExternalSemaphoreProperties(pExternalSemaphoreProperties) vkGetPhysicalDeviceExternalSemaphoreProperties_CMockReturnMemThruPtr_pExternalSemaphoreProperties(__LINE__, pExternalSemaphoreProperties, sizeof(VkExternalSemaphoreProperties)) +#define vkGetPhysicalDeviceExternalSemaphoreProperties_ReturnArrayThruPtr_pExternalSemaphoreProperties(pExternalSemaphoreProperties, cmock_len) vkGetPhysicalDeviceExternalSemaphoreProperties_CMockReturnMemThruPtr_pExternalSemaphoreProperties(__LINE__, pExternalSemaphoreProperties, cmock_len * sizeof(*pExternalSemaphoreProperties)) +#define vkGetPhysicalDeviceExternalSemaphoreProperties_ReturnMemThruPtr_pExternalSemaphoreProperties(pExternalSemaphoreProperties, cmock_size) vkGetPhysicalDeviceExternalSemaphoreProperties_CMockReturnMemThruPtr_pExternalSemaphoreProperties(__LINE__, pExternalSemaphoreProperties, cmock_size) +void vkGetPhysicalDeviceExternalSemaphoreProperties_CMockReturnMemThruPtr_pExternalSemaphoreProperties(UNITY_LINE_TYPE cmock_line, VkExternalSemaphoreProperties const* pExternalSemaphoreProperties, size_t cmock_size); +#define vkGetPhysicalDeviceExternalSemaphoreProperties_IgnoreArg_physicalDevice() vkGetPhysicalDeviceExternalSemaphoreProperties_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceExternalSemaphoreProperties_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalSemaphoreProperties_IgnoreArg_pExternalSemaphoreInfo() vkGetPhysicalDeviceExternalSemaphoreProperties_CMockIgnoreArg_pExternalSemaphoreInfo(__LINE__) +void vkGetPhysicalDeviceExternalSemaphoreProperties_CMockIgnoreArg_pExternalSemaphoreInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalSemaphoreProperties_IgnoreArg_pExternalSemaphoreProperties() vkGetPhysicalDeviceExternalSemaphoreProperties_CMockIgnoreArg_pExternalSemaphoreProperties(__LINE__) +void vkGetPhysicalDeviceExternalSemaphoreProperties_CMockIgnoreArg_pExternalSemaphoreProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetDescriptorSetLayoutSupport_Ignore() vkGetDescriptorSetLayoutSupport_CMockIgnore() +void vkGetDescriptorSetLayoutSupport_CMockIgnore(void); +#define vkGetDescriptorSetLayoutSupport_StopIgnore() vkGetDescriptorSetLayoutSupport_CMockStopIgnore() +void vkGetDescriptorSetLayoutSupport_CMockStopIgnore(void); +#define vkGetDescriptorSetLayoutSupport_ExpectAnyArgs() vkGetDescriptorSetLayoutSupport_CMockExpectAnyArgs(__LINE__) +void vkGetDescriptorSetLayoutSupport_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetDescriptorSetLayoutSupport_Expect(device, pCreateInfo, pSupport) vkGetDescriptorSetLayoutSupport_CMockExpect(__LINE__, device, pCreateInfo, pSupport) +void vkGetDescriptorSetLayoutSupport_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); +typedef void (* CMOCK_vkGetDescriptorSetLayoutSupport_CALLBACK)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport, int cmock_num_calls); +void vkGetDescriptorSetLayoutSupport_AddCallback(CMOCK_vkGetDescriptorSetLayoutSupport_CALLBACK Callback); +void vkGetDescriptorSetLayoutSupport_Stub(CMOCK_vkGetDescriptorSetLayoutSupport_CALLBACK Callback); +#define vkGetDescriptorSetLayoutSupport_StubWithCallback vkGetDescriptorSetLayoutSupport_AddCallback +#define vkGetDescriptorSetLayoutSupport_ReturnThruPtr_pSupport(pSupport) vkGetDescriptorSetLayoutSupport_CMockReturnMemThruPtr_pSupport(__LINE__, pSupport, sizeof(VkDescriptorSetLayoutSupport)) +#define vkGetDescriptorSetLayoutSupport_ReturnArrayThruPtr_pSupport(pSupport, cmock_len) vkGetDescriptorSetLayoutSupport_CMockReturnMemThruPtr_pSupport(__LINE__, pSupport, cmock_len * sizeof(*pSupport)) +#define vkGetDescriptorSetLayoutSupport_ReturnMemThruPtr_pSupport(pSupport, cmock_size) vkGetDescriptorSetLayoutSupport_CMockReturnMemThruPtr_pSupport(__LINE__, pSupport, cmock_size) +void vkGetDescriptorSetLayoutSupport_CMockReturnMemThruPtr_pSupport(UNITY_LINE_TYPE cmock_line, VkDescriptorSetLayoutSupport const* pSupport, size_t cmock_size); +#define vkGetDescriptorSetLayoutSupport_IgnoreArg_device() vkGetDescriptorSetLayoutSupport_CMockIgnoreArg_device(__LINE__) +void vkGetDescriptorSetLayoutSupport_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetDescriptorSetLayoutSupport_IgnoreArg_pCreateInfo() vkGetDescriptorSetLayoutSupport_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkGetDescriptorSetLayoutSupport_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetDescriptorSetLayoutSupport_IgnoreArg_pSupport() vkGetDescriptorSetLayoutSupport_CMockIgnoreArg_pSupport(__LINE__) +void vkGetDescriptorSetLayoutSupport_CMockIgnoreArg_pSupport(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectCount_Ignore() vkCmdDrawIndirectCount_CMockIgnore() +void vkCmdDrawIndirectCount_CMockIgnore(void); +#define vkCmdDrawIndirectCount_StopIgnore() vkCmdDrawIndirectCount_CMockStopIgnore() +void vkCmdDrawIndirectCount_CMockStopIgnore(void); +#define vkCmdDrawIndirectCount_ExpectAnyArgs() vkCmdDrawIndirectCount_CMockExpectAnyArgs(__LINE__) +void vkCmdDrawIndirectCount_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectCount_Expect(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride) vkCmdDrawIndirectCount_CMockExpect(__LINE__, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride) +void vkCmdDrawIndirectCount_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef void (* CMOCK_vkCmdDrawIndirectCount_CALLBACK)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, int cmock_num_calls); +void vkCmdDrawIndirectCount_AddCallback(CMOCK_vkCmdDrawIndirectCount_CALLBACK Callback); +void vkCmdDrawIndirectCount_Stub(CMOCK_vkCmdDrawIndirectCount_CALLBACK Callback); +#define vkCmdDrawIndirectCount_StubWithCallback vkCmdDrawIndirectCount_AddCallback +#define vkCmdDrawIndirectCount_IgnoreArg_commandBuffer() vkCmdDrawIndirectCount_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDrawIndirectCount_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectCount_IgnoreArg_buffer() vkCmdDrawIndirectCount_CMockIgnoreArg_buffer(__LINE__) +void vkCmdDrawIndirectCount_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectCount_IgnoreArg_offset() vkCmdDrawIndirectCount_CMockIgnoreArg_offset(__LINE__) +void vkCmdDrawIndirectCount_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectCount_IgnoreArg_countBuffer() vkCmdDrawIndirectCount_CMockIgnoreArg_countBuffer(__LINE__) +void vkCmdDrawIndirectCount_CMockIgnoreArg_countBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectCount_IgnoreArg_countBufferOffset() vkCmdDrawIndirectCount_CMockIgnoreArg_countBufferOffset(__LINE__) +void vkCmdDrawIndirectCount_CMockIgnoreArg_countBufferOffset(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectCount_IgnoreArg_maxDrawCount() vkCmdDrawIndirectCount_CMockIgnoreArg_maxDrawCount(__LINE__) +void vkCmdDrawIndirectCount_CMockIgnoreArg_maxDrawCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectCount_IgnoreArg_stride() vkCmdDrawIndirectCount_CMockIgnoreArg_stride(__LINE__) +void vkCmdDrawIndirectCount_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexedIndirectCount_Ignore() vkCmdDrawIndexedIndirectCount_CMockIgnore() +void vkCmdDrawIndexedIndirectCount_CMockIgnore(void); +#define vkCmdDrawIndexedIndirectCount_StopIgnore() vkCmdDrawIndexedIndirectCount_CMockStopIgnore() +void vkCmdDrawIndexedIndirectCount_CMockStopIgnore(void); +#define vkCmdDrawIndexedIndirectCount_ExpectAnyArgs() vkCmdDrawIndexedIndirectCount_CMockExpectAnyArgs(__LINE__) +void vkCmdDrawIndexedIndirectCount_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexedIndirectCount_Expect(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride) vkCmdDrawIndexedIndirectCount_CMockExpect(__LINE__, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride) +void vkCmdDrawIndexedIndirectCount_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef void (* CMOCK_vkCmdDrawIndexedIndirectCount_CALLBACK)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, int cmock_num_calls); +void vkCmdDrawIndexedIndirectCount_AddCallback(CMOCK_vkCmdDrawIndexedIndirectCount_CALLBACK Callback); +void vkCmdDrawIndexedIndirectCount_Stub(CMOCK_vkCmdDrawIndexedIndirectCount_CALLBACK Callback); +#define vkCmdDrawIndexedIndirectCount_StubWithCallback vkCmdDrawIndexedIndirectCount_AddCallback +#define vkCmdDrawIndexedIndirectCount_IgnoreArg_commandBuffer() vkCmdDrawIndexedIndirectCount_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDrawIndexedIndirectCount_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexedIndirectCount_IgnoreArg_buffer() vkCmdDrawIndexedIndirectCount_CMockIgnoreArg_buffer(__LINE__) +void vkCmdDrawIndexedIndirectCount_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexedIndirectCount_IgnoreArg_offset() vkCmdDrawIndexedIndirectCount_CMockIgnoreArg_offset(__LINE__) +void vkCmdDrawIndexedIndirectCount_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexedIndirectCount_IgnoreArg_countBuffer() vkCmdDrawIndexedIndirectCount_CMockIgnoreArg_countBuffer(__LINE__) +void vkCmdDrawIndexedIndirectCount_CMockIgnoreArg_countBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexedIndirectCount_IgnoreArg_countBufferOffset() vkCmdDrawIndexedIndirectCount_CMockIgnoreArg_countBufferOffset(__LINE__) +void vkCmdDrawIndexedIndirectCount_CMockIgnoreArg_countBufferOffset(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexedIndirectCount_IgnoreArg_maxDrawCount() vkCmdDrawIndexedIndirectCount_CMockIgnoreArg_maxDrawCount(__LINE__) +void vkCmdDrawIndexedIndirectCount_CMockIgnoreArg_maxDrawCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexedIndirectCount_IgnoreArg_stride() vkCmdDrawIndexedIndirectCount_CMockIgnoreArg_stride(__LINE__) +void vkCmdDrawIndexedIndirectCount_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line); +#define vkCreateRenderPass2_IgnoreAndReturn(cmock_retval) vkCreateRenderPass2_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateRenderPass2_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateRenderPass2_StopIgnore() vkCreateRenderPass2_CMockStopIgnore() +void vkCreateRenderPass2_CMockStopIgnore(void); +#define vkCreateRenderPass2_ExpectAnyArgsAndReturn(cmock_retval) vkCreateRenderPass2_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateRenderPass2_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateRenderPass2_ExpectAndReturn(device, pCreateInfo, pAllocator, pRenderPass, cmock_retval) vkCreateRenderPass2_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pRenderPass, cmock_retval) +void vkCreateRenderPass2_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateRenderPass2_CALLBACK)(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, int cmock_num_calls); +void vkCreateRenderPass2_AddCallback(CMOCK_vkCreateRenderPass2_CALLBACK Callback); +void vkCreateRenderPass2_Stub(CMOCK_vkCreateRenderPass2_CALLBACK Callback); +#define vkCreateRenderPass2_StubWithCallback vkCreateRenderPass2_AddCallback +#define vkCreateRenderPass2_ReturnThruPtr_pRenderPass(pRenderPass) vkCreateRenderPass2_CMockReturnMemThruPtr_pRenderPass(__LINE__, pRenderPass, sizeof(VkRenderPass)) +#define vkCreateRenderPass2_ReturnArrayThruPtr_pRenderPass(pRenderPass, cmock_len) vkCreateRenderPass2_CMockReturnMemThruPtr_pRenderPass(__LINE__, pRenderPass, cmock_len * sizeof(*pRenderPass)) +#define vkCreateRenderPass2_ReturnMemThruPtr_pRenderPass(pRenderPass, cmock_size) vkCreateRenderPass2_CMockReturnMemThruPtr_pRenderPass(__LINE__, pRenderPass, cmock_size) +void vkCreateRenderPass2_CMockReturnMemThruPtr_pRenderPass(UNITY_LINE_TYPE cmock_line, VkRenderPass const* pRenderPass, size_t cmock_size); +#define vkCreateRenderPass2_IgnoreArg_device() vkCreateRenderPass2_CMockIgnoreArg_device(__LINE__) +void vkCreateRenderPass2_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateRenderPass2_IgnoreArg_pCreateInfo() vkCreateRenderPass2_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateRenderPass2_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateRenderPass2_IgnoreArg_pAllocator() vkCreateRenderPass2_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateRenderPass2_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateRenderPass2_IgnoreArg_pRenderPass() vkCreateRenderPass2_CMockIgnoreArg_pRenderPass(__LINE__) +void vkCreateRenderPass2_CMockIgnoreArg_pRenderPass(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginRenderPass2_Ignore() vkCmdBeginRenderPass2_CMockIgnore() +void vkCmdBeginRenderPass2_CMockIgnore(void); +#define vkCmdBeginRenderPass2_StopIgnore() vkCmdBeginRenderPass2_CMockStopIgnore() +void vkCmdBeginRenderPass2_CMockStopIgnore(void); +#define vkCmdBeginRenderPass2_ExpectAnyArgs() vkCmdBeginRenderPass2_CMockExpectAnyArgs(__LINE__) +void vkCmdBeginRenderPass2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginRenderPass2_Expect(commandBuffer, pRenderPassBegin, pSubpassBeginInfo) vkCmdBeginRenderPass2_CMockExpect(__LINE__, commandBuffer, pRenderPassBegin, pSubpassBeginInfo) +void vkCmdBeginRenderPass2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo); +typedef void (* CMOCK_vkCmdBeginRenderPass2_CALLBACK)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo, int cmock_num_calls); +void vkCmdBeginRenderPass2_AddCallback(CMOCK_vkCmdBeginRenderPass2_CALLBACK Callback); +void vkCmdBeginRenderPass2_Stub(CMOCK_vkCmdBeginRenderPass2_CALLBACK Callback); +#define vkCmdBeginRenderPass2_StubWithCallback vkCmdBeginRenderPass2_AddCallback +#define vkCmdBeginRenderPass2_IgnoreArg_commandBuffer() vkCmdBeginRenderPass2_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBeginRenderPass2_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginRenderPass2_IgnoreArg_pRenderPassBegin() vkCmdBeginRenderPass2_CMockIgnoreArg_pRenderPassBegin(__LINE__) +void vkCmdBeginRenderPass2_CMockIgnoreArg_pRenderPassBegin(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginRenderPass2_IgnoreArg_pSubpassBeginInfo() vkCmdBeginRenderPass2_CMockIgnoreArg_pSubpassBeginInfo(__LINE__) +void vkCmdBeginRenderPass2_CMockIgnoreArg_pSubpassBeginInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdNextSubpass2_Ignore() vkCmdNextSubpass2_CMockIgnore() +void vkCmdNextSubpass2_CMockIgnore(void); +#define vkCmdNextSubpass2_StopIgnore() vkCmdNextSubpass2_CMockStopIgnore() +void vkCmdNextSubpass2_CMockStopIgnore(void); +#define vkCmdNextSubpass2_ExpectAnyArgs() vkCmdNextSubpass2_CMockExpectAnyArgs(__LINE__) +void vkCmdNextSubpass2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdNextSubpass2_Expect(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo) vkCmdNextSubpass2_CMockExpect(__LINE__, commandBuffer, pSubpassBeginInfo, pSubpassEndInfo) +void vkCmdNextSubpass2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo); +typedef void (* CMOCK_vkCmdNextSubpass2_CALLBACK)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo, int cmock_num_calls); +void vkCmdNextSubpass2_AddCallback(CMOCK_vkCmdNextSubpass2_CALLBACK Callback); +void vkCmdNextSubpass2_Stub(CMOCK_vkCmdNextSubpass2_CALLBACK Callback); +#define vkCmdNextSubpass2_StubWithCallback vkCmdNextSubpass2_AddCallback +#define vkCmdNextSubpass2_IgnoreArg_commandBuffer() vkCmdNextSubpass2_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdNextSubpass2_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdNextSubpass2_IgnoreArg_pSubpassBeginInfo() vkCmdNextSubpass2_CMockIgnoreArg_pSubpassBeginInfo(__LINE__) +void vkCmdNextSubpass2_CMockIgnoreArg_pSubpassBeginInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdNextSubpass2_IgnoreArg_pSubpassEndInfo() vkCmdNextSubpass2_CMockIgnoreArg_pSubpassEndInfo(__LINE__) +void vkCmdNextSubpass2_CMockIgnoreArg_pSubpassEndInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndRenderPass2_Ignore() vkCmdEndRenderPass2_CMockIgnore() +void vkCmdEndRenderPass2_CMockIgnore(void); +#define vkCmdEndRenderPass2_StopIgnore() vkCmdEndRenderPass2_CMockStopIgnore() +void vkCmdEndRenderPass2_CMockStopIgnore(void); +#define vkCmdEndRenderPass2_ExpectAnyArgs() vkCmdEndRenderPass2_CMockExpectAnyArgs(__LINE__) +void vkCmdEndRenderPass2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndRenderPass2_Expect(commandBuffer, pSubpassEndInfo) vkCmdEndRenderPass2_CMockExpect(__LINE__, commandBuffer, pSubpassEndInfo) +void vkCmdEndRenderPass2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo); +typedef void (* CMOCK_vkCmdEndRenderPass2_CALLBACK)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo, int cmock_num_calls); +void vkCmdEndRenderPass2_AddCallback(CMOCK_vkCmdEndRenderPass2_CALLBACK Callback); +void vkCmdEndRenderPass2_Stub(CMOCK_vkCmdEndRenderPass2_CALLBACK Callback); +#define vkCmdEndRenderPass2_StubWithCallback vkCmdEndRenderPass2_AddCallback +#define vkCmdEndRenderPass2_IgnoreArg_commandBuffer() vkCmdEndRenderPass2_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdEndRenderPass2_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndRenderPass2_IgnoreArg_pSubpassEndInfo() vkCmdEndRenderPass2_CMockIgnoreArg_pSubpassEndInfo(__LINE__) +void vkCmdEndRenderPass2_CMockIgnoreArg_pSubpassEndInfo(UNITY_LINE_TYPE cmock_line); +#define vkResetQueryPool_Ignore() vkResetQueryPool_CMockIgnore() +void vkResetQueryPool_CMockIgnore(void); +#define vkResetQueryPool_StopIgnore() vkResetQueryPool_CMockStopIgnore() +void vkResetQueryPool_CMockStopIgnore(void); +#define vkResetQueryPool_ExpectAnyArgs() vkResetQueryPool_CMockExpectAnyArgs(__LINE__) +void vkResetQueryPool_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkResetQueryPool_Expect(device, queryPool, firstQuery, queryCount) vkResetQueryPool_CMockExpect(__LINE__, device, queryPool, firstQuery, queryCount) +void vkResetQueryPool_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); +typedef void (* CMOCK_vkResetQueryPool_CALLBACK)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, int cmock_num_calls); +void vkResetQueryPool_AddCallback(CMOCK_vkResetQueryPool_CALLBACK Callback); +void vkResetQueryPool_Stub(CMOCK_vkResetQueryPool_CALLBACK Callback); +#define vkResetQueryPool_StubWithCallback vkResetQueryPool_AddCallback +#define vkResetQueryPool_IgnoreArg_device() vkResetQueryPool_CMockIgnoreArg_device(__LINE__) +void vkResetQueryPool_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkResetQueryPool_IgnoreArg_queryPool() vkResetQueryPool_CMockIgnoreArg_queryPool(__LINE__) +void vkResetQueryPool_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line); +#define vkResetQueryPool_IgnoreArg_firstQuery() vkResetQueryPool_CMockIgnoreArg_firstQuery(__LINE__) +void vkResetQueryPool_CMockIgnoreArg_firstQuery(UNITY_LINE_TYPE cmock_line); +#define vkResetQueryPool_IgnoreArg_queryCount() vkResetQueryPool_CMockIgnoreArg_queryCount(__LINE__) +void vkResetQueryPool_CMockIgnoreArg_queryCount(UNITY_LINE_TYPE cmock_line); +#define vkGetSemaphoreCounterValue_IgnoreAndReturn(cmock_retval) vkGetSemaphoreCounterValue_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetSemaphoreCounterValue_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetSemaphoreCounterValue_StopIgnore() vkGetSemaphoreCounterValue_CMockStopIgnore() +void vkGetSemaphoreCounterValue_CMockStopIgnore(void); +#define vkGetSemaphoreCounterValue_ExpectAnyArgsAndReturn(cmock_retval) vkGetSemaphoreCounterValue_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetSemaphoreCounterValue_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetSemaphoreCounterValue_ExpectAndReturn(device, semaphore, pValue, cmock_retval) vkGetSemaphoreCounterValue_CMockExpectAndReturn(__LINE__, device, semaphore, pValue, cmock_retval) +void vkGetSemaphoreCounterValue_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSemaphore semaphore, uint64_t* pValue, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetSemaphoreCounterValue_CALLBACK)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue, int cmock_num_calls); +void vkGetSemaphoreCounterValue_AddCallback(CMOCK_vkGetSemaphoreCounterValue_CALLBACK Callback); +void vkGetSemaphoreCounterValue_Stub(CMOCK_vkGetSemaphoreCounterValue_CALLBACK Callback); +#define vkGetSemaphoreCounterValue_StubWithCallback vkGetSemaphoreCounterValue_AddCallback +#define vkGetSemaphoreCounterValue_ReturnThruPtr_pValue(pValue) vkGetSemaphoreCounterValue_CMockReturnMemThruPtr_pValue(__LINE__, pValue, sizeof(uint64_t)) +#define vkGetSemaphoreCounterValue_ReturnArrayThruPtr_pValue(pValue, cmock_len) vkGetSemaphoreCounterValue_CMockReturnMemThruPtr_pValue(__LINE__, pValue, cmock_len * sizeof(*pValue)) +#define vkGetSemaphoreCounterValue_ReturnMemThruPtr_pValue(pValue, cmock_size) vkGetSemaphoreCounterValue_CMockReturnMemThruPtr_pValue(__LINE__, pValue, cmock_size) +void vkGetSemaphoreCounterValue_CMockReturnMemThruPtr_pValue(UNITY_LINE_TYPE cmock_line, uint64_t const* pValue, size_t cmock_size); +#define vkGetSemaphoreCounterValue_IgnoreArg_device() vkGetSemaphoreCounterValue_CMockIgnoreArg_device(__LINE__) +void vkGetSemaphoreCounterValue_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetSemaphoreCounterValue_IgnoreArg_semaphore() vkGetSemaphoreCounterValue_CMockIgnoreArg_semaphore(__LINE__) +void vkGetSemaphoreCounterValue_CMockIgnoreArg_semaphore(UNITY_LINE_TYPE cmock_line); +#define vkGetSemaphoreCounterValue_IgnoreArg_pValue() vkGetSemaphoreCounterValue_CMockIgnoreArg_pValue(__LINE__) +void vkGetSemaphoreCounterValue_CMockIgnoreArg_pValue(UNITY_LINE_TYPE cmock_line); +#define vkWaitSemaphores_IgnoreAndReturn(cmock_retval) vkWaitSemaphores_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkWaitSemaphores_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkWaitSemaphores_StopIgnore() vkWaitSemaphores_CMockStopIgnore() +void vkWaitSemaphores_CMockStopIgnore(void); +#define vkWaitSemaphores_ExpectAnyArgsAndReturn(cmock_retval) vkWaitSemaphores_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkWaitSemaphores_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkWaitSemaphores_ExpectAndReturn(device, pWaitInfo, timeout, cmock_retval) vkWaitSemaphores_CMockExpectAndReturn(__LINE__, device, pWaitInfo, timeout, cmock_retval) +void vkWaitSemaphores_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkWaitSemaphores_CALLBACK)(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout, int cmock_num_calls); +void vkWaitSemaphores_AddCallback(CMOCK_vkWaitSemaphores_CALLBACK Callback); +void vkWaitSemaphores_Stub(CMOCK_vkWaitSemaphores_CALLBACK Callback); +#define vkWaitSemaphores_StubWithCallback vkWaitSemaphores_AddCallback +#define vkWaitSemaphores_IgnoreArg_device() vkWaitSemaphores_CMockIgnoreArg_device(__LINE__) +void vkWaitSemaphores_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkWaitSemaphores_IgnoreArg_pWaitInfo() vkWaitSemaphores_CMockIgnoreArg_pWaitInfo(__LINE__) +void vkWaitSemaphores_CMockIgnoreArg_pWaitInfo(UNITY_LINE_TYPE cmock_line); +#define vkWaitSemaphores_IgnoreArg_timeout() vkWaitSemaphores_CMockIgnoreArg_timeout(__LINE__) +void vkWaitSemaphores_CMockIgnoreArg_timeout(UNITY_LINE_TYPE cmock_line); +#define vkSignalSemaphore_IgnoreAndReturn(cmock_retval) vkSignalSemaphore_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkSignalSemaphore_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkSignalSemaphore_StopIgnore() vkSignalSemaphore_CMockStopIgnore() +void vkSignalSemaphore_CMockStopIgnore(void); +#define vkSignalSemaphore_ExpectAnyArgsAndReturn(cmock_retval) vkSignalSemaphore_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkSignalSemaphore_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkSignalSemaphore_ExpectAndReturn(device, pSignalInfo, cmock_retval) vkSignalSemaphore_CMockExpectAndReturn(__LINE__, device, pSignalInfo, cmock_retval) +void vkSignalSemaphore_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkSignalSemaphore_CALLBACK)(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo, int cmock_num_calls); +void vkSignalSemaphore_AddCallback(CMOCK_vkSignalSemaphore_CALLBACK Callback); +void vkSignalSemaphore_Stub(CMOCK_vkSignalSemaphore_CALLBACK Callback); +#define vkSignalSemaphore_StubWithCallback vkSignalSemaphore_AddCallback +#define vkSignalSemaphore_IgnoreArg_device() vkSignalSemaphore_CMockIgnoreArg_device(__LINE__) +void vkSignalSemaphore_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkSignalSemaphore_IgnoreArg_pSignalInfo() vkSignalSemaphore_CMockIgnoreArg_pSignalInfo(__LINE__) +void vkSignalSemaphore_CMockIgnoreArg_pSignalInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetBufferDeviceAddress_IgnoreAndReturn(cmock_retval) vkGetBufferDeviceAddress_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetBufferDeviceAddress_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkDeviceAddress cmock_to_return); +#define vkGetBufferDeviceAddress_StopIgnore() vkGetBufferDeviceAddress_CMockStopIgnore() +void vkGetBufferDeviceAddress_CMockStopIgnore(void); +#define vkGetBufferDeviceAddress_ExpectAnyArgsAndReturn(cmock_retval) vkGetBufferDeviceAddress_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetBufferDeviceAddress_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkDeviceAddress cmock_to_return); +#define vkGetBufferDeviceAddress_ExpectAndReturn(device, pInfo, cmock_retval) vkGetBufferDeviceAddress_CMockExpectAndReturn(__LINE__, device, pInfo, cmock_retval) +void vkGetBufferDeviceAddress_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkBufferDeviceAddressInfo* pInfo, VkDeviceAddress cmock_to_return); +typedef VkDeviceAddress (* CMOCK_vkGetBufferDeviceAddress_CALLBACK)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo, int cmock_num_calls); +void vkGetBufferDeviceAddress_AddCallback(CMOCK_vkGetBufferDeviceAddress_CALLBACK Callback); +void vkGetBufferDeviceAddress_Stub(CMOCK_vkGetBufferDeviceAddress_CALLBACK Callback); +#define vkGetBufferDeviceAddress_StubWithCallback vkGetBufferDeviceAddress_AddCallback +#define vkGetBufferDeviceAddress_IgnoreArg_device() vkGetBufferDeviceAddress_CMockIgnoreArg_device(__LINE__) +void vkGetBufferDeviceAddress_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetBufferDeviceAddress_IgnoreArg_pInfo() vkGetBufferDeviceAddress_CMockIgnoreArg_pInfo(__LINE__) +void vkGetBufferDeviceAddress_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetBufferOpaqueCaptureAddress_IgnoreAndReturn(cmock_retval) vkGetBufferOpaqueCaptureAddress_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetBufferOpaqueCaptureAddress_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, uint64_t cmock_to_return); +#define vkGetBufferOpaqueCaptureAddress_StopIgnore() vkGetBufferOpaqueCaptureAddress_CMockStopIgnore() +void vkGetBufferOpaqueCaptureAddress_CMockStopIgnore(void); +#define vkGetBufferOpaqueCaptureAddress_ExpectAnyArgsAndReturn(cmock_retval) vkGetBufferOpaqueCaptureAddress_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetBufferOpaqueCaptureAddress_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, uint64_t cmock_to_return); +#define vkGetBufferOpaqueCaptureAddress_ExpectAndReturn(device, pInfo, cmock_retval) vkGetBufferOpaqueCaptureAddress_CMockExpectAndReturn(__LINE__, device, pInfo, cmock_retval) +void vkGetBufferOpaqueCaptureAddress_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkBufferDeviceAddressInfo* pInfo, uint64_t cmock_to_return); +typedef uint64_t (* CMOCK_vkGetBufferOpaqueCaptureAddress_CALLBACK)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo, int cmock_num_calls); +void vkGetBufferOpaqueCaptureAddress_AddCallback(CMOCK_vkGetBufferOpaqueCaptureAddress_CALLBACK Callback); +void vkGetBufferOpaqueCaptureAddress_Stub(CMOCK_vkGetBufferOpaqueCaptureAddress_CALLBACK Callback); +#define vkGetBufferOpaqueCaptureAddress_StubWithCallback vkGetBufferOpaqueCaptureAddress_AddCallback +#define vkGetBufferOpaqueCaptureAddress_IgnoreArg_device() vkGetBufferOpaqueCaptureAddress_CMockIgnoreArg_device(__LINE__) +void vkGetBufferOpaqueCaptureAddress_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetBufferOpaqueCaptureAddress_IgnoreArg_pInfo() vkGetBufferOpaqueCaptureAddress_CMockIgnoreArg_pInfo(__LINE__) +void vkGetBufferOpaqueCaptureAddress_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceMemoryOpaqueCaptureAddress_IgnoreAndReturn(cmock_retval) vkGetDeviceMemoryOpaqueCaptureAddress_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetDeviceMemoryOpaqueCaptureAddress_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, uint64_t cmock_to_return); +#define vkGetDeviceMemoryOpaqueCaptureAddress_StopIgnore() vkGetDeviceMemoryOpaqueCaptureAddress_CMockStopIgnore() +void vkGetDeviceMemoryOpaqueCaptureAddress_CMockStopIgnore(void); +#define vkGetDeviceMemoryOpaqueCaptureAddress_ExpectAnyArgsAndReturn(cmock_retval) vkGetDeviceMemoryOpaqueCaptureAddress_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetDeviceMemoryOpaqueCaptureAddress_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, uint64_t cmock_to_return); +#define vkGetDeviceMemoryOpaqueCaptureAddress_ExpectAndReturn(device, pInfo, cmock_retval) vkGetDeviceMemoryOpaqueCaptureAddress_CMockExpectAndReturn(__LINE__, device, pInfo, cmock_retval) +void vkGetDeviceMemoryOpaqueCaptureAddress_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo, uint64_t cmock_to_return); +typedef uint64_t (* CMOCK_vkGetDeviceMemoryOpaqueCaptureAddress_CALLBACK)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo, int cmock_num_calls); +void vkGetDeviceMemoryOpaqueCaptureAddress_AddCallback(CMOCK_vkGetDeviceMemoryOpaqueCaptureAddress_CALLBACK Callback); +void vkGetDeviceMemoryOpaqueCaptureAddress_Stub(CMOCK_vkGetDeviceMemoryOpaqueCaptureAddress_CALLBACK Callback); +#define vkGetDeviceMemoryOpaqueCaptureAddress_StubWithCallback vkGetDeviceMemoryOpaqueCaptureAddress_AddCallback +#define vkGetDeviceMemoryOpaqueCaptureAddress_IgnoreArg_device() vkGetDeviceMemoryOpaqueCaptureAddress_CMockIgnoreArg_device(__LINE__) +void vkGetDeviceMemoryOpaqueCaptureAddress_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceMemoryOpaqueCaptureAddress_IgnoreArg_pInfo() vkGetDeviceMemoryOpaqueCaptureAddress_CMockIgnoreArg_pInfo(__LINE__) +void vkGetDeviceMemoryOpaqueCaptureAddress_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceToolProperties_IgnoreAndReturn(cmock_retval) vkGetPhysicalDeviceToolProperties_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceToolProperties_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceToolProperties_StopIgnore() vkGetPhysicalDeviceToolProperties_CMockStopIgnore() +void vkGetPhysicalDeviceToolProperties_CMockStopIgnore(void); +#define vkGetPhysicalDeviceToolProperties_ExpectAnyArgsAndReturn(cmock_retval) vkGetPhysicalDeviceToolProperties_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceToolProperties_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceToolProperties_ExpectAndReturn(physicalDevice, pToolCount, pToolProperties, cmock_retval) vkGetPhysicalDeviceToolProperties_CMockExpectAndReturn(__LINE__, physicalDevice, pToolCount, pToolProperties, cmock_retval) +void vkGetPhysicalDeviceToolProperties_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPhysicalDeviceToolProperties_CALLBACK)(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties, int cmock_num_calls); +void vkGetPhysicalDeviceToolProperties_AddCallback(CMOCK_vkGetPhysicalDeviceToolProperties_CALLBACK Callback); +void vkGetPhysicalDeviceToolProperties_Stub(CMOCK_vkGetPhysicalDeviceToolProperties_CALLBACK Callback); +#define vkGetPhysicalDeviceToolProperties_StubWithCallback vkGetPhysicalDeviceToolProperties_AddCallback +#define vkGetPhysicalDeviceToolProperties_ReturnThruPtr_pToolCount(pToolCount) vkGetPhysicalDeviceToolProperties_CMockReturnMemThruPtr_pToolCount(__LINE__, pToolCount, sizeof(uint32_t)) +#define vkGetPhysicalDeviceToolProperties_ReturnArrayThruPtr_pToolCount(pToolCount, cmock_len) vkGetPhysicalDeviceToolProperties_CMockReturnMemThruPtr_pToolCount(__LINE__, pToolCount, cmock_len * sizeof(*pToolCount)) +#define vkGetPhysicalDeviceToolProperties_ReturnMemThruPtr_pToolCount(pToolCount, cmock_size) vkGetPhysicalDeviceToolProperties_CMockReturnMemThruPtr_pToolCount(__LINE__, pToolCount, cmock_size) +void vkGetPhysicalDeviceToolProperties_CMockReturnMemThruPtr_pToolCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pToolCount, size_t cmock_size); +#define vkGetPhysicalDeviceToolProperties_ReturnThruPtr_pToolProperties(pToolProperties) vkGetPhysicalDeviceToolProperties_CMockReturnMemThruPtr_pToolProperties(__LINE__, pToolProperties, sizeof(VkPhysicalDeviceToolProperties)) +#define vkGetPhysicalDeviceToolProperties_ReturnArrayThruPtr_pToolProperties(pToolProperties, cmock_len) vkGetPhysicalDeviceToolProperties_CMockReturnMemThruPtr_pToolProperties(__LINE__, pToolProperties, cmock_len * sizeof(*pToolProperties)) +#define vkGetPhysicalDeviceToolProperties_ReturnMemThruPtr_pToolProperties(pToolProperties, cmock_size) vkGetPhysicalDeviceToolProperties_CMockReturnMemThruPtr_pToolProperties(__LINE__, pToolProperties, cmock_size) +void vkGetPhysicalDeviceToolProperties_CMockReturnMemThruPtr_pToolProperties(UNITY_LINE_TYPE cmock_line, VkPhysicalDeviceToolProperties const* pToolProperties, size_t cmock_size); +#define vkGetPhysicalDeviceToolProperties_IgnoreArg_physicalDevice() vkGetPhysicalDeviceToolProperties_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceToolProperties_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceToolProperties_IgnoreArg_pToolCount() vkGetPhysicalDeviceToolProperties_CMockIgnoreArg_pToolCount(__LINE__) +void vkGetPhysicalDeviceToolProperties_CMockIgnoreArg_pToolCount(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceToolProperties_IgnoreArg_pToolProperties() vkGetPhysicalDeviceToolProperties_CMockIgnoreArg_pToolProperties(__LINE__) +void vkGetPhysicalDeviceToolProperties_CMockIgnoreArg_pToolProperties(UNITY_LINE_TYPE cmock_line); +#define vkCreatePrivateDataSlot_IgnoreAndReturn(cmock_retval) vkCreatePrivateDataSlot_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreatePrivateDataSlot_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreatePrivateDataSlot_StopIgnore() vkCreatePrivateDataSlot_CMockStopIgnore() +void vkCreatePrivateDataSlot_CMockStopIgnore(void); +#define vkCreatePrivateDataSlot_ExpectAnyArgsAndReturn(cmock_retval) vkCreatePrivateDataSlot_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreatePrivateDataSlot_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreatePrivateDataSlot_ExpectAndReturn(device, pCreateInfo, pAllocator, pPrivateDataSlot, cmock_retval) vkCreatePrivateDataSlot_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pPrivateDataSlot, cmock_retval) +void vkCreatePrivateDataSlot_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreatePrivateDataSlot_CALLBACK)(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot, int cmock_num_calls); +void vkCreatePrivateDataSlot_AddCallback(CMOCK_vkCreatePrivateDataSlot_CALLBACK Callback); +void vkCreatePrivateDataSlot_Stub(CMOCK_vkCreatePrivateDataSlot_CALLBACK Callback); +#define vkCreatePrivateDataSlot_StubWithCallback vkCreatePrivateDataSlot_AddCallback +#define vkCreatePrivateDataSlot_ReturnThruPtr_pPrivateDataSlot(pPrivateDataSlot) vkCreatePrivateDataSlot_CMockReturnMemThruPtr_pPrivateDataSlot(__LINE__, pPrivateDataSlot, sizeof(VkPrivateDataSlot)) +#define vkCreatePrivateDataSlot_ReturnArrayThruPtr_pPrivateDataSlot(pPrivateDataSlot, cmock_len) vkCreatePrivateDataSlot_CMockReturnMemThruPtr_pPrivateDataSlot(__LINE__, pPrivateDataSlot, cmock_len * sizeof(*pPrivateDataSlot)) +#define vkCreatePrivateDataSlot_ReturnMemThruPtr_pPrivateDataSlot(pPrivateDataSlot, cmock_size) vkCreatePrivateDataSlot_CMockReturnMemThruPtr_pPrivateDataSlot(__LINE__, pPrivateDataSlot, cmock_size) +void vkCreatePrivateDataSlot_CMockReturnMemThruPtr_pPrivateDataSlot(UNITY_LINE_TYPE cmock_line, VkPrivateDataSlot const* pPrivateDataSlot, size_t cmock_size); +#define vkCreatePrivateDataSlot_IgnoreArg_device() vkCreatePrivateDataSlot_CMockIgnoreArg_device(__LINE__) +void vkCreatePrivateDataSlot_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreatePrivateDataSlot_IgnoreArg_pCreateInfo() vkCreatePrivateDataSlot_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreatePrivateDataSlot_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreatePrivateDataSlot_IgnoreArg_pAllocator() vkCreatePrivateDataSlot_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreatePrivateDataSlot_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreatePrivateDataSlot_IgnoreArg_pPrivateDataSlot() vkCreatePrivateDataSlot_CMockIgnoreArg_pPrivateDataSlot(__LINE__) +void vkCreatePrivateDataSlot_CMockIgnoreArg_pPrivateDataSlot(UNITY_LINE_TYPE cmock_line); +#define vkDestroyPrivateDataSlot_Ignore() vkDestroyPrivateDataSlot_CMockIgnore() +void vkDestroyPrivateDataSlot_CMockIgnore(void); +#define vkDestroyPrivateDataSlot_StopIgnore() vkDestroyPrivateDataSlot_CMockStopIgnore() +void vkDestroyPrivateDataSlot_CMockStopIgnore(void); +#define vkDestroyPrivateDataSlot_ExpectAnyArgs() vkDestroyPrivateDataSlot_CMockExpectAnyArgs(__LINE__) +void vkDestroyPrivateDataSlot_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyPrivateDataSlot_Expect(device, privateDataSlot, pAllocator) vkDestroyPrivateDataSlot_CMockExpect(__LINE__, device, privateDataSlot, pAllocator) +void vkDestroyPrivateDataSlot_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyPrivateDataSlot_CALLBACK)(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyPrivateDataSlot_AddCallback(CMOCK_vkDestroyPrivateDataSlot_CALLBACK Callback); +void vkDestroyPrivateDataSlot_Stub(CMOCK_vkDestroyPrivateDataSlot_CALLBACK Callback); +#define vkDestroyPrivateDataSlot_StubWithCallback vkDestroyPrivateDataSlot_AddCallback +#define vkDestroyPrivateDataSlot_IgnoreArg_device() vkDestroyPrivateDataSlot_CMockIgnoreArg_device(__LINE__) +void vkDestroyPrivateDataSlot_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyPrivateDataSlot_IgnoreArg_privateDataSlot() vkDestroyPrivateDataSlot_CMockIgnoreArg_privateDataSlot(__LINE__) +void vkDestroyPrivateDataSlot_CMockIgnoreArg_privateDataSlot(UNITY_LINE_TYPE cmock_line); +#define vkDestroyPrivateDataSlot_IgnoreArg_pAllocator() vkDestroyPrivateDataSlot_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyPrivateDataSlot_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkSetPrivateData_IgnoreAndReturn(cmock_retval) vkSetPrivateData_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkSetPrivateData_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkSetPrivateData_StopIgnore() vkSetPrivateData_CMockStopIgnore() +void vkSetPrivateData_CMockStopIgnore(void); +#define vkSetPrivateData_ExpectAnyArgsAndReturn(cmock_retval) vkSetPrivateData_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkSetPrivateData_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkSetPrivateData_ExpectAndReturn(device, objectType, objectHandle, privateDataSlot, data, cmock_retval) vkSetPrivateData_CMockExpectAndReturn(__LINE__, device, objectType, objectHandle, privateDataSlot, data, cmock_retval) +void vkSetPrivateData_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkSetPrivateData_CALLBACK)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data, int cmock_num_calls); +void vkSetPrivateData_AddCallback(CMOCK_vkSetPrivateData_CALLBACK Callback); +void vkSetPrivateData_Stub(CMOCK_vkSetPrivateData_CALLBACK Callback); +#define vkSetPrivateData_StubWithCallback vkSetPrivateData_AddCallback +#define vkSetPrivateData_IgnoreArg_device() vkSetPrivateData_CMockIgnoreArg_device(__LINE__) +void vkSetPrivateData_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkSetPrivateData_IgnoreArg_objectType() vkSetPrivateData_CMockIgnoreArg_objectType(__LINE__) +void vkSetPrivateData_CMockIgnoreArg_objectType(UNITY_LINE_TYPE cmock_line); +#define vkSetPrivateData_IgnoreArg_objectHandle() vkSetPrivateData_CMockIgnoreArg_objectHandle(__LINE__) +void vkSetPrivateData_CMockIgnoreArg_objectHandle(UNITY_LINE_TYPE cmock_line); +#define vkSetPrivateData_IgnoreArg_privateDataSlot() vkSetPrivateData_CMockIgnoreArg_privateDataSlot(__LINE__) +void vkSetPrivateData_CMockIgnoreArg_privateDataSlot(UNITY_LINE_TYPE cmock_line); +#define vkSetPrivateData_IgnoreArg_data() vkSetPrivateData_CMockIgnoreArg_data(__LINE__) +void vkSetPrivateData_CMockIgnoreArg_data(UNITY_LINE_TYPE cmock_line); +#define vkGetPrivateData_Ignore() vkGetPrivateData_CMockIgnore() +void vkGetPrivateData_CMockIgnore(void); +#define vkGetPrivateData_StopIgnore() vkGetPrivateData_CMockStopIgnore() +void vkGetPrivateData_CMockStopIgnore(void); +#define vkGetPrivateData_ExpectAnyArgs() vkGetPrivateData_CMockExpectAnyArgs(__LINE__) +void vkGetPrivateData_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetPrivateData_Expect(device, objectType, objectHandle, privateDataSlot, pData) vkGetPrivateData_CMockExpect(__LINE__, device, objectType, objectHandle, privateDataSlot, pData) +void vkGetPrivateData_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData); +typedef void (* CMOCK_vkGetPrivateData_CALLBACK)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData, int cmock_num_calls); +void vkGetPrivateData_AddCallback(CMOCK_vkGetPrivateData_CALLBACK Callback); +void vkGetPrivateData_Stub(CMOCK_vkGetPrivateData_CALLBACK Callback); +#define vkGetPrivateData_StubWithCallback vkGetPrivateData_AddCallback +#define vkGetPrivateData_ReturnThruPtr_pData(pData) vkGetPrivateData_CMockReturnMemThruPtr_pData(__LINE__, pData, sizeof(uint64_t)) +#define vkGetPrivateData_ReturnArrayThruPtr_pData(pData, cmock_len) vkGetPrivateData_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_len * sizeof(*pData)) +#define vkGetPrivateData_ReturnMemThruPtr_pData(pData, cmock_size) vkGetPrivateData_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_size) +void vkGetPrivateData_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, uint64_t const* pData, size_t cmock_size); +#define vkGetPrivateData_IgnoreArg_device() vkGetPrivateData_CMockIgnoreArg_device(__LINE__) +void vkGetPrivateData_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetPrivateData_IgnoreArg_objectType() vkGetPrivateData_CMockIgnoreArg_objectType(__LINE__) +void vkGetPrivateData_CMockIgnoreArg_objectType(UNITY_LINE_TYPE cmock_line); +#define vkGetPrivateData_IgnoreArg_objectHandle() vkGetPrivateData_CMockIgnoreArg_objectHandle(__LINE__) +void vkGetPrivateData_CMockIgnoreArg_objectHandle(UNITY_LINE_TYPE cmock_line); +#define vkGetPrivateData_IgnoreArg_privateDataSlot() vkGetPrivateData_CMockIgnoreArg_privateDataSlot(__LINE__) +void vkGetPrivateData_CMockIgnoreArg_privateDataSlot(UNITY_LINE_TYPE cmock_line); +#define vkGetPrivateData_IgnoreArg_pData() vkGetPrivateData_CMockIgnoreArg_pData(__LINE__) +void vkGetPrivateData_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetEvent2_Ignore() vkCmdSetEvent2_CMockIgnore() +void vkCmdSetEvent2_CMockIgnore(void); +#define vkCmdSetEvent2_StopIgnore() vkCmdSetEvent2_CMockStopIgnore() +void vkCmdSetEvent2_CMockStopIgnore(void); +#define vkCmdSetEvent2_ExpectAnyArgs() vkCmdSetEvent2_CMockExpectAnyArgs(__LINE__) +void vkCmdSetEvent2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetEvent2_Expect(commandBuffer, event, pDependencyInfo) vkCmdSetEvent2_CMockExpect(__LINE__, commandBuffer, event, pDependencyInfo) +void vkCmdSetEvent2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo); +typedef void (* CMOCK_vkCmdSetEvent2_CALLBACK)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo, int cmock_num_calls); +void vkCmdSetEvent2_AddCallback(CMOCK_vkCmdSetEvent2_CALLBACK Callback); +void vkCmdSetEvent2_Stub(CMOCK_vkCmdSetEvent2_CALLBACK Callback); +#define vkCmdSetEvent2_StubWithCallback vkCmdSetEvent2_AddCallback +#define vkCmdSetEvent2_IgnoreArg_commandBuffer() vkCmdSetEvent2_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetEvent2_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetEvent2_IgnoreArg_event() vkCmdSetEvent2_CMockIgnoreArg_event(__LINE__) +void vkCmdSetEvent2_CMockIgnoreArg_event(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetEvent2_IgnoreArg_pDependencyInfo() vkCmdSetEvent2_CMockIgnoreArg_pDependencyInfo(__LINE__) +void vkCmdSetEvent2_CMockIgnoreArg_pDependencyInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdResetEvent2_Ignore() vkCmdResetEvent2_CMockIgnore() +void vkCmdResetEvent2_CMockIgnore(void); +#define vkCmdResetEvent2_StopIgnore() vkCmdResetEvent2_CMockStopIgnore() +void vkCmdResetEvent2_CMockStopIgnore(void); +#define vkCmdResetEvent2_ExpectAnyArgs() vkCmdResetEvent2_CMockExpectAnyArgs(__LINE__) +void vkCmdResetEvent2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdResetEvent2_Expect(commandBuffer, event, stageMask) vkCmdResetEvent2_CMockExpect(__LINE__, commandBuffer, event, stageMask) +void vkCmdResetEvent2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask); +typedef void (* CMOCK_vkCmdResetEvent2_CALLBACK)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask, int cmock_num_calls); +void vkCmdResetEvent2_AddCallback(CMOCK_vkCmdResetEvent2_CALLBACK Callback); +void vkCmdResetEvent2_Stub(CMOCK_vkCmdResetEvent2_CALLBACK Callback); +#define vkCmdResetEvent2_StubWithCallback vkCmdResetEvent2_AddCallback +#define vkCmdResetEvent2_IgnoreArg_commandBuffer() vkCmdResetEvent2_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdResetEvent2_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdResetEvent2_IgnoreArg_event() vkCmdResetEvent2_CMockIgnoreArg_event(__LINE__) +void vkCmdResetEvent2_CMockIgnoreArg_event(UNITY_LINE_TYPE cmock_line); +#define vkCmdResetEvent2_IgnoreArg_stageMask() vkCmdResetEvent2_CMockIgnoreArg_stageMask(__LINE__) +void vkCmdResetEvent2_CMockIgnoreArg_stageMask(UNITY_LINE_TYPE cmock_line); +#define vkCmdWaitEvents2_Ignore() vkCmdWaitEvents2_CMockIgnore() +void vkCmdWaitEvents2_CMockIgnore(void); +#define vkCmdWaitEvents2_StopIgnore() vkCmdWaitEvents2_CMockStopIgnore() +void vkCmdWaitEvents2_CMockStopIgnore(void); +#define vkCmdWaitEvents2_ExpectAnyArgs() vkCmdWaitEvents2_CMockExpectAnyArgs(__LINE__) +void vkCmdWaitEvents2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdWaitEvents2_Expect(commandBuffer, eventCount, pEvents, pDependencyInfos) vkCmdWaitEvents2_CMockExpect(__LINE__, commandBuffer, eventCount, pEvents, pDependencyInfos) +void vkCmdWaitEvents2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos); +typedef void (* CMOCK_vkCmdWaitEvents2_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos, int cmock_num_calls); +void vkCmdWaitEvents2_AddCallback(CMOCK_vkCmdWaitEvents2_CALLBACK Callback); +void vkCmdWaitEvents2_Stub(CMOCK_vkCmdWaitEvents2_CALLBACK Callback); +#define vkCmdWaitEvents2_StubWithCallback vkCmdWaitEvents2_AddCallback +#define vkCmdWaitEvents2_IgnoreArg_commandBuffer() vkCmdWaitEvents2_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdWaitEvents2_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdWaitEvents2_IgnoreArg_eventCount() vkCmdWaitEvents2_CMockIgnoreArg_eventCount(__LINE__) +void vkCmdWaitEvents2_CMockIgnoreArg_eventCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdWaitEvents2_IgnoreArg_pEvents() vkCmdWaitEvents2_CMockIgnoreArg_pEvents(__LINE__) +void vkCmdWaitEvents2_CMockIgnoreArg_pEvents(UNITY_LINE_TYPE cmock_line); +#define vkCmdWaitEvents2_IgnoreArg_pDependencyInfos() vkCmdWaitEvents2_CMockIgnoreArg_pDependencyInfos(__LINE__) +void vkCmdWaitEvents2_CMockIgnoreArg_pDependencyInfos(UNITY_LINE_TYPE cmock_line); +#define vkCmdPipelineBarrier2_Ignore() vkCmdPipelineBarrier2_CMockIgnore() +void vkCmdPipelineBarrier2_CMockIgnore(void); +#define vkCmdPipelineBarrier2_StopIgnore() vkCmdPipelineBarrier2_CMockStopIgnore() +void vkCmdPipelineBarrier2_CMockStopIgnore(void); +#define vkCmdPipelineBarrier2_ExpectAnyArgs() vkCmdPipelineBarrier2_CMockExpectAnyArgs(__LINE__) +void vkCmdPipelineBarrier2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdPipelineBarrier2_Expect(commandBuffer, pDependencyInfo) vkCmdPipelineBarrier2_CMockExpect(__LINE__, commandBuffer, pDependencyInfo) +void vkCmdPipelineBarrier2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo); +typedef void (* CMOCK_vkCmdPipelineBarrier2_CALLBACK)(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo, int cmock_num_calls); +void vkCmdPipelineBarrier2_AddCallback(CMOCK_vkCmdPipelineBarrier2_CALLBACK Callback); +void vkCmdPipelineBarrier2_Stub(CMOCK_vkCmdPipelineBarrier2_CALLBACK Callback); +#define vkCmdPipelineBarrier2_StubWithCallback vkCmdPipelineBarrier2_AddCallback +#define vkCmdPipelineBarrier2_IgnoreArg_commandBuffer() vkCmdPipelineBarrier2_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdPipelineBarrier2_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdPipelineBarrier2_IgnoreArg_pDependencyInfo() vkCmdPipelineBarrier2_CMockIgnoreArg_pDependencyInfo(__LINE__) +void vkCmdPipelineBarrier2_CMockIgnoreArg_pDependencyInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteTimestamp2_Ignore() vkCmdWriteTimestamp2_CMockIgnore() +void vkCmdWriteTimestamp2_CMockIgnore(void); +#define vkCmdWriteTimestamp2_StopIgnore() vkCmdWriteTimestamp2_CMockStopIgnore() +void vkCmdWriteTimestamp2_CMockStopIgnore(void); +#define vkCmdWriteTimestamp2_ExpectAnyArgs() vkCmdWriteTimestamp2_CMockExpectAnyArgs(__LINE__) +void vkCmdWriteTimestamp2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteTimestamp2_Expect(commandBuffer, stage, queryPool, query) vkCmdWriteTimestamp2_CMockExpect(__LINE__, commandBuffer, stage, queryPool, query) +void vkCmdWriteTimestamp2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query); +typedef void (* CMOCK_vkCmdWriteTimestamp2_CALLBACK)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query, int cmock_num_calls); +void vkCmdWriteTimestamp2_AddCallback(CMOCK_vkCmdWriteTimestamp2_CALLBACK Callback); +void vkCmdWriteTimestamp2_Stub(CMOCK_vkCmdWriteTimestamp2_CALLBACK Callback); +#define vkCmdWriteTimestamp2_StubWithCallback vkCmdWriteTimestamp2_AddCallback +#define vkCmdWriteTimestamp2_IgnoreArg_commandBuffer() vkCmdWriteTimestamp2_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdWriteTimestamp2_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteTimestamp2_IgnoreArg_stage() vkCmdWriteTimestamp2_CMockIgnoreArg_stage(__LINE__) +void vkCmdWriteTimestamp2_CMockIgnoreArg_stage(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteTimestamp2_IgnoreArg_queryPool() vkCmdWriteTimestamp2_CMockIgnoreArg_queryPool(__LINE__) +void vkCmdWriteTimestamp2_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteTimestamp2_IgnoreArg_query() vkCmdWriteTimestamp2_CMockIgnoreArg_query(__LINE__) +void vkCmdWriteTimestamp2_CMockIgnoreArg_query(UNITY_LINE_TYPE cmock_line); +#define vkQueueSubmit2_IgnoreAndReturn(cmock_retval) vkQueueSubmit2_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkQueueSubmit2_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkQueueSubmit2_StopIgnore() vkQueueSubmit2_CMockStopIgnore() +void vkQueueSubmit2_CMockStopIgnore(void); +#define vkQueueSubmit2_ExpectAnyArgsAndReturn(cmock_retval) vkQueueSubmit2_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkQueueSubmit2_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkQueueSubmit2_ExpectAndReturn(queue, submitCount, pSubmits, fence, cmock_retval) vkQueueSubmit2_CMockExpectAndReturn(__LINE__, queue, submitCount, pSubmits, fence, cmock_retval) +void vkQueueSubmit2_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkQueueSubmit2_CALLBACK)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence, int cmock_num_calls); +void vkQueueSubmit2_AddCallback(CMOCK_vkQueueSubmit2_CALLBACK Callback); +void vkQueueSubmit2_Stub(CMOCK_vkQueueSubmit2_CALLBACK Callback); +#define vkQueueSubmit2_StubWithCallback vkQueueSubmit2_AddCallback +#define vkQueueSubmit2_IgnoreArg_queue() vkQueueSubmit2_CMockIgnoreArg_queue(__LINE__) +void vkQueueSubmit2_CMockIgnoreArg_queue(UNITY_LINE_TYPE cmock_line); +#define vkQueueSubmit2_IgnoreArg_submitCount() vkQueueSubmit2_CMockIgnoreArg_submitCount(__LINE__) +void vkQueueSubmit2_CMockIgnoreArg_submitCount(UNITY_LINE_TYPE cmock_line); +#define vkQueueSubmit2_IgnoreArg_pSubmits() vkQueueSubmit2_CMockIgnoreArg_pSubmits(__LINE__) +void vkQueueSubmit2_CMockIgnoreArg_pSubmits(UNITY_LINE_TYPE cmock_line); +#define vkQueueSubmit2_IgnoreArg_fence() vkQueueSubmit2_CMockIgnoreArg_fence(__LINE__) +void vkQueueSubmit2_CMockIgnoreArg_fence(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyBuffer2_Ignore() vkCmdCopyBuffer2_CMockIgnore() +void vkCmdCopyBuffer2_CMockIgnore(void); +#define vkCmdCopyBuffer2_StopIgnore() vkCmdCopyBuffer2_CMockStopIgnore() +void vkCmdCopyBuffer2_CMockStopIgnore(void); +#define vkCmdCopyBuffer2_ExpectAnyArgs() vkCmdCopyBuffer2_CMockExpectAnyArgs(__LINE__) +void vkCmdCopyBuffer2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyBuffer2_Expect(commandBuffer, pCopyBufferInfo) vkCmdCopyBuffer2_CMockExpect(__LINE__, commandBuffer, pCopyBufferInfo) +void vkCmdCopyBuffer2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo); +typedef void (* CMOCK_vkCmdCopyBuffer2_CALLBACK)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo, int cmock_num_calls); +void vkCmdCopyBuffer2_AddCallback(CMOCK_vkCmdCopyBuffer2_CALLBACK Callback); +void vkCmdCopyBuffer2_Stub(CMOCK_vkCmdCopyBuffer2_CALLBACK Callback); +#define vkCmdCopyBuffer2_StubWithCallback vkCmdCopyBuffer2_AddCallback +#define vkCmdCopyBuffer2_IgnoreArg_commandBuffer() vkCmdCopyBuffer2_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdCopyBuffer2_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyBuffer2_IgnoreArg_pCopyBufferInfo() vkCmdCopyBuffer2_CMockIgnoreArg_pCopyBufferInfo(__LINE__) +void vkCmdCopyBuffer2_CMockIgnoreArg_pCopyBufferInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyImage2_Ignore() vkCmdCopyImage2_CMockIgnore() +void vkCmdCopyImage2_CMockIgnore(void); +#define vkCmdCopyImage2_StopIgnore() vkCmdCopyImage2_CMockStopIgnore() +void vkCmdCopyImage2_CMockStopIgnore(void); +#define vkCmdCopyImage2_ExpectAnyArgs() vkCmdCopyImage2_CMockExpectAnyArgs(__LINE__) +void vkCmdCopyImage2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyImage2_Expect(commandBuffer, pCopyImageInfo) vkCmdCopyImage2_CMockExpect(__LINE__, commandBuffer, pCopyImageInfo) +void vkCmdCopyImage2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo); +typedef void (* CMOCK_vkCmdCopyImage2_CALLBACK)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo, int cmock_num_calls); +void vkCmdCopyImage2_AddCallback(CMOCK_vkCmdCopyImage2_CALLBACK Callback); +void vkCmdCopyImage2_Stub(CMOCK_vkCmdCopyImage2_CALLBACK Callback); +#define vkCmdCopyImage2_StubWithCallback vkCmdCopyImage2_AddCallback +#define vkCmdCopyImage2_IgnoreArg_commandBuffer() vkCmdCopyImage2_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdCopyImage2_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyImage2_IgnoreArg_pCopyImageInfo() vkCmdCopyImage2_CMockIgnoreArg_pCopyImageInfo(__LINE__) +void vkCmdCopyImage2_CMockIgnoreArg_pCopyImageInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyBufferToImage2_Ignore() vkCmdCopyBufferToImage2_CMockIgnore() +void vkCmdCopyBufferToImage2_CMockIgnore(void); +#define vkCmdCopyBufferToImage2_StopIgnore() vkCmdCopyBufferToImage2_CMockStopIgnore() +void vkCmdCopyBufferToImage2_CMockStopIgnore(void); +#define vkCmdCopyBufferToImage2_ExpectAnyArgs() vkCmdCopyBufferToImage2_CMockExpectAnyArgs(__LINE__) +void vkCmdCopyBufferToImage2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyBufferToImage2_Expect(commandBuffer, pCopyBufferToImageInfo) vkCmdCopyBufferToImage2_CMockExpect(__LINE__, commandBuffer, pCopyBufferToImageInfo) +void vkCmdCopyBufferToImage2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); +typedef void (* CMOCK_vkCmdCopyBufferToImage2_CALLBACK)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo, int cmock_num_calls); +void vkCmdCopyBufferToImage2_AddCallback(CMOCK_vkCmdCopyBufferToImage2_CALLBACK Callback); +void vkCmdCopyBufferToImage2_Stub(CMOCK_vkCmdCopyBufferToImage2_CALLBACK Callback); +#define vkCmdCopyBufferToImage2_StubWithCallback vkCmdCopyBufferToImage2_AddCallback +#define vkCmdCopyBufferToImage2_IgnoreArg_commandBuffer() vkCmdCopyBufferToImage2_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdCopyBufferToImage2_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyBufferToImage2_IgnoreArg_pCopyBufferToImageInfo() vkCmdCopyBufferToImage2_CMockIgnoreArg_pCopyBufferToImageInfo(__LINE__) +void vkCmdCopyBufferToImage2_CMockIgnoreArg_pCopyBufferToImageInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyImageToBuffer2_Ignore() vkCmdCopyImageToBuffer2_CMockIgnore() +void vkCmdCopyImageToBuffer2_CMockIgnore(void); +#define vkCmdCopyImageToBuffer2_StopIgnore() vkCmdCopyImageToBuffer2_CMockStopIgnore() +void vkCmdCopyImageToBuffer2_CMockStopIgnore(void); +#define vkCmdCopyImageToBuffer2_ExpectAnyArgs() vkCmdCopyImageToBuffer2_CMockExpectAnyArgs(__LINE__) +void vkCmdCopyImageToBuffer2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyImageToBuffer2_Expect(commandBuffer, pCopyImageToBufferInfo) vkCmdCopyImageToBuffer2_CMockExpect(__LINE__, commandBuffer, pCopyImageToBufferInfo) +void vkCmdCopyImageToBuffer2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); +typedef void (* CMOCK_vkCmdCopyImageToBuffer2_CALLBACK)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo, int cmock_num_calls); +void vkCmdCopyImageToBuffer2_AddCallback(CMOCK_vkCmdCopyImageToBuffer2_CALLBACK Callback); +void vkCmdCopyImageToBuffer2_Stub(CMOCK_vkCmdCopyImageToBuffer2_CALLBACK Callback); +#define vkCmdCopyImageToBuffer2_StubWithCallback vkCmdCopyImageToBuffer2_AddCallback +#define vkCmdCopyImageToBuffer2_IgnoreArg_commandBuffer() vkCmdCopyImageToBuffer2_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdCopyImageToBuffer2_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyImageToBuffer2_IgnoreArg_pCopyImageToBufferInfo() vkCmdCopyImageToBuffer2_CMockIgnoreArg_pCopyImageToBufferInfo(__LINE__) +void vkCmdCopyImageToBuffer2_CMockIgnoreArg_pCopyImageToBufferInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdBlitImage2_Ignore() vkCmdBlitImage2_CMockIgnore() +void vkCmdBlitImage2_CMockIgnore(void); +#define vkCmdBlitImage2_StopIgnore() vkCmdBlitImage2_CMockStopIgnore() +void vkCmdBlitImage2_CMockStopIgnore(void); +#define vkCmdBlitImage2_ExpectAnyArgs() vkCmdBlitImage2_CMockExpectAnyArgs(__LINE__) +void vkCmdBlitImage2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBlitImage2_Expect(commandBuffer, pBlitImageInfo) vkCmdBlitImage2_CMockExpect(__LINE__, commandBuffer, pBlitImageInfo) +void vkCmdBlitImage2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo); +typedef void (* CMOCK_vkCmdBlitImage2_CALLBACK)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo, int cmock_num_calls); +void vkCmdBlitImage2_AddCallback(CMOCK_vkCmdBlitImage2_CALLBACK Callback); +void vkCmdBlitImage2_Stub(CMOCK_vkCmdBlitImage2_CALLBACK Callback); +#define vkCmdBlitImage2_StubWithCallback vkCmdBlitImage2_AddCallback +#define vkCmdBlitImage2_IgnoreArg_commandBuffer() vkCmdBlitImage2_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBlitImage2_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBlitImage2_IgnoreArg_pBlitImageInfo() vkCmdBlitImage2_CMockIgnoreArg_pBlitImageInfo(__LINE__) +void vkCmdBlitImage2_CMockIgnoreArg_pBlitImageInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdResolveImage2_Ignore() vkCmdResolveImage2_CMockIgnore() +void vkCmdResolveImage2_CMockIgnore(void); +#define vkCmdResolveImage2_StopIgnore() vkCmdResolveImage2_CMockStopIgnore() +void vkCmdResolveImage2_CMockStopIgnore(void); +#define vkCmdResolveImage2_ExpectAnyArgs() vkCmdResolveImage2_CMockExpectAnyArgs(__LINE__) +void vkCmdResolveImage2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdResolveImage2_Expect(commandBuffer, pResolveImageInfo) vkCmdResolveImage2_CMockExpect(__LINE__, commandBuffer, pResolveImageInfo) +void vkCmdResolveImage2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo); +typedef void (* CMOCK_vkCmdResolveImage2_CALLBACK)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo, int cmock_num_calls); +void vkCmdResolveImage2_AddCallback(CMOCK_vkCmdResolveImage2_CALLBACK Callback); +void vkCmdResolveImage2_Stub(CMOCK_vkCmdResolveImage2_CALLBACK Callback); +#define vkCmdResolveImage2_StubWithCallback vkCmdResolveImage2_AddCallback +#define vkCmdResolveImage2_IgnoreArg_commandBuffer() vkCmdResolveImage2_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdResolveImage2_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdResolveImage2_IgnoreArg_pResolveImageInfo() vkCmdResolveImage2_CMockIgnoreArg_pResolveImageInfo(__LINE__) +void vkCmdResolveImage2_CMockIgnoreArg_pResolveImageInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginRendering_Ignore() vkCmdBeginRendering_CMockIgnore() +void vkCmdBeginRendering_CMockIgnore(void); +#define vkCmdBeginRendering_StopIgnore() vkCmdBeginRendering_CMockStopIgnore() +void vkCmdBeginRendering_CMockStopIgnore(void); +#define vkCmdBeginRendering_ExpectAnyArgs() vkCmdBeginRendering_CMockExpectAnyArgs(__LINE__) +void vkCmdBeginRendering_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginRendering_Expect(commandBuffer, pRenderingInfo) vkCmdBeginRendering_CMockExpect(__LINE__, commandBuffer, pRenderingInfo) +void vkCmdBeginRendering_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo); +typedef void (* CMOCK_vkCmdBeginRendering_CALLBACK)(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo, int cmock_num_calls); +void vkCmdBeginRendering_AddCallback(CMOCK_vkCmdBeginRendering_CALLBACK Callback); +void vkCmdBeginRendering_Stub(CMOCK_vkCmdBeginRendering_CALLBACK Callback); +#define vkCmdBeginRendering_StubWithCallback vkCmdBeginRendering_AddCallback +#define vkCmdBeginRendering_IgnoreArg_commandBuffer() vkCmdBeginRendering_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBeginRendering_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginRendering_IgnoreArg_pRenderingInfo() vkCmdBeginRendering_CMockIgnoreArg_pRenderingInfo(__LINE__) +void vkCmdBeginRendering_CMockIgnoreArg_pRenderingInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndRendering_Ignore() vkCmdEndRendering_CMockIgnore() +void vkCmdEndRendering_CMockIgnore(void); +#define vkCmdEndRendering_StopIgnore() vkCmdEndRendering_CMockStopIgnore() +void vkCmdEndRendering_CMockStopIgnore(void); +#define vkCmdEndRendering_ExpectAnyArgs() vkCmdEndRendering_CMockExpectAnyArgs(__LINE__) +void vkCmdEndRendering_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndRendering_Expect(commandBuffer) vkCmdEndRendering_CMockExpect(__LINE__, commandBuffer) +void vkCmdEndRendering_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer); +typedef void (* CMOCK_vkCmdEndRendering_CALLBACK)(VkCommandBuffer commandBuffer, int cmock_num_calls); +void vkCmdEndRendering_AddCallback(CMOCK_vkCmdEndRendering_CALLBACK Callback); +void vkCmdEndRendering_Stub(CMOCK_vkCmdEndRendering_CALLBACK Callback); +#define vkCmdEndRendering_StubWithCallback vkCmdEndRendering_AddCallback +#define vkCmdEndRendering_IgnoreArg_commandBuffer() vkCmdEndRendering_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdEndRendering_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCullMode_Ignore() vkCmdSetCullMode_CMockIgnore() +void vkCmdSetCullMode_CMockIgnore(void); +#define vkCmdSetCullMode_StopIgnore() vkCmdSetCullMode_CMockStopIgnore() +void vkCmdSetCullMode_CMockStopIgnore(void); +#define vkCmdSetCullMode_ExpectAnyArgs() vkCmdSetCullMode_CMockExpectAnyArgs(__LINE__) +void vkCmdSetCullMode_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCullMode_Expect(commandBuffer, cullMode) vkCmdSetCullMode_CMockExpect(__LINE__, commandBuffer, cullMode) +void vkCmdSetCullMode_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkCullModeFlags cullMode); +typedef void (* CMOCK_vkCmdSetCullMode_CALLBACK)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode, int cmock_num_calls); +void vkCmdSetCullMode_AddCallback(CMOCK_vkCmdSetCullMode_CALLBACK Callback); +void vkCmdSetCullMode_Stub(CMOCK_vkCmdSetCullMode_CALLBACK Callback); +#define vkCmdSetCullMode_StubWithCallback vkCmdSetCullMode_AddCallback +#define vkCmdSetCullMode_IgnoreArg_commandBuffer() vkCmdSetCullMode_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetCullMode_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCullMode_IgnoreArg_cullMode() vkCmdSetCullMode_CMockIgnoreArg_cullMode(__LINE__) +void vkCmdSetCullMode_CMockIgnoreArg_cullMode(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetFrontFace_Ignore() vkCmdSetFrontFace_CMockIgnore() +void vkCmdSetFrontFace_CMockIgnore(void); +#define vkCmdSetFrontFace_StopIgnore() vkCmdSetFrontFace_CMockStopIgnore() +void vkCmdSetFrontFace_CMockStopIgnore(void); +#define vkCmdSetFrontFace_ExpectAnyArgs() vkCmdSetFrontFace_CMockExpectAnyArgs(__LINE__) +void vkCmdSetFrontFace_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetFrontFace_Expect(commandBuffer, frontFace) vkCmdSetFrontFace_CMockExpect(__LINE__, commandBuffer, frontFace) +void vkCmdSetFrontFace_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkFrontFace frontFace); +typedef void (* CMOCK_vkCmdSetFrontFace_CALLBACK)(VkCommandBuffer commandBuffer, VkFrontFace frontFace, int cmock_num_calls); +void vkCmdSetFrontFace_AddCallback(CMOCK_vkCmdSetFrontFace_CALLBACK Callback); +void vkCmdSetFrontFace_Stub(CMOCK_vkCmdSetFrontFace_CALLBACK Callback); +#define vkCmdSetFrontFace_StubWithCallback vkCmdSetFrontFace_AddCallback +#define vkCmdSetFrontFace_IgnoreArg_commandBuffer() vkCmdSetFrontFace_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetFrontFace_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetFrontFace_IgnoreArg_frontFace() vkCmdSetFrontFace_CMockIgnoreArg_frontFace(__LINE__) +void vkCmdSetFrontFace_CMockIgnoreArg_frontFace(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetPrimitiveTopology_Ignore() vkCmdSetPrimitiveTopology_CMockIgnore() +void vkCmdSetPrimitiveTopology_CMockIgnore(void); +#define vkCmdSetPrimitiveTopology_StopIgnore() vkCmdSetPrimitiveTopology_CMockStopIgnore() +void vkCmdSetPrimitiveTopology_CMockStopIgnore(void); +#define vkCmdSetPrimitiveTopology_ExpectAnyArgs() vkCmdSetPrimitiveTopology_CMockExpectAnyArgs(__LINE__) +void vkCmdSetPrimitiveTopology_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetPrimitiveTopology_Expect(commandBuffer, primitiveTopology) vkCmdSetPrimitiveTopology_CMockExpect(__LINE__, commandBuffer, primitiveTopology) +void vkCmdSetPrimitiveTopology_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology); +typedef void (* CMOCK_vkCmdSetPrimitiveTopology_CALLBACK)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology, int cmock_num_calls); +void vkCmdSetPrimitiveTopology_AddCallback(CMOCK_vkCmdSetPrimitiveTopology_CALLBACK Callback); +void vkCmdSetPrimitiveTopology_Stub(CMOCK_vkCmdSetPrimitiveTopology_CALLBACK Callback); +#define vkCmdSetPrimitiveTopology_StubWithCallback vkCmdSetPrimitiveTopology_AddCallback +#define vkCmdSetPrimitiveTopology_IgnoreArg_commandBuffer() vkCmdSetPrimitiveTopology_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetPrimitiveTopology_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetPrimitiveTopology_IgnoreArg_primitiveTopology() vkCmdSetPrimitiveTopology_CMockIgnoreArg_primitiveTopology(__LINE__) +void vkCmdSetPrimitiveTopology_CMockIgnoreArg_primitiveTopology(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewportWithCount_Ignore() vkCmdSetViewportWithCount_CMockIgnore() +void vkCmdSetViewportWithCount_CMockIgnore(void); +#define vkCmdSetViewportWithCount_StopIgnore() vkCmdSetViewportWithCount_CMockStopIgnore() +void vkCmdSetViewportWithCount_CMockStopIgnore(void); +#define vkCmdSetViewportWithCount_ExpectAnyArgs() vkCmdSetViewportWithCount_CMockExpectAnyArgs(__LINE__) +void vkCmdSetViewportWithCount_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewportWithCount_Expect(commandBuffer, viewportCount, pViewports) vkCmdSetViewportWithCount_CMockExpect(__LINE__, commandBuffer, viewportCount, pViewports) +void vkCmdSetViewportWithCount_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports); +typedef void (* CMOCK_vkCmdSetViewportWithCount_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports, int cmock_num_calls); +void vkCmdSetViewportWithCount_AddCallback(CMOCK_vkCmdSetViewportWithCount_CALLBACK Callback); +void vkCmdSetViewportWithCount_Stub(CMOCK_vkCmdSetViewportWithCount_CALLBACK Callback); +#define vkCmdSetViewportWithCount_StubWithCallback vkCmdSetViewportWithCount_AddCallback +#define vkCmdSetViewportWithCount_IgnoreArg_commandBuffer() vkCmdSetViewportWithCount_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetViewportWithCount_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewportWithCount_IgnoreArg_viewportCount() vkCmdSetViewportWithCount_CMockIgnoreArg_viewportCount(__LINE__) +void vkCmdSetViewportWithCount_CMockIgnoreArg_viewportCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewportWithCount_IgnoreArg_pViewports() vkCmdSetViewportWithCount_CMockIgnoreArg_pViewports(__LINE__) +void vkCmdSetViewportWithCount_CMockIgnoreArg_pViewports(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetScissorWithCount_Ignore() vkCmdSetScissorWithCount_CMockIgnore() +void vkCmdSetScissorWithCount_CMockIgnore(void); +#define vkCmdSetScissorWithCount_StopIgnore() vkCmdSetScissorWithCount_CMockStopIgnore() +void vkCmdSetScissorWithCount_CMockStopIgnore(void); +#define vkCmdSetScissorWithCount_ExpectAnyArgs() vkCmdSetScissorWithCount_CMockExpectAnyArgs(__LINE__) +void vkCmdSetScissorWithCount_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetScissorWithCount_Expect(commandBuffer, scissorCount, pScissors) vkCmdSetScissorWithCount_CMockExpect(__LINE__, commandBuffer, scissorCount, pScissors) +void vkCmdSetScissorWithCount_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors); +typedef void (* CMOCK_vkCmdSetScissorWithCount_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors, int cmock_num_calls); +void vkCmdSetScissorWithCount_AddCallback(CMOCK_vkCmdSetScissorWithCount_CALLBACK Callback); +void vkCmdSetScissorWithCount_Stub(CMOCK_vkCmdSetScissorWithCount_CALLBACK Callback); +#define vkCmdSetScissorWithCount_StubWithCallback vkCmdSetScissorWithCount_AddCallback +#define vkCmdSetScissorWithCount_IgnoreArg_commandBuffer() vkCmdSetScissorWithCount_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetScissorWithCount_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetScissorWithCount_IgnoreArg_scissorCount() vkCmdSetScissorWithCount_CMockIgnoreArg_scissorCount(__LINE__) +void vkCmdSetScissorWithCount_CMockIgnoreArg_scissorCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetScissorWithCount_IgnoreArg_pScissors() vkCmdSetScissorWithCount_CMockIgnoreArg_pScissors(__LINE__) +void vkCmdSetScissorWithCount_CMockIgnoreArg_pScissors(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindVertexBuffers2_Ignore() vkCmdBindVertexBuffers2_CMockIgnore() +void vkCmdBindVertexBuffers2_CMockIgnore(void); +#define vkCmdBindVertexBuffers2_StopIgnore() vkCmdBindVertexBuffers2_CMockStopIgnore() +void vkCmdBindVertexBuffers2_CMockStopIgnore(void); +#define vkCmdBindVertexBuffers2_ExpectAnyArgs() vkCmdBindVertexBuffers2_CMockExpectAnyArgs(__LINE__) +void vkCmdBindVertexBuffers2_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindVertexBuffers2_Expect(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides) vkCmdBindVertexBuffers2_CMockExpect(__LINE__, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides) +void vkCmdBindVertexBuffers2_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides); +typedef void (* CMOCK_vkCmdBindVertexBuffers2_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides, int cmock_num_calls); +void vkCmdBindVertexBuffers2_AddCallback(CMOCK_vkCmdBindVertexBuffers2_CALLBACK Callback); +void vkCmdBindVertexBuffers2_Stub(CMOCK_vkCmdBindVertexBuffers2_CALLBACK Callback); +#define vkCmdBindVertexBuffers2_StubWithCallback vkCmdBindVertexBuffers2_AddCallback +#define vkCmdBindVertexBuffers2_IgnoreArg_commandBuffer() vkCmdBindVertexBuffers2_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBindVertexBuffers2_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindVertexBuffers2_IgnoreArg_firstBinding() vkCmdBindVertexBuffers2_CMockIgnoreArg_firstBinding(__LINE__) +void vkCmdBindVertexBuffers2_CMockIgnoreArg_firstBinding(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindVertexBuffers2_IgnoreArg_bindingCount() vkCmdBindVertexBuffers2_CMockIgnoreArg_bindingCount(__LINE__) +void vkCmdBindVertexBuffers2_CMockIgnoreArg_bindingCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindVertexBuffers2_IgnoreArg_pBuffers() vkCmdBindVertexBuffers2_CMockIgnoreArg_pBuffers(__LINE__) +void vkCmdBindVertexBuffers2_CMockIgnoreArg_pBuffers(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindVertexBuffers2_IgnoreArg_pOffsets() vkCmdBindVertexBuffers2_CMockIgnoreArg_pOffsets(__LINE__) +void vkCmdBindVertexBuffers2_CMockIgnoreArg_pOffsets(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindVertexBuffers2_IgnoreArg_pSizes() vkCmdBindVertexBuffers2_CMockIgnoreArg_pSizes(__LINE__) +void vkCmdBindVertexBuffers2_CMockIgnoreArg_pSizes(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindVertexBuffers2_IgnoreArg_pStrides() vkCmdBindVertexBuffers2_CMockIgnoreArg_pStrides(__LINE__) +void vkCmdBindVertexBuffers2_CMockIgnoreArg_pStrides(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthTestEnable_Ignore() vkCmdSetDepthTestEnable_CMockIgnore() +void vkCmdSetDepthTestEnable_CMockIgnore(void); +#define vkCmdSetDepthTestEnable_StopIgnore() vkCmdSetDepthTestEnable_CMockStopIgnore() +void vkCmdSetDepthTestEnable_CMockStopIgnore(void); +#define vkCmdSetDepthTestEnable_ExpectAnyArgs() vkCmdSetDepthTestEnable_CMockExpectAnyArgs(__LINE__) +void vkCmdSetDepthTestEnable_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthTestEnable_Expect(commandBuffer, depthTestEnable) vkCmdSetDepthTestEnable_CMockExpect(__LINE__, commandBuffer, depthTestEnable) +void vkCmdSetDepthTestEnable_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 depthTestEnable); +typedef void (* CMOCK_vkCmdSetDepthTestEnable_CALLBACK)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable, int cmock_num_calls); +void vkCmdSetDepthTestEnable_AddCallback(CMOCK_vkCmdSetDepthTestEnable_CALLBACK Callback); +void vkCmdSetDepthTestEnable_Stub(CMOCK_vkCmdSetDepthTestEnable_CALLBACK Callback); +#define vkCmdSetDepthTestEnable_StubWithCallback vkCmdSetDepthTestEnable_AddCallback +#define vkCmdSetDepthTestEnable_IgnoreArg_commandBuffer() vkCmdSetDepthTestEnable_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetDepthTestEnable_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthTestEnable_IgnoreArg_depthTestEnable() vkCmdSetDepthTestEnable_CMockIgnoreArg_depthTestEnable(__LINE__) +void vkCmdSetDepthTestEnable_CMockIgnoreArg_depthTestEnable(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthWriteEnable_Ignore() vkCmdSetDepthWriteEnable_CMockIgnore() +void vkCmdSetDepthWriteEnable_CMockIgnore(void); +#define vkCmdSetDepthWriteEnable_StopIgnore() vkCmdSetDepthWriteEnable_CMockStopIgnore() +void vkCmdSetDepthWriteEnable_CMockStopIgnore(void); +#define vkCmdSetDepthWriteEnable_ExpectAnyArgs() vkCmdSetDepthWriteEnable_CMockExpectAnyArgs(__LINE__) +void vkCmdSetDepthWriteEnable_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthWriteEnable_Expect(commandBuffer, depthWriteEnable) vkCmdSetDepthWriteEnable_CMockExpect(__LINE__, commandBuffer, depthWriteEnable) +void vkCmdSetDepthWriteEnable_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); +typedef void (* CMOCK_vkCmdSetDepthWriteEnable_CALLBACK)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable, int cmock_num_calls); +void vkCmdSetDepthWriteEnable_AddCallback(CMOCK_vkCmdSetDepthWriteEnable_CALLBACK Callback); +void vkCmdSetDepthWriteEnable_Stub(CMOCK_vkCmdSetDepthWriteEnable_CALLBACK Callback); +#define vkCmdSetDepthWriteEnable_StubWithCallback vkCmdSetDepthWriteEnable_AddCallback +#define vkCmdSetDepthWriteEnable_IgnoreArg_commandBuffer() vkCmdSetDepthWriteEnable_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetDepthWriteEnable_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthWriteEnable_IgnoreArg_depthWriteEnable() vkCmdSetDepthWriteEnable_CMockIgnoreArg_depthWriteEnable(__LINE__) +void vkCmdSetDepthWriteEnable_CMockIgnoreArg_depthWriteEnable(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthCompareOp_Ignore() vkCmdSetDepthCompareOp_CMockIgnore() +void vkCmdSetDepthCompareOp_CMockIgnore(void); +#define vkCmdSetDepthCompareOp_StopIgnore() vkCmdSetDepthCompareOp_CMockStopIgnore() +void vkCmdSetDepthCompareOp_CMockStopIgnore(void); +#define vkCmdSetDepthCompareOp_ExpectAnyArgs() vkCmdSetDepthCompareOp_CMockExpectAnyArgs(__LINE__) +void vkCmdSetDepthCompareOp_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthCompareOp_Expect(commandBuffer, depthCompareOp) vkCmdSetDepthCompareOp_CMockExpect(__LINE__, commandBuffer, depthCompareOp) +void vkCmdSetDepthCompareOp_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp); +typedef void (* CMOCK_vkCmdSetDepthCompareOp_CALLBACK)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp, int cmock_num_calls); +void vkCmdSetDepthCompareOp_AddCallback(CMOCK_vkCmdSetDepthCompareOp_CALLBACK Callback); +void vkCmdSetDepthCompareOp_Stub(CMOCK_vkCmdSetDepthCompareOp_CALLBACK Callback); +#define vkCmdSetDepthCompareOp_StubWithCallback vkCmdSetDepthCompareOp_AddCallback +#define vkCmdSetDepthCompareOp_IgnoreArg_commandBuffer() vkCmdSetDepthCompareOp_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetDepthCompareOp_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthCompareOp_IgnoreArg_depthCompareOp() vkCmdSetDepthCompareOp_CMockIgnoreArg_depthCompareOp(__LINE__) +void vkCmdSetDepthCompareOp_CMockIgnoreArg_depthCompareOp(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthBoundsTestEnable_Ignore() vkCmdSetDepthBoundsTestEnable_CMockIgnore() +void vkCmdSetDepthBoundsTestEnable_CMockIgnore(void); +#define vkCmdSetDepthBoundsTestEnable_StopIgnore() vkCmdSetDepthBoundsTestEnable_CMockStopIgnore() +void vkCmdSetDepthBoundsTestEnable_CMockStopIgnore(void); +#define vkCmdSetDepthBoundsTestEnable_ExpectAnyArgs() vkCmdSetDepthBoundsTestEnable_CMockExpectAnyArgs(__LINE__) +void vkCmdSetDepthBoundsTestEnable_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthBoundsTestEnable_Expect(commandBuffer, depthBoundsTestEnable) vkCmdSetDepthBoundsTestEnable_CMockExpect(__LINE__, commandBuffer, depthBoundsTestEnable) +void vkCmdSetDepthBoundsTestEnable_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable); +typedef void (* CMOCK_vkCmdSetDepthBoundsTestEnable_CALLBACK)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable, int cmock_num_calls); +void vkCmdSetDepthBoundsTestEnable_AddCallback(CMOCK_vkCmdSetDepthBoundsTestEnable_CALLBACK Callback); +void vkCmdSetDepthBoundsTestEnable_Stub(CMOCK_vkCmdSetDepthBoundsTestEnable_CALLBACK Callback); +#define vkCmdSetDepthBoundsTestEnable_StubWithCallback vkCmdSetDepthBoundsTestEnable_AddCallback +#define vkCmdSetDepthBoundsTestEnable_IgnoreArg_commandBuffer() vkCmdSetDepthBoundsTestEnable_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetDepthBoundsTestEnable_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthBoundsTestEnable_IgnoreArg_depthBoundsTestEnable() vkCmdSetDepthBoundsTestEnable_CMockIgnoreArg_depthBoundsTestEnable(__LINE__) +void vkCmdSetDepthBoundsTestEnable_CMockIgnoreArg_depthBoundsTestEnable(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilTestEnable_Ignore() vkCmdSetStencilTestEnable_CMockIgnore() +void vkCmdSetStencilTestEnable_CMockIgnore(void); +#define vkCmdSetStencilTestEnable_StopIgnore() vkCmdSetStencilTestEnable_CMockStopIgnore() +void vkCmdSetStencilTestEnable_CMockStopIgnore(void); +#define vkCmdSetStencilTestEnable_ExpectAnyArgs() vkCmdSetStencilTestEnable_CMockExpectAnyArgs(__LINE__) +void vkCmdSetStencilTestEnable_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilTestEnable_Expect(commandBuffer, stencilTestEnable) vkCmdSetStencilTestEnable_CMockExpect(__LINE__, commandBuffer, stencilTestEnable) +void vkCmdSetStencilTestEnable_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable); +typedef void (* CMOCK_vkCmdSetStencilTestEnable_CALLBACK)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable, int cmock_num_calls); +void vkCmdSetStencilTestEnable_AddCallback(CMOCK_vkCmdSetStencilTestEnable_CALLBACK Callback); +void vkCmdSetStencilTestEnable_Stub(CMOCK_vkCmdSetStencilTestEnable_CALLBACK Callback); +#define vkCmdSetStencilTestEnable_StubWithCallback vkCmdSetStencilTestEnable_AddCallback +#define vkCmdSetStencilTestEnable_IgnoreArg_commandBuffer() vkCmdSetStencilTestEnable_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetStencilTestEnable_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilTestEnable_IgnoreArg_stencilTestEnable() vkCmdSetStencilTestEnable_CMockIgnoreArg_stencilTestEnable(__LINE__) +void vkCmdSetStencilTestEnable_CMockIgnoreArg_stencilTestEnable(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilOp_Ignore() vkCmdSetStencilOp_CMockIgnore() +void vkCmdSetStencilOp_CMockIgnore(void); +#define vkCmdSetStencilOp_StopIgnore() vkCmdSetStencilOp_CMockStopIgnore() +void vkCmdSetStencilOp_CMockStopIgnore(void); +#define vkCmdSetStencilOp_ExpectAnyArgs() vkCmdSetStencilOp_CMockExpectAnyArgs(__LINE__) +void vkCmdSetStencilOp_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilOp_Expect(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp) vkCmdSetStencilOp_CMockExpect(__LINE__, commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp) +void vkCmdSetStencilOp_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp); +typedef void (* CMOCK_vkCmdSetStencilOp_CALLBACK)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp, int cmock_num_calls); +void vkCmdSetStencilOp_AddCallback(CMOCK_vkCmdSetStencilOp_CALLBACK Callback); +void vkCmdSetStencilOp_Stub(CMOCK_vkCmdSetStencilOp_CALLBACK Callback); +#define vkCmdSetStencilOp_StubWithCallback vkCmdSetStencilOp_AddCallback +#define vkCmdSetStencilOp_IgnoreArg_commandBuffer() vkCmdSetStencilOp_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetStencilOp_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilOp_IgnoreArg_faceMask() vkCmdSetStencilOp_CMockIgnoreArg_faceMask(__LINE__) +void vkCmdSetStencilOp_CMockIgnoreArg_faceMask(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilOp_IgnoreArg_failOp() vkCmdSetStencilOp_CMockIgnoreArg_failOp(__LINE__) +void vkCmdSetStencilOp_CMockIgnoreArg_failOp(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilOp_IgnoreArg_passOp() vkCmdSetStencilOp_CMockIgnoreArg_passOp(__LINE__) +void vkCmdSetStencilOp_CMockIgnoreArg_passOp(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilOp_IgnoreArg_depthFailOp() vkCmdSetStencilOp_CMockIgnoreArg_depthFailOp(__LINE__) +void vkCmdSetStencilOp_CMockIgnoreArg_depthFailOp(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilOp_IgnoreArg_compareOp() vkCmdSetStencilOp_CMockIgnoreArg_compareOp(__LINE__) +void vkCmdSetStencilOp_CMockIgnoreArg_compareOp(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetRasterizerDiscardEnable_Ignore() vkCmdSetRasterizerDiscardEnable_CMockIgnore() +void vkCmdSetRasterizerDiscardEnable_CMockIgnore(void); +#define vkCmdSetRasterizerDiscardEnable_StopIgnore() vkCmdSetRasterizerDiscardEnable_CMockStopIgnore() +void vkCmdSetRasterizerDiscardEnable_CMockStopIgnore(void); +#define vkCmdSetRasterizerDiscardEnable_ExpectAnyArgs() vkCmdSetRasterizerDiscardEnable_CMockExpectAnyArgs(__LINE__) +void vkCmdSetRasterizerDiscardEnable_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetRasterizerDiscardEnable_Expect(commandBuffer, rasterizerDiscardEnable) vkCmdSetRasterizerDiscardEnable_CMockExpect(__LINE__, commandBuffer, rasterizerDiscardEnable) +void vkCmdSetRasterizerDiscardEnable_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); +typedef void (* CMOCK_vkCmdSetRasterizerDiscardEnable_CALLBACK)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable, int cmock_num_calls); +void vkCmdSetRasterizerDiscardEnable_AddCallback(CMOCK_vkCmdSetRasterizerDiscardEnable_CALLBACK Callback); +void vkCmdSetRasterizerDiscardEnable_Stub(CMOCK_vkCmdSetRasterizerDiscardEnable_CALLBACK Callback); +#define vkCmdSetRasterizerDiscardEnable_StubWithCallback vkCmdSetRasterizerDiscardEnable_AddCallback +#define vkCmdSetRasterizerDiscardEnable_IgnoreArg_commandBuffer() vkCmdSetRasterizerDiscardEnable_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetRasterizerDiscardEnable_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetRasterizerDiscardEnable_IgnoreArg_rasterizerDiscardEnable() vkCmdSetRasterizerDiscardEnable_CMockIgnoreArg_rasterizerDiscardEnable(__LINE__) +void vkCmdSetRasterizerDiscardEnable_CMockIgnoreArg_rasterizerDiscardEnable(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthBiasEnable_Ignore() vkCmdSetDepthBiasEnable_CMockIgnore() +void vkCmdSetDepthBiasEnable_CMockIgnore(void); +#define vkCmdSetDepthBiasEnable_StopIgnore() vkCmdSetDepthBiasEnable_CMockStopIgnore() +void vkCmdSetDepthBiasEnable_CMockStopIgnore(void); +#define vkCmdSetDepthBiasEnable_ExpectAnyArgs() vkCmdSetDepthBiasEnable_CMockExpectAnyArgs(__LINE__) +void vkCmdSetDepthBiasEnable_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthBiasEnable_Expect(commandBuffer, depthBiasEnable) vkCmdSetDepthBiasEnable_CMockExpect(__LINE__, commandBuffer, depthBiasEnable) +void vkCmdSetDepthBiasEnable_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable); +typedef void (* CMOCK_vkCmdSetDepthBiasEnable_CALLBACK)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable, int cmock_num_calls); +void vkCmdSetDepthBiasEnable_AddCallback(CMOCK_vkCmdSetDepthBiasEnable_CALLBACK Callback); +void vkCmdSetDepthBiasEnable_Stub(CMOCK_vkCmdSetDepthBiasEnable_CALLBACK Callback); +#define vkCmdSetDepthBiasEnable_StubWithCallback vkCmdSetDepthBiasEnable_AddCallback +#define vkCmdSetDepthBiasEnable_IgnoreArg_commandBuffer() vkCmdSetDepthBiasEnable_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetDepthBiasEnable_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthBiasEnable_IgnoreArg_depthBiasEnable() vkCmdSetDepthBiasEnable_CMockIgnoreArg_depthBiasEnable(__LINE__) +void vkCmdSetDepthBiasEnable_CMockIgnoreArg_depthBiasEnable(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetPrimitiveRestartEnable_Ignore() vkCmdSetPrimitiveRestartEnable_CMockIgnore() +void vkCmdSetPrimitiveRestartEnable_CMockIgnore(void); +#define vkCmdSetPrimitiveRestartEnable_StopIgnore() vkCmdSetPrimitiveRestartEnable_CMockStopIgnore() +void vkCmdSetPrimitiveRestartEnable_CMockStopIgnore(void); +#define vkCmdSetPrimitiveRestartEnable_ExpectAnyArgs() vkCmdSetPrimitiveRestartEnable_CMockExpectAnyArgs(__LINE__) +void vkCmdSetPrimitiveRestartEnable_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetPrimitiveRestartEnable_Expect(commandBuffer, primitiveRestartEnable) vkCmdSetPrimitiveRestartEnable_CMockExpect(__LINE__, commandBuffer, primitiveRestartEnable) +void vkCmdSetPrimitiveRestartEnable_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); +typedef void (* CMOCK_vkCmdSetPrimitiveRestartEnable_CALLBACK)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable, int cmock_num_calls); +void vkCmdSetPrimitiveRestartEnable_AddCallback(CMOCK_vkCmdSetPrimitiveRestartEnable_CALLBACK Callback); +void vkCmdSetPrimitiveRestartEnable_Stub(CMOCK_vkCmdSetPrimitiveRestartEnable_CALLBACK Callback); +#define vkCmdSetPrimitiveRestartEnable_StubWithCallback vkCmdSetPrimitiveRestartEnable_AddCallback +#define vkCmdSetPrimitiveRestartEnable_IgnoreArg_commandBuffer() vkCmdSetPrimitiveRestartEnable_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetPrimitiveRestartEnable_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetPrimitiveRestartEnable_IgnoreArg_primitiveRestartEnable() vkCmdSetPrimitiveRestartEnable_CMockIgnoreArg_primitiveRestartEnable(__LINE__) +void vkCmdSetPrimitiveRestartEnable_CMockIgnoreArg_primitiveRestartEnable(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceBufferMemoryRequirements_Ignore() vkGetDeviceBufferMemoryRequirements_CMockIgnore() +void vkGetDeviceBufferMemoryRequirements_CMockIgnore(void); +#define vkGetDeviceBufferMemoryRequirements_StopIgnore() vkGetDeviceBufferMemoryRequirements_CMockStopIgnore() +void vkGetDeviceBufferMemoryRequirements_CMockStopIgnore(void); +#define vkGetDeviceBufferMemoryRequirements_ExpectAnyArgs() vkGetDeviceBufferMemoryRequirements_CMockExpectAnyArgs(__LINE__) +void vkGetDeviceBufferMemoryRequirements_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceBufferMemoryRequirements_Expect(device, pInfo, pMemoryRequirements) vkGetDeviceBufferMemoryRequirements_CMockExpect(__LINE__, device, pInfo, pMemoryRequirements) +void vkGetDeviceBufferMemoryRequirements_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (* CMOCK_vkGetDeviceBufferMemoryRequirements_CALLBACK)(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements, int cmock_num_calls); +void vkGetDeviceBufferMemoryRequirements_AddCallback(CMOCK_vkGetDeviceBufferMemoryRequirements_CALLBACK Callback); +void vkGetDeviceBufferMemoryRequirements_Stub(CMOCK_vkGetDeviceBufferMemoryRequirements_CALLBACK Callback); +#define vkGetDeviceBufferMemoryRequirements_StubWithCallback vkGetDeviceBufferMemoryRequirements_AddCallback +#define vkGetDeviceBufferMemoryRequirements_ReturnThruPtr_pMemoryRequirements(pMemoryRequirements) vkGetDeviceBufferMemoryRequirements_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, sizeof(VkMemoryRequirements2)) +#define vkGetDeviceBufferMemoryRequirements_ReturnArrayThruPtr_pMemoryRequirements(pMemoryRequirements, cmock_len) vkGetDeviceBufferMemoryRequirements_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, cmock_len * sizeof(*pMemoryRequirements)) +#define vkGetDeviceBufferMemoryRequirements_ReturnMemThruPtr_pMemoryRequirements(pMemoryRequirements, cmock_size) vkGetDeviceBufferMemoryRequirements_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, cmock_size) +void vkGetDeviceBufferMemoryRequirements_CMockReturnMemThruPtr_pMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkMemoryRequirements2 const* pMemoryRequirements, size_t cmock_size); +#define vkGetDeviceBufferMemoryRequirements_IgnoreArg_device() vkGetDeviceBufferMemoryRequirements_CMockIgnoreArg_device(__LINE__) +void vkGetDeviceBufferMemoryRequirements_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceBufferMemoryRequirements_IgnoreArg_pInfo() vkGetDeviceBufferMemoryRequirements_CMockIgnoreArg_pInfo(__LINE__) +void vkGetDeviceBufferMemoryRequirements_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceBufferMemoryRequirements_IgnoreArg_pMemoryRequirements() vkGetDeviceBufferMemoryRequirements_CMockIgnoreArg_pMemoryRequirements(__LINE__) +void vkGetDeviceBufferMemoryRequirements_CMockIgnoreArg_pMemoryRequirements(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceImageMemoryRequirements_Ignore() vkGetDeviceImageMemoryRequirements_CMockIgnore() +void vkGetDeviceImageMemoryRequirements_CMockIgnore(void); +#define vkGetDeviceImageMemoryRequirements_StopIgnore() vkGetDeviceImageMemoryRequirements_CMockStopIgnore() +void vkGetDeviceImageMemoryRequirements_CMockStopIgnore(void); +#define vkGetDeviceImageMemoryRequirements_ExpectAnyArgs() vkGetDeviceImageMemoryRequirements_CMockExpectAnyArgs(__LINE__) +void vkGetDeviceImageMemoryRequirements_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceImageMemoryRequirements_Expect(device, pInfo, pMemoryRequirements) vkGetDeviceImageMemoryRequirements_CMockExpect(__LINE__, device, pInfo, pMemoryRequirements) +void vkGetDeviceImageMemoryRequirements_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (* CMOCK_vkGetDeviceImageMemoryRequirements_CALLBACK)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements, int cmock_num_calls); +void vkGetDeviceImageMemoryRequirements_AddCallback(CMOCK_vkGetDeviceImageMemoryRequirements_CALLBACK Callback); +void vkGetDeviceImageMemoryRequirements_Stub(CMOCK_vkGetDeviceImageMemoryRequirements_CALLBACK Callback); +#define vkGetDeviceImageMemoryRequirements_StubWithCallback vkGetDeviceImageMemoryRequirements_AddCallback +#define vkGetDeviceImageMemoryRequirements_ReturnThruPtr_pMemoryRequirements(pMemoryRequirements) vkGetDeviceImageMemoryRequirements_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, sizeof(VkMemoryRequirements2)) +#define vkGetDeviceImageMemoryRequirements_ReturnArrayThruPtr_pMemoryRequirements(pMemoryRequirements, cmock_len) vkGetDeviceImageMemoryRequirements_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, cmock_len * sizeof(*pMemoryRequirements)) +#define vkGetDeviceImageMemoryRequirements_ReturnMemThruPtr_pMemoryRequirements(pMemoryRequirements, cmock_size) vkGetDeviceImageMemoryRequirements_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, cmock_size) +void vkGetDeviceImageMemoryRequirements_CMockReturnMemThruPtr_pMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkMemoryRequirements2 const* pMemoryRequirements, size_t cmock_size); +#define vkGetDeviceImageMemoryRequirements_IgnoreArg_device() vkGetDeviceImageMemoryRequirements_CMockIgnoreArg_device(__LINE__) +void vkGetDeviceImageMemoryRequirements_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceImageMemoryRequirements_IgnoreArg_pInfo() vkGetDeviceImageMemoryRequirements_CMockIgnoreArg_pInfo(__LINE__) +void vkGetDeviceImageMemoryRequirements_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceImageMemoryRequirements_IgnoreArg_pMemoryRequirements() vkGetDeviceImageMemoryRequirements_CMockIgnoreArg_pMemoryRequirements(__LINE__) +void vkGetDeviceImageMemoryRequirements_CMockIgnoreArg_pMemoryRequirements(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceImageSparseMemoryRequirements_Ignore() vkGetDeviceImageSparseMemoryRequirements_CMockIgnore() +void vkGetDeviceImageSparseMemoryRequirements_CMockIgnore(void); +#define vkGetDeviceImageSparseMemoryRequirements_StopIgnore() vkGetDeviceImageSparseMemoryRequirements_CMockStopIgnore() +void vkGetDeviceImageSparseMemoryRequirements_CMockStopIgnore(void); +#define vkGetDeviceImageSparseMemoryRequirements_ExpectAnyArgs() vkGetDeviceImageSparseMemoryRequirements_CMockExpectAnyArgs(__LINE__) +void vkGetDeviceImageSparseMemoryRequirements_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceImageSparseMemoryRequirements_Expect(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements) vkGetDeviceImageSparseMemoryRequirements_CMockExpect(__LINE__, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements) +void vkGetDeviceImageSparseMemoryRequirements_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +typedef void (* CMOCK_vkGetDeviceImageSparseMemoryRequirements_CALLBACK)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, int cmock_num_calls); +void vkGetDeviceImageSparseMemoryRequirements_AddCallback(CMOCK_vkGetDeviceImageSparseMemoryRequirements_CALLBACK Callback); +void vkGetDeviceImageSparseMemoryRequirements_Stub(CMOCK_vkGetDeviceImageSparseMemoryRequirements_CALLBACK Callback); +#define vkGetDeviceImageSparseMemoryRequirements_StubWithCallback vkGetDeviceImageSparseMemoryRequirements_AddCallback +#define vkGetDeviceImageSparseMemoryRequirements_ReturnThruPtr_pSparseMemoryRequirementCount(pSparseMemoryRequirementCount) vkGetDeviceImageSparseMemoryRequirements_CMockReturnMemThruPtr_pSparseMemoryRequirementCount(__LINE__, pSparseMemoryRequirementCount, sizeof(uint32_t)) +#define vkGetDeviceImageSparseMemoryRequirements_ReturnArrayThruPtr_pSparseMemoryRequirementCount(pSparseMemoryRequirementCount, cmock_len) vkGetDeviceImageSparseMemoryRequirements_CMockReturnMemThruPtr_pSparseMemoryRequirementCount(__LINE__, pSparseMemoryRequirementCount, cmock_len * sizeof(*pSparseMemoryRequirementCount)) +#define vkGetDeviceImageSparseMemoryRequirements_ReturnMemThruPtr_pSparseMemoryRequirementCount(pSparseMemoryRequirementCount, cmock_size) vkGetDeviceImageSparseMemoryRequirements_CMockReturnMemThruPtr_pSparseMemoryRequirementCount(__LINE__, pSparseMemoryRequirementCount, cmock_size) +void vkGetDeviceImageSparseMemoryRequirements_CMockReturnMemThruPtr_pSparseMemoryRequirementCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pSparseMemoryRequirementCount, size_t cmock_size); +#define vkGetDeviceImageSparseMemoryRequirements_ReturnThruPtr_pSparseMemoryRequirements(pSparseMemoryRequirements) vkGetDeviceImageSparseMemoryRequirements_CMockReturnMemThruPtr_pSparseMemoryRequirements(__LINE__, pSparseMemoryRequirements, sizeof(VkSparseImageMemoryRequirements2)) +#define vkGetDeviceImageSparseMemoryRequirements_ReturnArrayThruPtr_pSparseMemoryRequirements(pSparseMemoryRequirements, cmock_len) vkGetDeviceImageSparseMemoryRequirements_CMockReturnMemThruPtr_pSparseMemoryRequirements(__LINE__, pSparseMemoryRequirements, cmock_len * sizeof(*pSparseMemoryRequirements)) +#define vkGetDeviceImageSparseMemoryRequirements_ReturnMemThruPtr_pSparseMemoryRequirements(pSparseMemoryRequirements, cmock_size) vkGetDeviceImageSparseMemoryRequirements_CMockReturnMemThruPtr_pSparseMemoryRequirements(__LINE__, pSparseMemoryRequirements, cmock_size) +void vkGetDeviceImageSparseMemoryRequirements_CMockReturnMemThruPtr_pSparseMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkSparseImageMemoryRequirements2 const* pSparseMemoryRequirements, size_t cmock_size); +#define vkGetDeviceImageSparseMemoryRequirements_IgnoreArg_device() vkGetDeviceImageSparseMemoryRequirements_CMockIgnoreArg_device(__LINE__) +void vkGetDeviceImageSparseMemoryRequirements_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceImageSparseMemoryRequirements_IgnoreArg_pInfo() vkGetDeviceImageSparseMemoryRequirements_CMockIgnoreArg_pInfo(__LINE__) +void vkGetDeviceImageSparseMemoryRequirements_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceImageSparseMemoryRequirements_IgnoreArg_pSparseMemoryRequirementCount() vkGetDeviceImageSparseMemoryRequirements_CMockIgnoreArg_pSparseMemoryRequirementCount(__LINE__) +void vkGetDeviceImageSparseMemoryRequirements_CMockIgnoreArg_pSparseMemoryRequirementCount(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceImageSparseMemoryRequirements_IgnoreArg_pSparseMemoryRequirements() vkGetDeviceImageSparseMemoryRequirements_CMockIgnoreArg_pSparseMemoryRequirements(__LINE__) +void vkGetDeviceImageSparseMemoryRequirements_CMockIgnoreArg_pSparseMemoryRequirements(UNITY_LINE_TYPE cmock_line); +#define vkDestroySurfaceKHR_Ignore() vkDestroySurfaceKHR_CMockIgnore() +void vkDestroySurfaceKHR_CMockIgnore(void); +#define vkDestroySurfaceKHR_StopIgnore() vkDestroySurfaceKHR_CMockStopIgnore() +void vkDestroySurfaceKHR_CMockStopIgnore(void); +#define vkDestroySurfaceKHR_ExpectAnyArgs() vkDestroySurfaceKHR_CMockExpectAnyArgs(__LINE__) +void vkDestroySurfaceKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroySurfaceKHR_Expect(instance, surface, pAllocator) vkDestroySurfaceKHR_CMockExpect(__LINE__, instance, surface, pAllocator) +void vkDestroySurfaceKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroySurfaceKHR_CALLBACK)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroySurfaceKHR_AddCallback(CMOCK_vkDestroySurfaceKHR_CALLBACK Callback); +void vkDestroySurfaceKHR_Stub(CMOCK_vkDestroySurfaceKHR_CALLBACK Callback); +#define vkDestroySurfaceKHR_StubWithCallback vkDestroySurfaceKHR_AddCallback +#define vkDestroySurfaceKHR_IgnoreArg_instance() vkDestroySurfaceKHR_CMockIgnoreArg_instance(__LINE__) +void vkDestroySurfaceKHR_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line); +#define vkDestroySurfaceKHR_IgnoreArg_surface() vkDestroySurfaceKHR_CMockIgnoreArg_surface(__LINE__) +void vkDestroySurfaceKHR_CMockIgnoreArg_surface(UNITY_LINE_TYPE cmock_line); +#define vkDestroySurfaceKHR_IgnoreArg_pAllocator() vkDestroySurfaceKHR_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroySurfaceKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSurfaceSupportKHR_IgnoreAndReturn(cmock_retval) vkGetPhysicalDeviceSurfaceSupportKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceSurfaceSupportKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceSurfaceSupportKHR_StopIgnore() vkGetPhysicalDeviceSurfaceSupportKHR_CMockStopIgnore() +void vkGetPhysicalDeviceSurfaceSupportKHR_CMockStopIgnore(void); +#define vkGetPhysicalDeviceSurfaceSupportKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetPhysicalDeviceSurfaceSupportKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceSurfaceSupportKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceSurfaceSupportKHR_ExpectAndReturn(physicalDevice, queueFamilyIndex, surface, pSupported, cmock_retval) vkGetPhysicalDeviceSurfaceSupportKHR_CMockExpectAndReturn(__LINE__, physicalDevice, queueFamilyIndex, surface, pSupported, cmock_retval) +void vkGetPhysicalDeviceSurfaceSupportKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALLBACK)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported, int cmock_num_calls); +void vkGetPhysicalDeviceSurfaceSupportKHR_AddCallback(CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALLBACK Callback); +void vkGetPhysicalDeviceSurfaceSupportKHR_Stub(CMOCK_vkGetPhysicalDeviceSurfaceSupportKHR_CALLBACK Callback); +#define vkGetPhysicalDeviceSurfaceSupportKHR_StubWithCallback vkGetPhysicalDeviceSurfaceSupportKHR_AddCallback +#define vkGetPhysicalDeviceSurfaceSupportKHR_ReturnThruPtr_pSupported(pSupported) vkGetPhysicalDeviceSurfaceSupportKHR_CMockReturnMemThruPtr_pSupported(__LINE__, pSupported, sizeof(VkBool32)) +#define vkGetPhysicalDeviceSurfaceSupportKHR_ReturnArrayThruPtr_pSupported(pSupported, cmock_len) vkGetPhysicalDeviceSurfaceSupportKHR_CMockReturnMemThruPtr_pSupported(__LINE__, pSupported, cmock_len * sizeof(*pSupported)) +#define vkGetPhysicalDeviceSurfaceSupportKHR_ReturnMemThruPtr_pSupported(pSupported, cmock_size) vkGetPhysicalDeviceSurfaceSupportKHR_CMockReturnMemThruPtr_pSupported(__LINE__, pSupported, cmock_size) +void vkGetPhysicalDeviceSurfaceSupportKHR_CMockReturnMemThruPtr_pSupported(UNITY_LINE_TYPE cmock_line, VkBool32 const* pSupported, size_t cmock_size); +#define vkGetPhysicalDeviceSurfaceSupportKHR_IgnoreArg_physicalDevice() vkGetPhysicalDeviceSurfaceSupportKHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceSurfaceSupportKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSurfaceSupportKHR_IgnoreArg_queueFamilyIndex() vkGetPhysicalDeviceSurfaceSupportKHR_CMockIgnoreArg_queueFamilyIndex(__LINE__) +void vkGetPhysicalDeviceSurfaceSupportKHR_CMockIgnoreArg_queueFamilyIndex(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSurfaceSupportKHR_IgnoreArg_surface() vkGetPhysicalDeviceSurfaceSupportKHR_CMockIgnoreArg_surface(__LINE__) +void vkGetPhysicalDeviceSurfaceSupportKHR_CMockIgnoreArg_surface(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSurfaceSupportKHR_IgnoreArg_pSupported() vkGetPhysicalDeviceSurfaceSupportKHR_CMockIgnoreArg_pSupported(__LINE__) +void vkGetPhysicalDeviceSurfaceSupportKHR_CMockIgnoreArg_pSupported(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSurfaceCapabilitiesKHR_IgnoreAndReturn(cmock_retval) vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceSurfaceCapabilitiesKHR_StopIgnore() vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CMockStopIgnore() +void vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CMockStopIgnore(void); +#define vkGetPhysicalDeviceSurfaceCapabilitiesKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceSurfaceCapabilitiesKHR_ExpectAndReturn(physicalDevice, surface, pSurfaceCapabilities, cmock_retval) vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CMockExpectAndReturn(__LINE__, physicalDevice, surface, pSurfaceCapabilities, cmock_retval) +void vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CALLBACK)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities, int cmock_num_calls); +void vkGetPhysicalDeviceSurfaceCapabilitiesKHR_AddCallback(CMOCK_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CALLBACK Callback); +void vkGetPhysicalDeviceSurfaceCapabilitiesKHR_Stub(CMOCK_vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CALLBACK Callback); +#define vkGetPhysicalDeviceSurfaceCapabilitiesKHR_StubWithCallback vkGetPhysicalDeviceSurfaceCapabilitiesKHR_AddCallback +#define vkGetPhysicalDeviceSurfaceCapabilitiesKHR_ReturnThruPtr_pSurfaceCapabilities(pSurfaceCapabilities) vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CMockReturnMemThruPtr_pSurfaceCapabilities(__LINE__, pSurfaceCapabilities, sizeof(VkSurfaceCapabilitiesKHR)) +#define vkGetPhysicalDeviceSurfaceCapabilitiesKHR_ReturnArrayThruPtr_pSurfaceCapabilities(pSurfaceCapabilities, cmock_len) vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CMockReturnMemThruPtr_pSurfaceCapabilities(__LINE__, pSurfaceCapabilities, cmock_len * sizeof(*pSurfaceCapabilities)) +#define vkGetPhysicalDeviceSurfaceCapabilitiesKHR_ReturnMemThruPtr_pSurfaceCapabilities(pSurfaceCapabilities, cmock_size) vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CMockReturnMemThruPtr_pSurfaceCapabilities(__LINE__, pSurfaceCapabilities, cmock_size) +void vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CMockReturnMemThruPtr_pSurfaceCapabilities(UNITY_LINE_TYPE cmock_line, VkSurfaceCapabilitiesKHR const* pSurfaceCapabilities, size_t cmock_size); +#define vkGetPhysicalDeviceSurfaceCapabilitiesKHR_IgnoreArg_physicalDevice() vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSurfaceCapabilitiesKHR_IgnoreArg_surface() vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CMockIgnoreArg_surface(__LINE__) +void vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CMockIgnoreArg_surface(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSurfaceCapabilitiesKHR_IgnoreArg_pSurfaceCapabilities() vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CMockIgnoreArg_pSurfaceCapabilities(__LINE__) +void vkGetPhysicalDeviceSurfaceCapabilitiesKHR_CMockIgnoreArg_pSurfaceCapabilities(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSurfaceFormatsKHR_IgnoreAndReturn(cmock_retval) vkGetPhysicalDeviceSurfaceFormatsKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceSurfaceFormatsKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceSurfaceFormatsKHR_StopIgnore() vkGetPhysicalDeviceSurfaceFormatsKHR_CMockStopIgnore() +void vkGetPhysicalDeviceSurfaceFormatsKHR_CMockStopIgnore(void); +#define vkGetPhysicalDeviceSurfaceFormatsKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetPhysicalDeviceSurfaceFormatsKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceSurfaceFormatsKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceSurfaceFormatsKHR_ExpectAndReturn(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats, cmock_retval) vkGetPhysicalDeviceSurfaceFormatsKHR_CMockExpectAndReturn(__LINE__, physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats, cmock_retval) +void vkGetPhysicalDeviceSurfaceFormatsKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALLBACK)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats, int cmock_num_calls); +void vkGetPhysicalDeviceSurfaceFormatsKHR_AddCallback(CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALLBACK Callback); +void vkGetPhysicalDeviceSurfaceFormatsKHR_Stub(CMOCK_vkGetPhysicalDeviceSurfaceFormatsKHR_CALLBACK Callback); +#define vkGetPhysicalDeviceSurfaceFormatsKHR_StubWithCallback vkGetPhysicalDeviceSurfaceFormatsKHR_AddCallback +#define vkGetPhysicalDeviceSurfaceFormatsKHR_ReturnThruPtr_pSurfaceFormatCount(pSurfaceFormatCount) vkGetPhysicalDeviceSurfaceFormatsKHR_CMockReturnMemThruPtr_pSurfaceFormatCount(__LINE__, pSurfaceFormatCount, sizeof(uint32_t)) +#define vkGetPhysicalDeviceSurfaceFormatsKHR_ReturnArrayThruPtr_pSurfaceFormatCount(pSurfaceFormatCount, cmock_len) vkGetPhysicalDeviceSurfaceFormatsKHR_CMockReturnMemThruPtr_pSurfaceFormatCount(__LINE__, pSurfaceFormatCount, cmock_len * sizeof(*pSurfaceFormatCount)) +#define vkGetPhysicalDeviceSurfaceFormatsKHR_ReturnMemThruPtr_pSurfaceFormatCount(pSurfaceFormatCount, cmock_size) vkGetPhysicalDeviceSurfaceFormatsKHR_CMockReturnMemThruPtr_pSurfaceFormatCount(__LINE__, pSurfaceFormatCount, cmock_size) +void vkGetPhysicalDeviceSurfaceFormatsKHR_CMockReturnMemThruPtr_pSurfaceFormatCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pSurfaceFormatCount, size_t cmock_size); +#define vkGetPhysicalDeviceSurfaceFormatsKHR_ReturnThruPtr_pSurfaceFormats(pSurfaceFormats) vkGetPhysicalDeviceSurfaceFormatsKHR_CMockReturnMemThruPtr_pSurfaceFormats(__LINE__, pSurfaceFormats, sizeof(VkSurfaceFormatKHR)) +#define vkGetPhysicalDeviceSurfaceFormatsKHR_ReturnArrayThruPtr_pSurfaceFormats(pSurfaceFormats, cmock_len) vkGetPhysicalDeviceSurfaceFormatsKHR_CMockReturnMemThruPtr_pSurfaceFormats(__LINE__, pSurfaceFormats, cmock_len * sizeof(*pSurfaceFormats)) +#define vkGetPhysicalDeviceSurfaceFormatsKHR_ReturnMemThruPtr_pSurfaceFormats(pSurfaceFormats, cmock_size) vkGetPhysicalDeviceSurfaceFormatsKHR_CMockReturnMemThruPtr_pSurfaceFormats(__LINE__, pSurfaceFormats, cmock_size) +void vkGetPhysicalDeviceSurfaceFormatsKHR_CMockReturnMemThruPtr_pSurfaceFormats(UNITY_LINE_TYPE cmock_line, VkSurfaceFormatKHR const* pSurfaceFormats, size_t cmock_size); +#define vkGetPhysicalDeviceSurfaceFormatsKHR_IgnoreArg_physicalDevice() vkGetPhysicalDeviceSurfaceFormatsKHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceSurfaceFormatsKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSurfaceFormatsKHR_IgnoreArg_surface() vkGetPhysicalDeviceSurfaceFormatsKHR_CMockIgnoreArg_surface(__LINE__) +void vkGetPhysicalDeviceSurfaceFormatsKHR_CMockIgnoreArg_surface(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSurfaceFormatsKHR_IgnoreArg_pSurfaceFormatCount() vkGetPhysicalDeviceSurfaceFormatsKHR_CMockIgnoreArg_pSurfaceFormatCount(__LINE__) +void vkGetPhysicalDeviceSurfaceFormatsKHR_CMockIgnoreArg_pSurfaceFormatCount(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSurfaceFormatsKHR_IgnoreArg_pSurfaceFormats() vkGetPhysicalDeviceSurfaceFormatsKHR_CMockIgnoreArg_pSurfaceFormats(__LINE__) +void vkGetPhysicalDeviceSurfaceFormatsKHR_CMockIgnoreArg_pSurfaceFormats(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSurfacePresentModesKHR_IgnoreAndReturn(cmock_retval) vkGetPhysicalDeviceSurfacePresentModesKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceSurfacePresentModesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceSurfacePresentModesKHR_StopIgnore() vkGetPhysicalDeviceSurfacePresentModesKHR_CMockStopIgnore() +void vkGetPhysicalDeviceSurfacePresentModesKHR_CMockStopIgnore(void); +#define vkGetPhysicalDeviceSurfacePresentModesKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetPhysicalDeviceSurfacePresentModesKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceSurfacePresentModesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceSurfacePresentModesKHR_ExpectAndReturn(physicalDevice, surface, pPresentModeCount, pPresentModes, cmock_retval) vkGetPhysicalDeviceSurfacePresentModesKHR_CMockExpectAndReturn(__LINE__, physicalDevice, surface, pPresentModeCount, pPresentModes, cmock_retval) +void vkGetPhysicalDeviceSurfacePresentModesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALLBACK)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes, int cmock_num_calls); +void vkGetPhysicalDeviceSurfacePresentModesKHR_AddCallback(CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALLBACK Callback); +void vkGetPhysicalDeviceSurfacePresentModesKHR_Stub(CMOCK_vkGetPhysicalDeviceSurfacePresentModesKHR_CALLBACK Callback); +#define vkGetPhysicalDeviceSurfacePresentModesKHR_StubWithCallback vkGetPhysicalDeviceSurfacePresentModesKHR_AddCallback +#define vkGetPhysicalDeviceSurfacePresentModesKHR_ReturnThruPtr_pPresentModeCount(pPresentModeCount) vkGetPhysicalDeviceSurfacePresentModesKHR_CMockReturnMemThruPtr_pPresentModeCount(__LINE__, pPresentModeCount, sizeof(uint32_t)) +#define vkGetPhysicalDeviceSurfacePresentModesKHR_ReturnArrayThruPtr_pPresentModeCount(pPresentModeCount, cmock_len) vkGetPhysicalDeviceSurfacePresentModesKHR_CMockReturnMemThruPtr_pPresentModeCount(__LINE__, pPresentModeCount, cmock_len * sizeof(*pPresentModeCount)) +#define vkGetPhysicalDeviceSurfacePresentModesKHR_ReturnMemThruPtr_pPresentModeCount(pPresentModeCount, cmock_size) vkGetPhysicalDeviceSurfacePresentModesKHR_CMockReturnMemThruPtr_pPresentModeCount(__LINE__, pPresentModeCount, cmock_size) +void vkGetPhysicalDeviceSurfacePresentModesKHR_CMockReturnMemThruPtr_pPresentModeCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPresentModeCount, size_t cmock_size); +#define vkGetPhysicalDeviceSurfacePresentModesKHR_ReturnThruPtr_pPresentModes(pPresentModes) vkGetPhysicalDeviceSurfacePresentModesKHR_CMockReturnMemThruPtr_pPresentModes(__LINE__, pPresentModes, sizeof(VkPresentModeKHR)) +#define vkGetPhysicalDeviceSurfacePresentModesKHR_ReturnArrayThruPtr_pPresentModes(pPresentModes, cmock_len) vkGetPhysicalDeviceSurfacePresentModesKHR_CMockReturnMemThruPtr_pPresentModes(__LINE__, pPresentModes, cmock_len * sizeof(*pPresentModes)) +#define vkGetPhysicalDeviceSurfacePresentModesKHR_ReturnMemThruPtr_pPresentModes(pPresentModes, cmock_size) vkGetPhysicalDeviceSurfacePresentModesKHR_CMockReturnMemThruPtr_pPresentModes(__LINE__, pPresentModes, cmock_size) +void vkGetPhysicalDeviceSurfacePresentModesKHR_CMockReturnMemThruPtr_pPresentModes(UNITY_LINE_TYPE cmock_line, VkPresentModeKHR const* pPresentModes, size_t cmock_size); +#define vkGetPhysicalDeviceSurfacePresentModesKHR_IgnoreArg_physicalDevice() vkGetPhysicalDeviceSurfacePresentModesKHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceSurfacePresentModesKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSurfacePresentModesKHR_IgnoreArg_surface() vkGetPhysicalDeviceSurfacePresentModesKHR_CMockIgnoreArg_surface(__LINE__) +void vkGetPhysicalDeviceSurfacePresentModesKHR_CMockIgnoreArg_surface(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSurfacePresentModesKHR_IgnoreArg_pPresentModeCount() vkGetPhysicalDeviceSurfacePresentModesKHR_CMockIgnoreArg_pPresentModeCount(__LINE__) +void vkGetPhysicalDeviceSurfacePresentModesKHR_CMockIgnoreArg_pPresentModeCount(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSurfacePresentModesKHR_IgnoreArg_pPresentModes() vkGetPhysicalDeviceSurfacePresentModesKHR_CMockIgnoreArg_pPresentModes(__LINE__) +void vkGetPhysicalDeviceSurfacePresentModesKHR_CMockIgnoreArg_pPresentModes(UNITY_LINE_TYPE cmock_line); +#define vkCreateSwapchainKHR_IgnoreAndReturn(cmock_retval) vkCreateSwapchainKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateSwapchainKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateSwapchainKHR_StopIgnore() vkCreateSwapchainKHR_CMockStopIgnore() +void vkCreateSwapchainKHR_CMockStopIgnore(void); +#define vkCreateSwapchainKHR_ExpectAnyArgsAndReturn(cmock_retval) vkCreateSwapchainKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateSwapchainKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateSwapchainKHR_ExpectAndReturn(device, pCreateInfo, pAllocator, pSwapchain, cmock_retval) vkCreateSwapchainKHR_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pSwapchain, cmock_retval) +void vkCreateSwapchainKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateSwapchainKHR_CALLBACK)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain, int cmock_num_calls); +void vkCreateSwapchainKHR_AddCallback(CMOCK_vkCreateSwapchainKHR_CALLBACK Callback); +void vkCreateSwapchainKHR_Stub(CMOCK_vkCreateSwapchainKHR_CALLBACK Callback); +#define vkCreateSwapchainKHR_StubWithCallback vkCreateSwapchainKHR_AddCallback +#define vkCreateSwapchainKHR_ReturnThruPtr_pSwapchain(pSwapchain) vkCreateSwapchainKHR_CMockReturnMemThruPtr_pSwapchain(__LINE__, pSwapchain, sizeof(VkSwapchainKHR)) +#define vkCreateSwapchainKHR_ReturnArrayThruPtr_pSwapchain(pSwapchain, cmock_len) vkCreateSwapchainKHR_CMockReturnMemThruPtr_pSwapchain(__LINE__, pSwapchain, cmock_len * sizeof(*pSwapchain)) +#define vkCreateSwapchainKHR_ReturnMemThruPtr_pSwapchain(pSwapchain, cmock_size) vkCreateSwapchainKHR_CMockReturnMemThruPtr_pSwapchain(__LINE__, pSwapchain, cmock_size) +void vkCreateSwapchainKHR_CMockReturnMemThruPtr_pSwapchain(UNITY_LINE_TYPE cmock_line, VkSwapchainKHR const* pSwapchain, size_t cmock_size); +#define vkCreateSwapchainKHR_IgnoreArg_device() vkCreateSwapchainKHR_CMockIgnoreArg_device(__LINE__) +void vkCreateSwapchainKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateSwapchainKHR_IgnoreArg_pCreateInfo() vkCreateSwapchainKHR_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateSwapchainKHR_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateSwapchainKHR_IgnoreArg_pAllocator() vkCreateSwapchainKHR_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateSwapchainKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateSwapchainKHR_IgnoreArg_pSwapchain() vkCreateSwapchainKHR_CMockIgnoreArg_pSwapchain(__LINE__) +void vkCreateSwapchainKHR_CMockIgnoreArg_pSwapchain(UNITY_LINE_TYPE cmock_line); +#define vkDestroySwapchainKHR_Ignore() vkDestroySwapchainKHR_CMockIgnore() +void vkDestroySwapchainKHR_CMockIgnore(void); +#define vkDestroySwapchainKHR_StopIgnore() vkDestroySwapchainKHR_CMockStopIgnore() +void vkDestroySwapchainKHR_CMockStopIgnore(void); +#define vkDestroySwapchainKHR_ExpectAnyArgs() vkDestroySwapchainKHR_CMockExpectAnyArgs(__LINE__) +void vkDestroySwapchainKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroySwapchainKHR_Expect(device, swapchain, pAllocator) vkDestroySwapchainKHR_CMockExpect(__LINE__, device, swapchain, pAllocator) +void vkDestroySwapchainKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroySwapchainKHR_CALLBACK)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroySwapchainKHR_AddCallback(CMOCK_vkDestroySwapchainKHR_CALLBACK Callback); +void vkDestroySwapchainKHR_Stub(CMOCK_vkDestroySwapchainKHR_CALLBACK Callback); +#define vkDestroySwapchainKHR_StubWithCallback vkDestroySwapchainKHR_AddCallback +#define vkDestroySwapchainKHR_IgnoreArg_device() vkDestroySwapchainKHR_CMockIgnoreArg_device(__LINE__) +void vkDestroySwapchainKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroySwapchainKHR_IgnoreArg_swapchain() vkDestroySwapchainKHR_CMockIgnoreArg_swapchain(__LINE__) +void vkDestroySwapchainKHR_CMockIgnoreArg_swapchain(UNITY_LINE_TYPE cmock_line); +#define vkDestroySwapchainKHR_IgnoreArg_pAllocator() vkDestroySwapchainKHR_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroySwapchainKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkGetSwapchainImagesKHR_IgnoreAndReturn(cmock_retval) vkGetSwapchainImagesKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetSwapchainImagesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetSwapchainImagesKHR_StopIgnore() vkGetSwapchainImagesKHR_CMockStopIgnore() +void vkGetSwapchainImagesKHR_CMockStopIgnore(void); +#define vkGetSwapchainImagesKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetSwapchainImagesKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetSwapchainImagesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetSwapchainImagesKHR_ExpectAndReturn(device, swapchain, pSwapchainImageCount, pSwapchainImages, cmock_retval) vkGetSwapchainImagesKHR_CMockExpectAndReturn(__LINE__, device, swapchain, pSwapchainImageCount, pSwapchainImages, cmock_retval) +void vkGetSwapchainImagesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetSwapchainImagesKHR_CALLBACK)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages, int cmock_num_calls); +void vkGetSwapchainImagesKHR_AddCallback(CMOCK_vkGetSwapchainImagesKHR_CALLBACK Callback); +void vkGetSwapchainImagesKHR_Stub(CMOCK_vkGetSwapchainImagesKHR_CALLBACK Callback); +#define vkGetSwapchainImagesKHR_StubWithCallback vkGetSwapchainImagesKHR_AddCallback +#define vkGetSwapchainImagesKHR_ReturnThruPtr_pSwapchainImageCount(pSwapchainImageCount) vkGetSwapchainImagesKHR_CMockReturnMemThruPtr_pSwapchainImageCount(__LINE__, pSwapchainImageCount, sizeof(uint32_t)) +#define vkGetSwapchainImagesKHR_ReturnArrayThruPtr_pSwapchainImageCount(pSwapchainImageCount, cmock_len) vkGetSwapchainImagesKHR_CMockReturnMemThruPtr_pSwapchainImageCount(__LINE__, pSwapchainImageCount, cmock_len * sizeof(*pSwapchainImageCount)) +#define vkGetSwapchainImagesKHR_ReturnMemThruPtr_pSwapchainImageCount(pSwapchainImageCount, cmock_size) vkGetSwapchainImagesKHR_CMockReturnMemThruPtr_pSwapchainImageCount(__LINE__, pSwapchainImageCount, cmock_size) +void vkGetSwapchainImagesKHR_CMockReturnMemThruPtr_pSwapchainImageCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pSwapchainImageCount, size_t cmock_size); +#define vkGetSwapchainImagesKHR_ReturnThruPtr_pSwapchainImages(pSwapchainImages) vkGetSwapchainImagesKHR_CMockReturnMemThruPtr_pSwapchainImages(__LINE__, pSwapchainImages, sizeof(VkImage)) +#define vkGetSwapchainImagesKHR_ReturnArrayThruPtr_pSwapchainImages(pSwapchainImages, cmock_len) vkGetSwapchainImagesKHR_CMockReturnMemThruPtr_pSwapchainImages(__LINE__, pSwapchainImages, cmock_len * sizeof(*pSwapchainImages)) +#define vkGetSwapchainImagesKHR_ReturnMemThruPtr_pSwapchainImages(pSwapchainImages, cmock_size) vkGetSwapchainImagesKHR_CMockReturnMemThruPtr_pSwapchainImages(__LINE__, pSwapchainImages, cmock_size) +void vkGetSwapchainImagesKHR_CMockReturnMemThruPtr_pSwapchainImages(UNITY_LINE_TYPE cmock_line, VkImage const* pSwapchainImages, size_t cmock_size); +#define vkGetSwapchainImagesKHR_IgnoreArg_device() vkGetSwapchainImagesKHR_CMockIgnoreArg_device(__LINE__) +void vkGetSwapchainImagesKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetSwapchainImagesKHR_IgnoreArg_swapchain() vkGetSwapchainImagesKHR_CMockIgnoreArg_swapchain(__LINE__) +void vkGetSwapchainImagesKHR_CMockIgnoreArg_swapchain(UNITY_LINE_TYPE cmock_line); +#define vkGetSwapchainImagesKHR_IgnoreArg_pSwapchainImageCount() vkGetSwapchainImagesKHR_CMockIgnoreArg_pSwapchainImageCount(__LINE__) +void vkGetSwapchainImagesKHR_CMockIgnoreArg_pSwapchainImageCount(UNITY_LINE_TYPE cmock_line); +#define vkGetSwapchainImagesKHR_IgnoreArg_pSwapchainImages() vkGetSwapchainImagesKHR_CMockIgnoreArg_pSwapchainImages(__LINE__) +void vkGetSwapchainImagesKHR_CMockIgnoreArg_pSwapchainImages(UNITY_LINE_TYPE cmock_line); +#define vkAcquireNextImageKHR_IgnoreAndReturn(cmock_retval) vkAcquireNextImageKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkAcquireNextImageKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkAcquireNextImageKHR_StopIgnore() vkAcquireNextImageKHR_CMockStopIgnore() +void vkAcquireNextImageKHR_CMockStopIgnore(void); +#define vkAcquireNextImageKHR_ExpectAnyArgsAndReturn(cmock_retval) vkAcquireNextImageKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkAcquireNextImageKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkAcquireNextImageKHR_ExpectAndReturn(device, swapchain, timeout, semaphore, fence, pImageIndex, cmock_retval) vkAcquireNextImageKHR_CMockExpectAndReturn(__LINE__, device, swapchain, timeout, semaphore, fence, pImageIndex, cmock_retval) +void vkAcquireNextImageKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkAcquireNextImageKHR_CALLBACK)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex, int cmock_num_calls); +void vkAcquireNextImageKHR_AddCallback(CMOCK_vkAcquireNextImageKHR_CALLBACK Callback); +void vkAcquireNextImageKHR_Stub(CMOCK_vkAcquireNextImageKHR_CALLBACK Callback); +#define vkAcquireNextImageKHR_StubWithCallback vkAcquireNextImageKHR_AddCallback +#define vkAcquireNextImageKHR_ReturnThruPtr_pImageIndex(pImageIndex) vkAcquireNextImageKHR_CMockReturnMemThruPtr_pImageIndex(__LINE__, pImageIndex, sizeof(uint32_t)) +#define vkAcquireNextImageKHR_ReturnArrayThruPtr_pImageIndex(pImageIndex, cmock_len) vkAcquireNextImageKHR_CMockReturnMemThruPtr_pImageIndex(__LINE__, pImageIndex, cmock_len * sizeof(*pImageIndex)) +#define vkAcquireNextImageKHR_ReturnMemThruPtr_pImageIndex(pImageIndex, cmock_size) vkAcquireNextImageKHR_CMockReturnMemThruPtr_pImageIndex(__LINE__, pImageIndex, cmock_size) +void vkAcquireNextImageKHR_CMockReturnMemThruPtr_pImageIndex(UNITY_LINE_TYPE cmock_line, uint32_t const* pImageIndex, size_t cmock_size); +#define vkAcquireNextImageKHR_IgnoreArg_device() vkAcquireNextImageKHR_CMockIgnoreArg_device(__LINE__) +void vkAcquireNextImageKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkAcquireNextImageKHR_IgnoreArg_swapchain() vkAcquireNextImageKHR_CMockIgnoreArg_swapchain(__LINE__) +void vkAcquireNextImageKHR_CMockIgnoreArg_swapchain(UNITY_LINE_TYPE cmock_line); +#define vkAcquireNextImageKHR_IgnoreArg_timeout() vkAcquireNextImageKHR_CMockIgnoreArg_timeout(__LINE__) +void vkAcquireNextImageKHR_CMockIgnoreArg_timeout(UNITY_LINE_TYPE cmock_line); +#define vkAcquireNextImageKHR_IgnoreArg_semaphore() vkAcquireNextImageKHR_CMockIgnoreArg_semaphore(__LINE__) +void vkAcquireNextImageKHR_CMockIgnoreArg_semaphore(UNITY_LINE_TYPE cmock_line); +#define vkAcquireNextImageKHR_IgnoreArg_fence() vkAcquireNextImageKHR_CMockIgnoreArg_fence(__LINE__) +void vkAcquireNextImageKHR_CMockIgnoreArg_fence(UNITY_LINE_TYPE cmock_line); +#define vkAcquireNextImageKHR_IgnoreArg_pImageIndex() vkAcquireNextImageKHR_CMockIgnoreArg_pImageIndex(__LINE__) +void vkAcquireNextImageKHR_CMockIgnoreArg_pImageIndex(UNITY_LINE_TYPE cmock_line); +#define vkQueuePresentKHR_IgnoreAndReturn(cmock_retval) vkQueuePresentKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkQueuePresentKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkQueuePresentKHR_StopIgnore() vkQueuePresentKHR_CMockStopIgnore() +void vkQueuePresentKHR_CMockStopIgnore(void); +#define vkQueuePresentKHR_ExpectAnyArgsAndReturn(cmock_retval) vkQueuePresentKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkQueuePresentKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkQueuePresentKHR_ExpectAndReturn(queue, pPresentInfo, cmock_retval) vkQueuePresentKHR_CMockExpectAndReturn(__LINE__, queue, pPresentInfo, cmock_retval) +void vkQueuePresentKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkQueue queue, const VkPresentInfoKHR* pPresentInfo, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkQueuePresentKHR_CALLBACK)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo, int cmock_num_calls); +void vkQueuePresentKHR_AddCallback(CMOCK_vkQueuePresentKHR_CALLBACK Callback); +void vkQueuePresentKHR_Stub(CMOCK_vkQueuePresentKHR_CALLBACK Callback); +#define vkQueuePresentKHR_StubWithCallback vkQueuePresentKHR_AddCallback +#define vkQueuePresentKHR_IgnoreArg_queue() vkQueuePresentKHR_CMockIgnoreArg_queue(__LINE__) +void vkQueuePresentKHR_CMockIgnoreArg_queue(UNITY_LINE_TYPE cmock_line); +#define vkQueuePresentKHR_IgnoreArg_pPresentInfo() vkQueuePresentKHR_CMockIgnoreArg_pPresentInfo(__LINE__) +void vkQueuePresentKHR_CMockIgnoreArg_pPresentInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceGroupPresentCapabilitiesKHR_IgnoreAndReturn(cmock_retval) vkGetDeviceGroupPresentCapabilitiesKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetDeviceGroupPresentCapabilitiesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetDeviceGroupPresentCapabilitiesKHR_StopIgnore() vkGetDeviceGroupPresentCapabilitiesKHR_CMockStopIgnore() +void vkGetDeviceGroupPresentCapabilitiesKHR_CMockStopIgnore(void); +#define vkGetDeviceGroupPresentCapabilitiesKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetDeviceGroupPresentCapabilitiesKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetDeviceGroupPresentCapabilitiesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetDeviceGroupPresentCapabilitiesKHR_ExpectAndReturn(device, pDeviceGroupPresentCapabilities, cmock_retval) vkGetDeviceGroupPresentCapabilitiesKHR_CMockExpectAndReturn(__LINE__, device, pDeviceGroupPresentCapabilities, cmock_retval) +void vkGetDeviceGroupPresentCapabilitiesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetDeviceGroupPresentCapabilitiesKHR_CALLBACK)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities, int cmock_num_calls); +void vkGetDeviceGroupPresentCapabilitiesKHR_AddCallback(CMOCK_vkGetDeviceGroupPresentCapabilitiesKHR_CALLBACK Callback); +void vkGetDeviceGroupPresentCapabilitiesKHR_Stub(CMOCK_vkGetDeviceGroupPresentCapabilitiesKHR_CALLBACK Callback); +#define vkGetDeviceGroupPresentCapabilitiesKHR_StubWithCallback vkGetDeviceGroupPresentCapabilitiesKHR_AddCallback +#define vkGetDeviceGroupPresentCapabilitiesKHR_ReturnThruPtr_pDeviceGroupPresentCapabilities(pDeviceGroupPresentCapabilities) vkGetDeviceGroupPresentCapabilitiesKHR_CMockReturnMemThruPtr_pDeviceGroupPresentCapabilities(__LINE__, pDeviceGroupPresentCapabilities, sizeof(VkDeviceGroupPresentCapabilitiesKHR)) +#define vkGetDeviceGroupPresentCapabilitiesKHR_ReturnArrayThruPtr_pDeviceGroupPresentCapabilities(pDeviceGroupPresentCapabilities, cmock_len) vkGetDeviceGroupPresentCapabilitiesKHR_CMockReturnMemThruPtr_pDeviceGroupPresentCapabilities(__LINE__, pDeviceGroupPresentCapabilities, cmock_len * sizeof(*pDeviceGroupPresentCapabilities)) +#define vkGetDeviceGroupPresentCapabilitiesKHR_ReturnMemThruPtr_pDeviceGroupPresentCapabilities(pDeviceGroupPresentCapabilities, cmock_size) vkGetDeviceGroupPresentCapabilitiesKHR_CMockReturnMemThruPtr_pDeviceGroupPresentCapabilities(__LINE__, pDeviceGroupPresentCapabilities, cmock_size) +void vkGetDeviceGroupPresentCapabilitiesKHR_CMockReturnMemThruPtr_pDeviceGroupPresentCapabilities(UNITY_LINE_TYPE cmock_line, VkDeviceGroupPresentCapabilitiesKHR const* pDeviceGroupPresentCapabilities, size_t cmock_size); +#define vkGetDeviceGroupPresentCapabilitiesKHR_IgnoreArg_device() vkGetDeviceGroupPresentCapabilitiesKHR_CMockIgnoreArg_device(__LINE__) +void vkGetDeviceGroupPresentCapabilitiesKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceGroupPresentCapabilitiesKHR_IgnoreArg_pDeviceGroupPresentCapabilities() vkGetDeviceGroupPresentCapabilitiesKHR_CMockIgnoreArg_pDeviceGroupPresentCapabilities(__LINE__) +void vkGetDeviceGroupPresentCapabilitiesKHR_CMockIgnoreArg_pDeviceGroupPresentCapabilities(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceGroupSurfacePresentModesKHR_IgnoreAndReturn(cmock_retval) vkGetDeviceGroupSurfacePresentModesKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetDeviceGroupSurfacePresentModesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetDeviceGroupSurfacePresentModesKHR_StopIgnore() vkGetDeviceGroupSurfacePresentModesKHR_CMockStopIgnore() +void vkGetDeviceGroupSurfacePresentModesKHR_CMockStopIgnore(void); +#define vkGetDeviceGroupSurfacePresentModesKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetDeviceGroupSurfacePresentModesKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetDeviceGroupSurfacePresentModesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetDeviceGroupSurfacePresentModesKHR_ExpectAndReturn(device, surface, pModes, cmock_retval) vkGetDeviceGroupSurfacePresentModesKHR_CMockExpectAndReturn(__LINE__, device, surface, pModes, cmock_retval) +void vkGetDeviceGroupSurfacePresentModesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetDeviceGroupSurfacePresentModesKHR_CALLBACK)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes, int cmock_num_calls); +void vkGetDeviceGroupSurfacePresentModesKHR_AddCallback(CMOCK_vkGetDeviceGroupSurfacePresentModesKHR_CALLBACK Callback); +void vkGetDeviceGroupSurfacePresentModesKHR_Stub(CMOCK_vkGetDeviceGroupSurfacePresentModesKHR_CALLBACK Callback); +#define vkGetDeviceGroupSurfacePresentModesKHR_StubWithCallback vkGetDeviceGroupSurfacePresentModesKHR_AddCallback +#define vkGetDeviceGroupSurfacePresentModesKHR_ReturnThruPtr_pModes(pModes) vkGetDeviceGroupSurfacePresentModesKHR_CMockReturnMemThruPtr_pModes(__LINE__, pModes, sizeof(VkDeviceGroupPresentModeFlagsKHR)) +#define vkGetDeviceGroupSurfacePresentModesKHR_ReturnArrayThruPtr_pModes(pModes, cmock_len) vkGetDeviceGroupSurfacePresentModesKHR_CMockReturnMemThruPtr_pModes(__LINE__, pModes, cmock_len * sizeof(*pModes)) +#define vkGetDeviceGroupSurfacePresentModesKHR_ReturnMemThruPtr_pModes(pModes, cmock_size) vkGetDeviceGroupSurfacePresentModesKHR_CMockReturnMemThruPtr_pModes(__LINE__, pModes, cmock_size) +void vkGetDeviceGroupSurfacePresentModesKHR_CMockReturnMemThruPtr_pModes(UNITY_LINE_TYPE cmock_line, VkDeviceGroupPresentModeFlagsKHR const* pModes, size_t cmock_size); +#define vkGetDeviceGroupSurfacePresentModesKHR_IgnoreArg_device() vkGetDeviceGroupSurfacePresentModesKHR_CMockIgnoreArg_device(__LINE__) +void vkGetDeviceGroupSurfacePresentModesKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceGroupSurfacePresentModesKHR_IgnoreArg_surface() vkGetDeviceGroupSurfacePresentModesKHR_CMockIgnoreArg_surface(__LINE__) +void vkGetDeviceGroupSurfacePresentModesKHR_CMockIgnoreArg_surface(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceGroupSurfacePresentModesKHR_IgnoreArg_pModes() vkGetDeviceGroupSurfacePresentModesKHR_CMockIgnoreArg_pModes(__LINE__) +void vkGetDeviceGroupSurfacePresentModesKHR_CMockIgnoreArg_pModes(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDevicePresentRectanglesKHR_IgnoreAndReturn(cmock_retval) vkGetPhysicalDevicePresentRectanglesKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDevicePresentRectanglesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDevicePresentRectanglesKHR_StopIgnore() vkGetPhysicalDevicePresentRectanglesKHR_CMockStopIgnore() +void vkGetPhysicalDevicePresentRectanglesKHR_CMockStopIgnore(void); +#define vkGetPhysicalDevicePresentRectanglesKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetPhysicalDevicePresentRectanglesKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDevicePresentRectanglesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDevicePresentRectanglesKHR_ExpectAndReturn(physicalDevice, surface, pRectCount, pRects, cmock_retval) vkGetPhysicalDevicePresentRectanglesKHR_CMockExpectAndReturn(__LINE__, physicalDevice, surface, pRectCount, pRects, cmock_retval) +void vkGetPhysicalDevicePresentRectanglesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALLBACK)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects, int cmock_num_calls); +void vkGetPhysicalDevicePresentRectanglesKHR_AddCallback(CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALLBACK Callback); +void vkGetPhysicalDevicePresentRectanglesKHR_Stub(CMOCK_vkGetPhysicalDevicePresentRectanglesKHR_CALLBACK Callback); +#define vkGetPhysicalDevicePresentRectanglesKHR_StubWithCallback vkGetPhysicalDevicePresentRectanglesKHR_AddCallback +#define vkGetPhysicalDevicePresentRectanglesKHR_ReturnThruPtr_pRectCount(pRectCount) vkGetPhysicalDevicePresentRectanglesKHR_CMockReturnMemThruPtr_pRectCount(__LINE__, pRectCount, sizeof(uint32_t)) +#define vkGetPhysicalDevicePresentRectanglesKHR_ReturnArrayThruPtr_pRectCount(pRectCount, cmock_len) vkGetPhysicalDevicePresentRectanglesKHR_CMockReturnMemThruPtr_pRectCount(__LINE__, pRectCount, cmock_len * sizeof(*pRectCount)) +#define vkGetPhysicalDevicePresentRectanglesKHR_ReturnMemThruPtr_pRectCount(pRectCount, cmock_size) vkGetPhysicalDevicePresentRectanglesKHR_CMockReturnMemThruPtr_pRectCount(__LINE__, pRectCount, cmock_size) +void vkGetPhysicalDevicePresentRectanglesKHR_CMockReturnMemThruPtr_pRectCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pRectCount, size_t cmock_size); +#define vkGetPhysicalDevicePresentRectanglesKHR_ReturnThruPtr_pRects(pRects) vkGetPhysicalDevicePresentRectanglesKHR_CMockReturnMemThruPtr_pRects(__LINE__, pRects, sizeof(VkRect2D)) +#define vkGetPhysicalDevicePresentRectanglesKHR_ReturnArrayThruPtr_pRects(pRects, cmock_len) vkGetPhysicalDevicePresentRectanglesKHR_CMockReturnMemThruPtr_pRects(__LINE__, pRects, cmock_len * sizeof(*pRects)) +#define vkGetPhysicalDevicePresentRectanglesKHR_ReturnMemThruPtr_pRects(pRects, cmock_size) vkGetPhysicalDevicePresentRectanglesKHR_CMockReturnMemThruPtr_pRects(__LINE__, pRects, cmock_size) +void vkGetPhysicalDevicePresentRectanglesKHR_CMockReturnMemThruPtr_pRects(UNITY_LINE_TYPE cmock_line, VkRect2D const* pRects, size_t cmock_size); +#define vkGetPhysicalDevicePresentRectanglesKHR_IgnoreArg_physicalDevice() vkGetPhysicalDevicePresentRectanglesKHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDevicePresentRectanglesKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDevicePresentRectanglesKHR_IgnoreArg_surface() vkGetPhysicalDevicePresentRectanglesKHR_CMockIgnoreArg_surface(__LINE__) +void vkGetPhysicalDevicePresentRectanglesKHR_CMockIgnoreArg_surface(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDevicePresentRectanglesKHR_IgnoreArg_pRectCount() vkGetPhysicalDevicePresentRectanglesKHR_CMockIgnoreArg_pRectCount(__LINE__) +void vkGetPhysicalDevicePresentRectanglesKHR_CMockIgnoreArg_pRectCount(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDevicePresentRectanglesKHR_IgnoreArg_pRects() vkGetPhysicalDevicePresentRectanglesKHR_CMockIgnoreArg_pRects(__LINE__) +void vkGetPhysicalDevicePresentRectanglesKHR_CMockIgnoreArg_pRects(UNITY_LINE_TYPE cmock_line); +#define vkAcquireNextImage2KHR_IgnoreAndReturn(cmock_retval) vkAcquireNextImage2KHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkAcquireNextImage2KHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkAcquireNextImage2KHR_StopIgnore() vkAcquireNextImage2KHR_CMockStopIgnore() +void vkAcquireNextImage2KHR_CMockStopIgnore(void); +#define vkAcquireNextImage2KHR_ExpectAnyArgsAndReturn(cmock_retval) vkAcquireNextImage2KHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkAcquireNextImage2KHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkAcquireNextImage2KHR_ExpectAndReturn(device, pAcquireInfo, pImageIndex, cmock_retval) vkAcquireNextImage2KHR_CMockExpectAndReturn(__LINE__, device, pAcquireInfo, pImageIndex, cmock_retval) +void vkAcquireNextImage2KHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkAcquireNextImage2KHR_CALLBACK)(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex, int cmock_num_calls); +void vkAcquireNextImage2KHR_AddCallback(CMOCK_vkAcquireNextImage2KHR_CALLBACK Callback); +void vkAcquireNextImage2KHR_Stub(CMOCK_vkAcquireNextImage2KHR_CALLBACK Callback); +#define vkAcquireNextImage2KHR_StubWithCallback vkAcquireNextImage2KHR_AddCallback +#define vkAcquireNextImage2KHR_ReturnThruPtr_pImageIndex(pImageIndex) vkAcquireNextImage2KHR_CMockReturnMemThruPtr_pImageIndex(__LINE__, pImageIndex, sizeof(uint32_t)) +#define vkAcquireNextImage2KHR_ReturnArrayThruPtr_pImageIndex(pImageIndex, cmock_len) vkAcquireNextImage2KHR_CMockReturnMemThruPtr_pImageIndex(__LINE__, pImageIndex, cmock_len * sizeof(*pImageIndex)) +#define vkAcquireNextImage2KHR_ReturnMemThruPtr_pImageIndex(pImageIndex, cmock_size) vkAcquireNextImage2KHR_CMockReturnMemThruPtr_pImageIndex(__LINE__, pImageIndex, cmock_size) +void vkAcquireNextImage2KHR_CMockReturnMemThruPtr_pImageIndex(UNITY_LINE_TYPE cmock_line, uint32_t const* pImageIndex, size_t cmock_size); +#define vkAcquireNextImage2KHR_IgnoreArg_device() vkAcquireNextImage2KHR_CMockIgnoreArg_device(__LINE__) +void vkAcquireNextImage2KHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkAcquireNextImage2KHR_IgnoreArg_pAcquireInfo() vkAcquireNextImage2KHR_CMockIgnoreArg_pAcquireInfo(__LINE__) +void vkAcquireNextImage2KHR_CMockIgnoreArg_pAcquireInfo(UNITY_LINE_TYPE cmock_line); +#define vkAcquireNextImage2KHR_IgnoreArg_pImageIndex() vkAcquireNextImage2KHR_CMockIgnoreArg_pImageIndex(__LINE__) +void vkAcquireNextImage2KHR_CMockIgnoreArg_pImageIndex(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceDisplayPropertiesKHR_IgnoreAndReturn(cmock_retval) vkGetPhysicalDeviceDisplayPropertiesKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceDisplayPropertiesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceDisplayPropertiesKHR_StopIgnore() vkGetPhysicalDeviceDisplayPropertiesKHR_CMockStopIgnore() +void vkGetPhysicalDeviceDisplayPropertiesKHR_CMockStopIgnore(void); +#define vkGetPhysicalDeviceDisplayPropertiesKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetPhysicalDeviceDisplayPropertiesKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceDisplayPropertiesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceDisplayPropertiesKHR_ExpectAndReturn(physicalDevice, pPropertyCount, pProperties, cmock_retval) vkGetPhysicalDeviceDisplayPropertiesKHR_CMockExpectAndReturn(__LINE__, physicalDevice, pPropertyCount, pProperties, cmock_retval) +void vkGetPhysicalDeviceDisplayPropertiesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALLBACK)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties, int cmock_num_calls); +void vkGetPhysicalDeviceDisplayPropertiesKHR_AddCallback(CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALLBACK Callback); +void vkGetPhysicalDeviceDisplayPropertiesKHR_Stub(CMOCK_vkGetPhysicalDeviceDisplayPropertiesKHR_CALLBACK Callback); +#define vkGetPhysicalDeviceDisplayPropertiesKHR_StubWithCallback vkGetPhysicalDeviceDisplayPropertiesKHR_AddCallback +#define vkGetPhysicalDeviceDisplayPropertiesKHR_ReturnThruPtr_pPropertyCount(pPropertyCount) vkGetPhysicalDeviceDisplayPropertiesKHR_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, sizeof(uint32_t)) +#define vkGetPhysicalDeviceDisplayPropertiesKHR_ReturnArrayThruPtr_pPropertyCount(pPropertyCount, cmock_len) vkGetPhysicalDeviceDisplayPropertiesKHR_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, cmock_len * sizeof(*pPropertyCount)) +#define vkGetPhysicalDeviceDisplayPropertiesKHR_ReturnMemThruPtr_pPropertyCount(pPropertyCount, cmock_size) vkGetPhysicalDeviceDisplayPropertiesKHR_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, cmock_size) +void vkGetPhysicalDeviceDisplayPropertiesKHR_CMockReturnMemThruPtr_pPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPropertyCount, size_t cmock_size); +#define vkGetPhysicalDeviceDisplayPropertiesKHR_ReturnThruPtr_pProperties(pProperties) vkGetPhysicalDeviceDisplayPropertiesKHR_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, sizeof(VkDisplayPropertiesKHR)) +#define vkGetPhysicalDeviceDisplayPropertiesKHR_ReturnArrayThruPtr_pProperties(pProperties, cmock_len) vkGetPhysicalDeviceDisplayPropertiesKHR_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_len * sizeof(*pProperties)) +#define vkGetPhysicalDeviceDisplayPropertiesKHR_ReturnMemThruPtr_pProperties(pProperties, cmock_size) vkGetPhysicalDeviceDisplayPropertiesKHR_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_size) +void vkGetPhysicalDeviceDisplayPropertiesKHR_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkDisplayPropertiesKHR const* pProperties, size_t cmock_size); +#define vkGetPhysicalDeviceDisplayPropertiesKHR_IgnoreArg_physicalDevice() vkGetPhysicalDeviceDisplayPropertiesKHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceDisplayPropertiesKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceDisplayPropertiesKHR_IgnoreArg_pPropertyCount() vkGetPhysicalDeviceDisplayPropertiesKHR_CMockIgnoreArg_pPropertyCount(__LINE__) +void vkGetPhysicalDeviceDisplayPropertiesKHR_CMockIgnoreArg_pPropertyCount(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceDisplayPropertiesKHR_IgnoreArg_pProperties() vkGetPhysicalDeviceDisplayPropertiesKHR_CMockIgnoreArg_pProperties(__LINE__) +void vkGetPhysicalDeviceDisplayPropertiesKHR_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceDisplayPlanePropertiesKHR_IgnoreAndReturn(cmock_retval) vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceDisplayPlanePropertiesKHR_StopIgnore() vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockStopIgnore() +void vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockStopIgnore(void); +#define vkGetPhysicalDeviceDisplayPlanePropertiesKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceDisplayPlanePropertiesKHR_ExpectAndReturn(physicalDevice, pPropertyCount, pProperties, cmock_retval) vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockExpectAndReturn(__LINE__, physicalDevice, pPropertyCount, pProperties, cmock_retval) +void vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALLBACK)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties, int cmock_num_calls); +void vkGetPhysicalDeviceDisplayPlanePropertiesKHR_AddCallback(CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALLBACK Callback); +void vkGetPhysicalDeviceDisplayPlanePropertiesKHR_Stub(CMOCK_vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CALLBACK Callback); +#define vkGetPhysicalDeviceDisplayPlanePropertiesKHR_StubWithCallback vkGetPhysicalDeviceDisplayPlanePropertiesKHR_AddCallback +#define vkGetPhysicalDeviceDisplayPlanePropertiesKHR_ReturnThruPtr_pPropertyCount(pPropertyCount) vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, sizeof(uint32_t)) +#define vkGetPhysicalDeviceDisplayPlanePropertiesKHR_ReturnArrayThruPtr_pPropertyCount(pPropertyCount, cmock_len) vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, cmock_len * sizeof(*pPropertyCount)) +#define vkGetPhysicalDeviceDisplayPlanePropertiesKHR_ReturnMemThruPtr_pPropertyCount(pPropertyCount, cmock_size) vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, cmock_size) +void vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockReturnMemThruPtr_pPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPropertyCount, size_t cmock_size); +#define vkGetPhysicalDeviceDisplayPlanePropertiesKHR_ReturnThruPtr_pProperties(pProperties) vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, sizeof(VkDisplayPlanePropertiesKHR)) +#define vkGetPhysicalDeviceDisplayPlanePropertiesKHR_ReturnArrayThruPtr_pProperties(pProperties, cmock_len) vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_len * sizeof(*pProperties)) +#define vkGetPhysicalDeviceDisplayPlanePropertiesKHR_ReturnMemThruPtr_pProperties(pProperties, cmock_size) vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_size) +void vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkDisplayPlanePropertiesKHR const* pProperties, size_t cmock_size); +#define vkGetPhysicalDeviceDisplayPlanePropertiesKHR_IgnoreArg_physicalDevice() vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceDisplayPlanePropertiesKHR_IgnoreArg_pPropertyCount() vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockIgnoreArg_pPropertyCount(__LINE__) +void vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockIgnoreArg_pPropertyCount(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceDisplayPlanePropertiesKHR_IgnoreArg_pProperties() vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockIgnoreArg_pProperties(__LINE__) +void vkGetPhysicalDeviceDisplayPlanePropertiesKHR_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetDisplayPlaneSupportedDisplaysKHR_IgnoreAndReturn(cmock_retval) vkGetDisplayPlaneSupportedDisplaysKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetDisplayPlaneSupportedDisplaysKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetDisplayPlaneSupportedDisplaysKHR_StopIgnore() vkGetDisplayPlaneSupportedDisplaysKHR_CMockStopIgnore() +void vkGetDisplayPlaneSupportedDisplaysKHR_CMockStopIgnore(void); +#define vkGetDisplayPlaneSupportedDisplaysKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetDisplayPlaneSupportedDisplaysKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetDisplayPlaneSupportedDisplaysKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetDisplayPlaneSupportedDisplaysKHR_ExpectAndReturn(physicalDevice, planeIndex, pDisplayCount, pDisplays, cmock_retval) vkGetDisplayPlaneSupportedDisplaysKHR_CMockExpectAndReturn(__LINE__, physicalDevice, planeIndex, pDisplayCount, pDisplays, cmock_retval) +void vkGetDisplayPlaneSupportedDisplaysKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALLBACK)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays, int cmock_num_calls); +void vkGetDisplayPlaneSupportedDisplaysKHR_AddCallback(CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALLBACK Callback); +void vkGetDisplayPlaneSupportedDisplaysKHR_Stub(CMOCK_vkGetDisplayPlaneSupportedDisplaysKHR_CALLBACK Callback); +#define vkGetDisplayPlaneSupportedDisplaysKHR_StubWithCallback vkGetDisplayPlaneSupportedDisplaysKHR_AddCallback +#define vkGetDisplayPlaneSupportedDisplaysKHR_ReturnThruPtr_pDisplayCount(pDisplayCount) vkGetDisplayPlaneSupportedDisplaysKHR_CMockReturnMemThruPtr_pDisplayCount(__LINE__, pDisplayCount, sizeof(uint32_t)) +#define vkGetDisplayPlaneSupportedDisplaysKHR_ReturnArrayThruPtr_pDisplayCount(pDisplayCount, cmock_len) vkGetDisplayPlaneSupportedDisplaysKHR_CMockReturnMemThruPtr_pDisplayCount(__LINE__, pDisplayCount, cmock_len * sizeof(*pDisplayCount)) +#define vkGetDisplayPlaneSupportedDisplaysKHR_ReturnMemThruPtr_pDisplayCount(pDisplayCount, cmock_size) vkGetDisplayPlaneSupportedDisplaysKHR_CMockReturnMemThruPtr_pDisplayCount(__LINE__, pDisplayCount, cmock_size) +void vkGetDisplayPlaneSupportedDisplaysKHR_CMockReturnMemThruPtr_pDisplayCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pDisplayCount, size_t cmock_size); +#define vkGetDisplayPlaneSupportedDisplaysKHR_ReturnThruPtr_pDisplays(pDisplays) vkGetDisplayPlaneSupportedDisplaysKHR_CMockReturnMemThruPtr_pDisplays(__LINE__, pDisplays, sizeof(VkDisplayKHR)) +#define vkGetDisplayPlaneSupportedDisplaysKHR_ReturnArrayThruPtr_pDisplays(pDisplays, cmock_len) vkGetDisplayPlaneSupportedDisplaysKHR_CMockReturnMemThruPtr_pDisplays(__LINE__, pDisplays, cmock_len * sizeof(*pDisplays)) +#define vkGetDisplayPlaneSupportedDisplaysKHR_ReturnMemThruPtr_pDisplays(pDisplays, cmock_size) vkGetDisplayPlaneSupportedDisplaysKHR_CMockReturnMemThruPtr_pDisplays(__LINE__, pDisplays, cmock_size) +void vkGetDisplayPlaneSupportedDisplaysKHR_CMockReturnMemThruPtr_pDisplays(UNITY_LINE_TYPE cmock_line, VkDisplayKHR const* pDisplays, size_t cmock_size); +#define vkGetDisplayPlaneSupportedDisplaysKHR_IgnoreArg_physicalDevice() vkGetDisplayPlaneSupportedDisplaysKHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetDisplayPlaneSupportedDisplaysKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetDisplayPlaneSupportedDisplaysKHR_IgnoreArg_planeIndex() vkGetDisplayPlaneSupportedDisplaysKHR_CMockIgnoreArg_planeIndex(__LINE__) +void vkGetDisplayPlaneSupportedDisplaysKHR_CMockIgnoreArg_planeIndex(UNITY_LINE_TYPE cmock_line); +#define vkGetDisplayPlaneSupportedDisplaysKHR_IgnoreArg_pDisplayCount() vkGetDisplayPlaneSupportedDisplaysKHR_CMockIgnoreArg_pDisplayCount(__LINE__) +void vkGetDisplayPlaneSupportedDisplaysKHR_CMockIgnoreArg_pDisplayCount(UNITY_LINE_TYPE cmock_line); +#define vkGetDisplayPlaneSupportedDisplaysKHR_IgnoreArg_pDisplays() vkGetDisplayPlaneSupportedDisplaysKHR_CMockIgnoreArg_pDisplays(__LINE__) +void vkGetDisplayPlaneSupportedDisplaysKHR_CMockIgnoreArg_pDisplays(UNITY_LINE_TYPE cmock_line); +#define vkGetDisplayModePropertiesKHR_IgnoreAndReturn(cmock_retval) vkGetDisplayModePropertiesKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetDisplayModePropertiesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetDisplayModePropertiesKHR_StopIgnore() vkGetDisplayModePropertiesKHR_CMockStopIgnore() +void vkGetDisplayModePropertiesKHR_CMockStopIgnore(void); +#define vkGetDisplayModePropertiesKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetDisplayModePropertiesKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetDisplayModePropertiesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetDisplayModePropertiesKHR_ExpectAndReturn(physicalDevice, display, pPropertyCount, pProperties, cmock_retval) vkGetDisplayModePropertiesKHR_CMockExpectAndReturn(__LINE__, physicalDevice, display, pPropertyCount, pProperties, cmock_retval) +void vkGetDisplayModePropertiesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetDisplayModePropertiesKHR_CALLBACK)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties, int cmock_num_calls); +void vkGetDisplayModePropertiesKHR_AddCallback(CMOCK_vkGetDisplayModePropertiesKHR_CALLBACK Callback); +void vkGetDisplayModePropertiesKHR_Stub(CMOCK_vkGetDisplayModePropertiesKHR_CALLBACK Callback); +#define vkGetDisplayModePropertiesKHR_StubWithCallback vkGetDisplayModePropertiesKHR_AddCallback +#define vkGetDisplayModePropertiesKHR_ReturnThruPtr_pPropertyCount(pPropertyCount) vkGetDisplayModePropertiesKHR_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, sizeof(uint32_t)) +#define vkGetDisplayModePropertiesKHR_ReturnArrayThruPtr_pPropertyCount(pPropertyCount, cmock_len) vkGetDisplayModePropertiesKHR_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, cmock_len * sizeof(*pPropertyCount)) +#define vkGetDisplayModePropertiesKHR_ReturnMemThruPtr_pPropertyCount(pPropertyCount, cmock_size) vkGetDisplayModePropertiesKHR_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, cmock_size) +void vkGetDisplayModePropertiesKHR_CMockReturnMemThruPtr_pPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPropertyCount, size_t cmock_size); +#define vkGetDisplayModePropertiesKHR_ReturnThruPtr_pProperties(pProperties) vkGetDisplayModePropertiesKHR_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, sizeof(VkDisplayModePropertiesKHR)) +#define vkGetDisplayModePropertiesKHR_ReturnArrayThruPtr_pProperties(pProperties, cmock_len) vkGetDisplayModePropertiesKHR_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_len * sizeof(*pProperties)) +#define vkGetDisplayModePropertiesKHR_ReturnMemThruPtr_pProperties(pProperties, cmock_size) vkGetDisplayModePropertiesKHR_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_size) +void vkGetDisplayModePropertiesKHR_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkDisplayModePropertiesKHR const* pProperties, size_t cmock_size); +#define vkGetDisplayModePropertiesKHR_IgnoreArg_physicalDevice() vkGetDisplayModePropertiesKHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetDisplayModePropertiesKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetDisplayModePropertiesKHR_IgnoreArg_display() vkGetDisplayModePropertiesKHR_CMockIgnoreArg_display(__LINE__) +void vkGetDisplayModePropertiesKHR_CMockIgnoreArg_display(UNITY_LINE_TYPE cmock_line); +#define vkGetDisplayModePropertiesKHR_IgnoreArg_pPropertyCount() vkGetDisplayModePropertiesKHR_CMockIgnoreArg_pPropertyCount(__LINE__) +void vkGetDisplayModePropertiesKHR_CMockIgnoreArg_pPropertyCount(UNITY_LINE_TYPE cmock_line); +#define vkGetDisplayModePropertiesKHR_IgnoreArg_pProperties() vkGetDisplayModePropertiesKHR_CMockIgnoreArg_pProperties(__LINE__) +void vkGetDisplayModePropertiesKHR_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line); +#define vkCreateDisplayModeKHR_IgnoreAndReturn(cmock_retval) vkCreateDisplayModeKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateDisplayModeKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateDisplayModeKHR_StopIgnore() vkCreateDisplayModeKHR_CMockStopIgnore() +void vkCreateDisplayModeKHR_CMockStopIgnore(void); +#define vkCreateDisplayModeKHR_ExpectAnyArgsAndReturn(cmock_retval) vkCreateDisplayModeKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateDisplayModeKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateDisplayModeKHR_ExpectAndReturn(physicalDevice, display, pCreateInfo, pAllocator, pMode, cmock_retval) vkCreateDisplayModeKHR_CMockExpectAndReturn(__LINE__, physicalDevice, display, pCreateInfo, pAllocator, pMode, cmock_retval) +void vkCreateDisplayModeKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateDisplayModeKHR_CALLBACK)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode, int cmock_num_calls); +void vkCreateDisplayModeKHR_AddCallback(CMOCK_vkCreateDisplayModeKHR_CALLBACK Callback); +void vkCreateDisplayModeKHR_Stub(CMOCK_vkCreateDisplayModeKHR_CALLBACK Callback); +#define vkCreateDisplayModeKHR_StubWithCallback vkCreateDisplayModeKHR_AddCallback +#define vkCreateDisplayModeKHR_ReturnThruPtr_pMode(pMode) vkCreateDisplayModeKHR_CMockReturnMemThruPtr_pMode(__LINE__, pMode, sizeof(VkDisplayModeKHR)) +#define vkCreateDisplayModeKHR_ReturnArrayThruPtr_pMode(pMode, cmock_len) vkCreateDisplayModeKHR_CMockReturnMemThruPtr_pMode(__LINE__, pMode, cmock_len * sizeof(*pMode)) +#define vkCreateDisplayModeKHR_ReturnMemThruPtr_pMode(pMode, cmock_size) vkCreateDisplayModeKHR_CMockReturnMemThruPtr_pMode(__LINE__, pMode, cmock_size) +void vkCreateDisplayModeKHR_CMockReturnMemThruPtr_pMode(UNITY_LINE_TYPE cmock_line, VkDisplayModeKHR const* pMode, size_t cmock_size); +#define vkCreateDisplayModeKHR_IgnoreArg_physicalDevice() vkCreateDisplayModeKHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkCreateDisplayModeKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkCreateDisplayModeKHR_IgnoreArg_display() vkCreateDisplayModeKHR_CMockIgnoreArg_display(__LINE__) +void vkCreateDisplayModeKHR_CMockIgnoreArg_display(UNITY_LINE_TYPE cmock_line); +#define vkCreateDisplayModeKHR_IgnoreArg_pCreateInfo() vkCreateDisplayModeKHR_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateDisplayModeKHR_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateDisplayModeKHR_IgnoreArg_pAllocator() vkCreateDisplayModeKHR_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateDisplayModeKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateDisplayModeKHR_IgnoreArg_pMode() vkCreateDisplayModeKHR_CMockIgnoreArg_pMode(__LINE__) +void vkCreateDisplayModeKHR_CMockIgnoreArg_pMode(UNITY_LINE_TYPE cmock_line); +#define vkGetDisplayPlaneCapabilitiesKHR_IgnoreAndReturn(cmock_retval) vkGetDisplayPlaneCapabilitiesKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetDisplayPlaneCapabilitiesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetDisplayPlaneCapabilitiesKHR_StopIgnore() vkGetDisplayPlaneCapabilitiesKHR_CMockStopIgnore() +void vkGetDisplayPlaneCapabilitiesKHR_CMockStopIgnore(void); +#define vkGetDisplayPlaneCapabilitiesKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetDisplayPlaneCapabilitiesKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetDisplayPlaneCapabilitiesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetDisplayPlaneCapabilitiesKHR_ExpectAndReturn(physicalDevice, mode, planeIndex, pCapabilities, cmock_retval) vkGetDisplayPlaneCapabilitiesKHR_CMockExpectAndReturn(__LINE__, physicalDevice, mode, planeIndex, pCapabilities, cmock_retval) +void vkGetDisplayPlaneCapabilitiesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALLBACK)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities, int cmock_num_calls); +void vkGetDisplayPlaneCapabilitiesKHR_AddCallback(CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALLBACK Callback); +void vkGetDisplayPlaneCapabilitiesKHR_Stub(CMOCK_vkGetDisplayPlaneCapabilitiesKHR_CALLBACK Callback); +#define vkGetDisplayPlaneCapabilitiesKHR_StubWithCallback vkGetDisplayPlaneCapabilitiesKHR_AddCallback +#define vkGetDisplayPlaneCapabilitiesKHR_ReturnThruPtr_pCapabilities(pCapabilities) vkGetDisplayPlaneCapabilitiesKHR_CMockReturnMemThruPtr_pCapabilities(__LINE__, pCapabilities, sizeof(VkDisplayPlaneCapabilitiesKHR)) +#define vkGetDisplayPlaneCapabilitiesKHR_ReturnArrayThruPtr_pCapabilities(pCapabilities, cmock_len) vkGetDisplayPlaneCapabilitiesKHR_CMockReturnMemThruPtr_pCapabilities(__LINE__, pCapabilities, cmock_len * sizeof(*pCapabilities)) +#define vkGetDisplayPlaneCapabilitiesKHR_ReturnMemThruPtr_pCapabilities(pCapabilities, cmock_size) vkGetDisplayPlaneCapabilitiesKHR_CMockReturnMemThruPtr_pCapabilities(__LINE__, pCapabilities, cmock_size) +void vkGetDisplayPlaneCapabilitiesKHR_CMockReturnMemThruPtr_pCapabilities(UNITY_LINE_TYPE cmock_line, VkDisplayPlaneCapabilitiesKHR const* pCapabilities, size_t cmock_size); +#define vkGetDisplayPlaneCapabilitiesKHR_IgnoreArg_physicalDevice() vkGetDisplayPlaneCapabilitiesKHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetDisplayPlaneCapabilitiesKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetDisplayPlaneCapabilitiesKHR_IgnoreArg_mode() vkGetDisplayPlaneCapabilitiesKHR_CMockIgnoreArg_mode(__LINE__) +void vkGetDisplayPlaneCapabilitiesKHR_CMockIgnoreArg_mode(UNITY_LINE_TYPE cmock_line); +#define vkGetDisplayPlaneCapabilitiesKHR_IgnoreArg_planeIndex() vkGetDisplayPlaneCapabilitiesKHR_CMockIgnoreArg_planeIndex(__LINE__) +void vkGetDisplayPlaneCapabilitiesKHR_CMockIgnoreArg_planeIndex(UNITY_LINE_TYPE cmock_line); +#define vkGetDisplayPlaneCapabilitiesKHR_IgnoreArg_pCapabilities() vkGetDisplayPlaneCapabilitiesKHR_CMockIgnoreArg_pCapabilities(__LINE__) +void vkGetDisplayPlaneCapabilitiesKHR_CMockIgnoreArg_pCapabilities(UNITY_LINE_TYPE cmock_line); +#define vkCreateDisplayPlaneSurfaceKHR_IgnoreAndReturn(cmock_retval) vkCreateDisplayPlaneSurfaceKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateDisplayPlaneSurfaceKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateDisplayPlaneSurfaceKHR_StopIgnore() vkCreateDisplayPlaneSurfaceKHR_CMockStopIgnore() +void vkCreateDisplayPlaneSurfaceKHR_CMockStopIgnore(void); +#define vkCreateDisplayPlaneSurfaceKHR_ExpectAnyArgsAndReturn(cmock_retval) vkCreateDisplayPlaneSurfaceKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateDisplayPlaneSurfaceKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateDisplayPlaneSurfaceKHR_ExpectAndReturn(instance, pCreateInfo, pAllocator, pSurface, cmock_retval) vkCreateDisplayPlaneSurfaceKHR_CMockExpectAndReturn(__LINE__, instance, pCreateInfo, pAllocator, pSurface, cmock_retval) +void vkCreateDisplayPlaneSurfaceKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALLBACK)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, int cmock_num_calls); +void vkCreateDisplayPlaneSurfaceKHR_AddCallback(CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALLBACK Callback); +void vkCreateDisplayPlaneSurfaceKHR_Stub(CMOCK_vkCreateDisplayPlaneSurfaceKHR_CALLBACK Callback); +#define vkCreateDisplayPlaneSurfaceKHR_StubWithCallback vkCreateDisplayPlaneSurfaceKHR_AddCallback +#define vkCreateDisplayPlaneSurfaceKHR_ReturnThruPtr_pSurface(pSurface) vkCreateDisplayPlaneSurfaceKHR_CMockReturnMemThruPtr_pSurface(__LINE__, pSurface, sizeof(VkSurfaceKHR)) +#define vkCreateDisplayPlaneSurfaceKHR_ReturnArrayThruPtr_pSurface(pSurface, cmock_len) vkCreateDisplayPlaneSurfaceKHR_CMockReturnMemThruPtr_pSurface(__LINE__, pSurface, cmock_len * sizeof(*pSurface)) +#define vkCreateDisplayPlaneSurfaceKHR_ReturnMemThruPtr_pSurface(pSurface, cmock_size) vkCreateDisplayPlaneSurfaceKHR_CMockReturnMemThruPtr_pSurface(__LINE__, pSurface, cmock_size) +void vkCreateDisplayPlaneSurfaceKHR_CMockReturnMemThruPtr_pSurface(UNITY_LINE_TYPE cmock_line, VkSurfaceKHR const* pSurface, size_t cmock_size); +#define vkCreateDisplayPlaneSurfaceKHR_IgnoreArg_instance() vkCreateDisplayPlaneSurfaceKHR_CMockIgnoreArg_instance(__LINE__) +void vkCreateDisplayPlaneSurfaceKHR_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line); +#define vkCreateDisplayPlaneSurfaceKHR_IgnoreArg_pCreateInfo() vkCreateDisplayPlaneSurfaceKHR_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateDisplayPlaneSurfaceKHR_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateDisplayPlaneSurfaceKHR_IgnoreArg_pAllocator() vkCreateDisplayPlaneSurfaceKHR_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateDisplayPlaneSurfaceKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateDisplayPlaneSurfaceKHR_IgnoreArg_pSurface() vkCreateDisplayPlaneSurfaceKHR_CMockIgnoreArg_pSurface(__LINE__) +void vkCreateDisplayPlaneSurfaceKHR_CMockIgnoreArg_pSurface(UNITY_LINE_TYPE cmock_line); +#define vkCreateSharedSwapchainsKHR_IgnoreAndReturn(cmock_retval) vkCreateSharedSwapchainsKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateSharedSwapchainsKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateSharedSwapchainsKHR_StopIgnore() vkCreateSharedSwapchainsKHR_CMockStopIgnore() +void vkCreateSharedSwapchainsKHR_CMockStopIgnore(void); +#define vkCreateSharedSwapchainsKHR_ExpectAnyArgsAndReturn(cmock_retval) vkCreateSharedSwapchainsKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateSharedSwapchainsKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateSharedSwapchainsKHR_ExpectAndReturn(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains, cmock_retval) vkCreateSharedSwapchainsKHR_CMockExpectAndReturn(__LINE__, device, swapchainCount, pCreateInfos, pAllocator, pSwapchains, cmock_retval) +void vkCreateSharedSwapchainsKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateSharedSwapchainsKHR_CALLBACK)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains, int cmock_num_calls); +void vkCreateSharedSwapchainsKHR_AddCallback(CMOCK_vkCreateSharedSwapchainsKHR_CALLBACK Callback); +void vkCreateSharedSwapchainsKHR_Stub(CMOCK_vkCreateSharedSwapchainsKHR_CALLBACK Callback); +#define vkCreateSharedSwapchainsKHR_StubWithCallback vkCreateSharedSwapchainsKHR_AddCallback +#define vkCreateSharedSwapchainsKHR_ReturnThruPtr_pSwapchains(pSwapchains) vkCreateSharedSwapchainsKHR_CMockReturnMemThruPtr_pSwapchains(__LINE__, pSwapchains, sizeof(VkSwapchainKHR)) +#define vkCreateSharedSwapchainsKHR_ReturnArrayThruPtr_pSwapchains(pSwapchains, cmock_len) vkCreateSharedSwapchainsKHR_CMockReturnMemThruPtr_pSwapchains(__LINE__, pSwapchains, cmock_len * sizeof(*pSwapchains)) +#define vkCreateSharedSwapchainsKHR_ReturnMemThruPtr_pSwapchains(pSwapchains, cmock_size) vkCreateSharedSwapchainsKHR_CMockReturnMemThruPtr_pSwapchains(__LINE__, pSwapchains, cmock_size) +void vkCreateSharedSwapchainsKHR_CMockReturnMemThruPtr_pSwapchains(UNITY_LINE_TYPE cmock_line, VkSwapchainKHR const* pSwapchains, size_t cmock_size); +#define vkCreateSharedSwapchainsKHR_IgnoreArg_device() vkCreateSharedSwapchainsKHR_CMockIgnoreArg_device(__LINE__) +void vkCreateSharedSwapchainsKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateSharedSwapchainsKHR_IgnoreArg_swapchainCount() vkCreateSharedSwapchainsKHR_CMockIgnoreArg_swapchainCount(__LINE__) +void vkCreateSharedSwapchainsKHR_CMockIgnoreArg_swapchainCount(UNITY_LINE_TYPE cmock_line); +#define vkCreateSharedSwapchainsKHR_IgnoreArg_pCreateInfos() vkCreateSharedSwapchainsKHR_CMockIgnoreArg_pCreateInfos(__LINE__) +void vkCreateSharedSwapchainsKHR_CMockIgnoreArg_pCreateInfos(UNITY_LINE_TYPE cmock_line); +#define vkCreateSharedSwapchainsKHR_IgnoreArg_pAllocator() vkCreateSharedSwapchainsKHR_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateSharedSwapchainsKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateSharedSwapchainsKHR_IgnoreArg_pSwapchains() vkCreateSharedSwapchainsKHR_CMockIgnoreArg_pSwapchains(__LINE__) +void vkCreateSharedSwapchainsKHR_CMockIgnoreArg_pSwapchains(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceVideoCapabilitiesKHR_IgnoreAndReturn(cmock_retval) vkGetPhysicalDeviceVideoCapabilitiesKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceVideoCapabilitiesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceVideoCapabilitiesKHR_StopIgnore() vkGetPhysicalDeviceVideoCapabilitiesKHR_CMockStopIgnore() +void vkGetPhysicalDeviceVideoCapabilitiesKHR_CMockStopIgnore(void); +#define vkGetPhysicalDeviceVideoCapabilitiesKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetPhysicalDeviceVideoCapabilitiesKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceVideoCapabilitiesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceVideoCapabilitiesKHR_ExpectAndReturn(physicalDevice, pVideoProfile, pCapabilities, cmock_retval) vkGetPhysicalDeviceVideoCapabilitiesKHR_CMockExpectAndReturn(__LINE__, physicalDevice, pVideoProfile, pCapabilities, cmock_retval) +void vkGetPhysicalDeviceVideoCapabilitiesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPhysicalDeviceVideoCapabilitiesKHR_CALLBACK)(VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities, int cmock_num_calls); +void vkGetPhysicalDeviceVideoCapabilitiesKHR_AddCallback(CMOCK_vkGetPhysicalDeviceVideoCapabilitiesKHR_CALLBACK Callback); +void vkGetPhysicalDeviceVideoCapabilitiesKHR_Stub(CMOCK_vkGetPhysicalDeviceVideoCapabilitiesKHR_CALLBACK Callback); +#define vkGetPhysicalDeviceVideoCapabilitiesKHR_StubWithCallback vkGetPhysicalDeviceVideoCapabilitiesKHR_AddCallback +#define vkGetPhysicalDeviceVideoCapabilitiesKHR_ReturnThruPtr_pCapabilities(pCapabilities) vkGetPhysicalDeviceVideoCapabilitiesKHR_CMockReturnMemThruPtr_pCapabilities(__LINE__, pCapabilities, sizeof(VkVideoCapabilitiesKHR)) +#define vkGetPhysicalDeviceVideoCapabilitiesKHR_ReturnArrayThruPtr_pCapabilities(pCapabilities, cmock_len) vkGetPhysicalDeviceVideoCapabilitiesKHR_CMockReturnMemThruPtr_pCapabilities(__LINE__, pCapabilities, cmock_len * sizeof(*pCapabilities)) +#define vkGetPhysicalDeviceVideoCapabilitiesKHR_ReturnMemThruPtr_pCapabilities(pCapabilities, cmock_size) vkGetPhysicalDeviceVideoCapabilitiesKHR_CMockReturnMemThruPtr_pCapabilities(__LINE__, pCapabilities, cmock_size) +void vkGetPhysicalDeviceVideoCapabilitiesKHR_CMockReturnMemThruPtr_pCapabilities(UNITY_LINE_TYPE cmock_line, VkVideoCapabilitiesKHR const* pCapabilities, size_t cmock_size); +#define vkGetPhysicalDeviceVideoCapabilitiesKHR_IgnoreArg_physicalDevice() vkGetPhysicalDeviceVideoCapabilitiesKHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceVideoCapabilitiesKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceVideoCapabilitiesKHR_IgnoreArg_pVideoProfile() vkGetPhysicalDeviceVideoCapabilitiesKHR_CMockIgnoreArg_pVideoProfile(__LINE__) +void vkGetPhysicalDeviceVideoCapabilitiesKHR_CMockIgnoreArg_pVideoProfile(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceVideoCapabilitiesKHR_IgnoreArg_pCapabilities() vkGetPhysicalDeviceVideoCapabilitiesKHR_CMockIgnoreArg_pCapabilities(__LINE__) +void vkGetPhysicalDeviceVideoCapabilitiesKHR_CMockIgnoreArg_pCapabilities(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceVideoFormatPropertiesKHR_IgnoreAndReturn(cmock_retval) vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceVideoFormatPropertiesKHR_StopIgnore() vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockStopIgnore() +void vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockStopIgnore(void); +#define vkGetPhysicalDeviceVideoFormatPropertiesKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceVideoFormatPropertiesKHR_ExpectAndReturn(physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties, cmock_retval) vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockExpectAndReturn(__LINE__, physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties, cmock_retval) +void vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALLBACK)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties, int cmock_num_calls); +void vkGetPhysicalDeviceVideoFormatPropertiesKHR_AddCallback(CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALLBACK Callback); +void vkGetPhysicalDeviceVideoFormatPropertiesKHR_Stub(CMOCK_vkGetPhysicalDeviceVideoFormatPropertiesKHR_CALLBACK Callback); +#define vkGetPhysicalDeviceVideoFormatPropertiesKHR_StubWithCallback vkGetPhysicalDeviceVideoFormatPropertiesKHR_AddCallback +#define vkGetPhysicalDeviceVideoFormatPropertiesKHR_ReturnThruPtr_pVideoFormatPropertyCount(pVideoFormatPropertyCount) vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockReturnMemThruPtr_pVideoFormatPropertyCount(__LINE__, pVideoFormatPropertyCount, sizeof(uint32_t)) +#define vkGetPhysicalDeviceVideoFormatPropertiesKHR_ReturnArrayThruPtr_pVideoFormatPropertyCount(pVideoFormatPropertyCount, cmock_len) vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockReturnMemThruPtr_pVideoFormatPropertyCount(__LINE__, pVideoFormatPropertyCount, cmock_len * sizeof(*pVideoFormatPropertyCount)) +#define vkGetPhysicalDeviceVideoFormatPropertiesKHR_ReturnMemThruPtr_pVideoFormatPropertyCount(pVideoFormatPropertyCount, cmock_size) vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockReturnMemThruPtr_pVideoFormatPropertyCount(__LINE__, pVideoFormatPropertyCount, cmock_size) +void vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockReturnMemThruPtr_pVideoFormatPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pVideoFormatPropertyCount, size_t cmock_size); +#define vkGetPhysicalDeviceVideoFormatPropertiesKHR_ReturnThruPtr_pVideoFormatProperties(pVideoFormatProperties) vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockReturnMemThruPtr_pVideoFormatProperties(__LINE__, pVideoFormatProperties, sizeof(VkVideoFormatPropertiesKHR)) +#define vkGetPhysicalDeviceVideoFormatPropertiesKHR_ReturnArrayThruPtr_pVideoFormatProperties(pVideoFormatProperties, cmock_len) vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockReturnMemThruPtr_pVideoFormatProperties(__LINE__, pVideoFormatProperties, cmock_len * sizeof(*pVideoFormatProperties)) +#define vkGetPhysicalDeviceVideoFormatPropertiesKHR_ReturnMemThruPtr_pVideoFormatProperties(pVideoFormatProperties, cmock_size) vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockReturnMemThruPtr_pVideoFormatProperties(__LINE__, pVideoFormatProperties, cmock_size) +void vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockReturnMemThruPtr_pVideoFormatProperties(UNITY_LINE_TYPE cmock_line, VkVideoFormatPropertiesKHR const* pVideoFormatProperties, size_t cmock_size); +#define vkGetPhysicalDeviceVideoFormatPropertiesKHR_IgnoreArg_physicalDevice() vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceVideoFormatPropertiesKHR_IgnoreArg_pVideoFormatInfo() vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockIgnoreArg_pVideoFormatInfo(__LINE__) +void vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockIgnoreArg_pVideoFormatInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceVideoFormatPropertiesKHR_IgnoreArg_pVideoFormatPropertyCount() vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockIgnoreArg_pVideoFormatPropertyCount(__LINE__) +void vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockIgnoreArg_pVideoFormatPropertyCount(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceVideoFormatPropertiesKHR_IgnoreArg_pVideoFormatProperties() vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockIgnoreArg_pVideoFormatProperties(__LINE__) +void vkGetPhysicalDeviceVideoFormatPropertiesKHR_CMockIgnoreArg_pVideoFormatProperties(UNITY_LINE_TYPE cmock_line); +#define vkCreateVideoSessionKHR_IgnoreAndReturn(cmock_retval) vkCreateVideoSessionKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateVideoSessionKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateVideoSessionKHR_StopIgnore() vkCreateVideoSessionKHR_CMockStopIgnore() +void vkCreateVideoSessionKHR_CMockStopIgnore(void); +#define vkCreateVideoSessionKHR_ExpectAnyArgsAndReturn(cmock_retval) vkCreateVideoSessionKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateVideoSessionKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateVideoSessionKHR_ExpectAndReturn(device, pCreateInfo, pAllocator, pVideoSession, cmock_retval) vkCreateVideoSessionKHR_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pVideoSession, cmock_retval) +void vkCreateVideoSessionKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateVideoSessionKHR_CALLBACK)(VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession, int cmock_num_calls); +void vkCreateVideoSessionKHR_AddCallback(CMOCK_vkCreateVideoSessionKHR_CALLBACK Callback); +void vkCreateVideoSessionKHR_Stub(CMOCK_vkCreateVideoSessionKHR_CALLBACK Callback); +#define vkCreateVideoSessionKHR_StubWithCallback vkCreateVideoSessionKHR_AddCallback +#define vkCreateVideoSessionKHR_ReturnThruPtr_pVideoSession(pVideoSession) vkCreateVideoSessionKHR_CMockReturnMemThruPtr_pVideoSession(__LINE__, pVideoSession, sizeof(VkVideoSessionKHR)) +#define vkCreateVideoSessionKHR_ReturnArrayThruPtr_pVideoSession(pVideoSession, cmock_len) vkCreateVideoSessionKHR_CMockReturnMemThruPtr_pVideoSession(__LINE__, pVideoSession, cmock_len * sizeof(*pVideoSession)) +#define vkCreateVideoSessionKHR_ReturnMemThruPtr_pVideoSession(pVideoSession, cmock_size) vkCreateVideoSessionKHR_CMockReturnMemThruPtr_pVideoSession(__LINE__, pVideoSession, cmock_size) +void vkCreateVideoSessionKHR_CMockReturnMemThruPtr_pVideoSession(UNITY_LINE_TYPE cmock_line, VkVideoSessionKHR const* pVideoSession, size_t cmock_size); +#define vkCreateVideoSessionKHR_IgnoreArg_device() vkCreateVideoSessionKHR_CMockIgnoreArg_device(__LINE__) +void vkCreateVideoSessionKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateVideoSessionKHR_IgnoreArg_pCreateInfo() vkCreateVideoSessionKHR_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateVideoSessionKHR_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateVideoSessionKHR_IgnoreArg_pAllocator() vkCreateVideoSessionKHR_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateVideoSessionKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateVideoSessionKHR_IgnoreArg_pVideoSession() vkCreateVideoSessionKHR_CMockIgnoreArg_pVideoSession(__LINE__) +void vkCreateVideoSessionKHR_CMockIgnoreArg_pVideoSession(UNITY_LINE_TYPE cmock_line); +#define vkDestroyVideoSessionKHR_Ignore() vkDestroyVideoSessionKHR_CMockIgnore() +void vkDestroyVideoSessionKHR_CMockIgnore(void); +#define vkDestroyVideoSessionKHR_StopIgnore() vkDestroyVideoSessionKHR_CMockStopIgnore() +void vkDestroyVideoSessionKHR_CMockStopIgnore(void); +#define vkDestroyVideoSessionKHR_ExpectAnyArgs() vkDestroyVideoSessionKHR_CMockExpectAnyArgs(__LINE__) +void vkDestroyVideoSessionKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyVideoSessionKHR_Expect(device, videoSession, pAllocator) vkDestroyVideoSessionKHR_CMockExpect(__LINE__, device, videoSession, pAllocator) +void vkDestroyVideoSessionKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyVideoSessionKHR_CALLBACK)(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyVideoSessionKHR_AddCallback(CMOCK_vkDestroyVideoSessionKHR_CALLBACK Callback); +void vkDestroyVideoSessionKHR_Stub(CMOCK_vkDestroyVideoSessionKHR_CALLBACK Callback); +#define vkDestroyVideoSessionKHR_StubWithCallback vkDestroyVideoSessionKHR_AddCallback +#define vkDestroyVideoSessionKHR_IgnoreArg_device() vkDestroyVideoSessionKHR_CMockIgnoreArg_device(__LINE__) +void vkDestroyVideoSessionKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyVideoSessionKHR_IgnoreArg_videoSession() vkDestroyVideoSessionKHR_CMockIgnoreArg_videoSession(__LINE__) +void vkDestroyVideoSessionKHR_CMockIgnoreArg_videoSession(UNITY_LINE_TYPE cmock_line); +#define vkDestroyVideoSessionKHR_IgnoreArg_pAllocator() vkDestroyVideoSessionKHR_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyVideoSessionKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkGetVideoSessionMemoryRequirementsKHR_IgnoreAndReturn(cmock_retval) vkGetVideoSessionMemoryRequirementsKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetVideoSessionMemoryRequirementsKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetVideoSessionMemoryRequirementsKHR_StopIgnore() vkGetVideoSessionMemoryRequirementsKHR_CMockStopIgnore() +void vkGetVideoSessionMemoryRequirementsKHR_CMockStopIgnore(void); +#define vkGetVideoSessionMemoryRequirementsKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetVideoSessionMemoryRequirementsKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetVideoSessionMemoryRequirementsKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetVideoSessionMemoryRequirementsKHR_ExpectAndReturn(device, videoSession, pMemoryRequirementsCount, pMemoryRequirements, cmock_retval) vkGetVideoSessionMemoryRequirementsKHR_CMockExpectAndReturn(__LINE__, device, videoSession, pMemoryRequirementsCount, pMemoryRequirements, cmock_retval) +void vkGetVideoSessionMemoryRequirementsKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALLBACK)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements, int cmock_num_calls); +void vkGetVideoSessionMemoryRequirementsKHR_AddCallback(CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALLBACK Callback); +void vkGetVideoSessionMemoryRequirementsKHR_Stub(CMOCK_vkGetVideoSessionMemoryRequirementsKHR_CALLBACK Callback); +#define vkGetVideoSessionMemoryRequirementsKHR_StubWithCallback vkGetVideoSessionMemoryRequirementsKHR_AddCallback +#define vkGetVideoSessionMemoryRequirementsKHR_ReturnThruPtr_pMemoryRequirementsCount(pMemoryRequirementsCount) vkGetVideoSessionMemoryRequirementsKHR_CMockReturnMemThruPtr_pMemoryRequirementsCount(__LINE__, pMemoryRequirementsCount, sizeof(uint32_t)) +#define vkGetVideoSessionMemoryRequirementsKHR_ReturnArrayThruPtr_pMemoryRequirementsCount(pMemoryRequirementsCount, cmock_len) vkGetVideoSessionMemoryRequirementsKHR_CMockReturnMemThruPtr_pMemoryRequirementsCount(__LINE__, pMemoryRequirementsCount, cmock_len * sizeof(*pMemoryRequirementsCount)) +#define vkGetVideoSessionMemoryRequirementsKHR_ReturnMemThruPtr_pMemoryRequirementsCount(pMemoryRequirementsCount, cmock_size) vkGetVideoSessionMemoryRequirementsKHR_CMockReturnMemThruPtr_pMemoryRequirementsCount(__LINE__, pMemoryRequirementsCount, cmock_size) +void vkGetVideoSessionMemoryRequirementsKHR_CMockReturnMemThruPtr_pMemoryRequirementsCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pMemoryRequirementsCount, size_t cmock_size); +#define vkGetVideoSessionMemoryRequirementsKHR_ReturnThruPtr_pMemoryRequirements(pMemoryRequirements) vkGetVideoSessionMemoryRequirementsKHR_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, sizeof(VkVideoSessionMemoryRequirementsKHR)) +#define vkGetVideoSessionMemoryRequirementsKHR_ReturnArrayThruPtr_pMemoryRequirements(pMemoryRequirements, cmock_len) vkGetVideoSessionMemoryRequirementsKHR_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, cmock_len * sizeof(*pMemoryRequirements)) +#define vkGetVideoSessionMemoryRequirementsKHR_ReturnMemThruPtr_pMemoryRequirements(pMemoryRequirements, cmock_size) vkGetVideoSessionMemoryRequirementsKHR_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, cmock_size) +void vkGetVideoSessionMemoryRequirementsKHR_CMockReturnMemThruPtr_pMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkVideoSessionMemoryRequirementsKHR const* pMemoryRequirements, size_t cmock_size); +#define vkGetVideoSessionMemoryRequirementsKHR_IgnoreArg_device() vkGetVideoSessionMemoryRequirementsKHR_CMockIgnoreArg_device(__LINE__) +void vkGetVideoSessionMemoryRequirementsKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetVideoSessionMemoryRequirementsKHR_IgnoreArg_videoSession() vkGetVideoSessionMemoryRequirementsKHR_CMockIgnoreArg_videoSession(__LINE__) +void vkGetVideoSessionMemoryRequirementsKHR_CMockIgnoreArg_videoSession(UNITY_LINE_TYPE cmock_line); +#define vkGetVideoSessionMemoryRequirementsKHR_IgnoreArg_pMemoryRequirementsCount() vkGetVideoSessionMemoryRequirementsKHR_CMockIgnoreArg_pMemoryRequirementsCount(__LINE__) +void vkGetVideoSessionMemoryRequirementsKHR_CMockIgnoreArg_pMemoryRequirementsCount(UNITY_LINE_TYPE cmock_line); +#define vkGetVideoSessionMemoryRequirementsKHR_IgnoreArg_pMemoryRequirements() vkGetVideoSessionMemoryRequirementsKHR_CMockIgnoreArg_pMemoryRequirements(__LINE__) +void vkGetVideoSessionMemoryRequirementsKHR_CMockIgnoreArg_pMemoryRequirements(UNITY_LINE_TYPE cmock_line); +#define vkBindVideoSessionMemoryKHR_IgnoreAndReturn(cmock_retval) vkBindVideoSessionMemoryKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkBindVideoSessionMemoryKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkBindVideoSessionMemoryKHR_StopIgnore() vkBindVideoSessionMemoryKHR_CMockStopIgnore() +void vkBindVideoSessionMemoryKHR_CMockStopIgnore(void); +#define vkBindVideoSessionMemoryKHR_ExpectAnyArgsAndReturn(cmock_retval) vkBindVideoSessionMemoryKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkBindVideoSessionMemoryKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkBindVideoSessionMemoryKHR_ExpectAndReturn(device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos, cmock_retval) vkBindVideoSessionMemoryKHR_CMockExpectAndReturn(__LINE__, device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos, cmock_retval) +void vkBindVideoSessionMemoryKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkBindVideoSessionMemoryKHR_CALLBACK)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos, int cmock_num_calls); +void vkBindVideoSessionMemoryKHR_AddCallback(CMOCK_vkBindVideoSessionMemoryKHR_CALLBACK Callback); +void vkBindVideoSessionMemoryKHR_Stub(CMOCK_vkBindVideoSessionMemoryKHR_CALLBACK Callback); +#define vkBindVideoSessionMemoryKHR_StubWithCallback vkBindVideoSessionMemoryKHR_AddCallback +#define vkBindVideoSessionMemoryKHR_IgnoreArg_device() vkBindVideoSessionMemoryKHR_CMockIgnoreArg_device(__LINE__) +void vkBindVideoSessionMemoryKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkBindVideoSessionMemoryKHR_IgnoreArg_videoSession() vkBindVideoSessionMemoryKHR_CMockIgnoreArg_videoSession(__LINE__) +void vkBindVideoSessionMemoryKHR_CMockIgnoreArg_videoSession(UNITY_LINE_TYPE cmock_line); +#define vkBindVideoSessionMemoryKHR_IgnoreArg_bindSessionMemoryInfoCount() vkBindVideoSessionMemoryKHR_CMockIgnoreArg_bindSessionMemoryInfoCount(__LINE__) +void vkBindVideoSessionMemoryKHR_CMockIgnoreArg_bindSessionMemoryInfoCount(UNITY_LINE_TYPE cmock_line); +#define vkBindVideoSessionMemoryKHR_IgnoreArg_pBindSessionMemoryInfos() vkBindVideoSessionMemoryKHR_CMockIgnoreArg_pBindSessionMemoryInfos(__LINE__) +void vkBindVideoSessionMemoryKHR_CMockIgnoreArg_pBindSessionMemoryInfos(UNITY_LINE_TYPE cmock_line); +#define vkCreateVideoSessionParametersKHR_IgnoreAndReturn(cmock_retval) vkCreateVideoSessionParametersKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateVideoSessionParametersKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateVideoSessionParametersKHR_StopIgnore() vkCreateVideoSessionParametersKHR_CMockStopIgnore() +void vkCreateVideoSessionParametersKHR_CMockStopIgnore(void); +#define vkCreateVideoSessionParametersKHR_ExpectAnyArgsAndReturn(cmock_retval) vkCreateVideoSessionParametersKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateVideoSessionParametersKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateVideoSessionParametersKHR_ExpectAndReturn(device, pCreateInfo, pAllocator, pVideoSessionParameters, cmock_retval) vkCreateVideoSessionParametersKHR_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pVideoSessionParameters, cmock_retval) +void vkCreateVideoSessionParametersKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateVideoSessionParametersKHR_CALLBACK)(VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters, int cmock_num_calls); +void vkCreateVideoSessionParametersKHR_AddCallback(CMOCK_vkCreateVideoSessionParametersKHR_CALLBACK Callback); +void vkCreateVideoSessionParametersKHR_Stub(CMOCK_vkCreateVideoSessionParametersKHR_CALLBACK Callback); +#define vkCreateVideoSessionParametersKHR_StubWithCallback vkCreateVideoSessionParametersKHR_AddCallback +#define vkCreateVideoSessionParametersKHR_ReturnThruPtr_pVideoSessionParameters(pVideoSessionParameters) vkCreateVideoSessionParametersKHR_CMockReturnMemThruPtr_pVideoSessionParameters(__LINE__, pVideoSessionParameters, sizeof(VkVideoSessionParametersKHR)) +#define vkCreateVideoSessionParametersKHR_ReturnArrayThruPtr_pVideoSessionParameters(pVideoSessionParameters, cmock_len) vkCreateVideoSessionParametersKHR_CMockReturnMemThruPtr_pVideoSessionParameters(__LINE__, pVideoSessionParameters, cmock_len * sizeof(*pVideoSessionParameters)) +#define vkCreateVideoSessionParametersKHR_ReturnMemThruPtr_pVideoSessionParameters(pVideoSessionParameters, cmock_size) vkCreateVideoSessionParametersKHR_CMockReturnMemThruPtr_pVideoSessionParameters(__LINE__, pVideoSessionParameters, cmock_size) +void vkCreateVideoSessionParametersKHR_CMockReturnMemThruPtr_pVideoSessionParameters(UNITY_LINE_TYPE cmock_line, VkVideoSessionParametersKHR const* pVideoSessionParameters, size_t cmock_size); +#define vkCreateVideoSessionParametersKHR_IgnoreArg_device() vkCreateVideoSessionParametersKHR_CMockIgnoreArg_device(__LINE__) +void vkCreateVideoSessionParametersKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateVideoSessionParametersKHR_IgnoreArg_pCreateInfo() vkCreateVideoSessionParametersKHR_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateVideoSessionParametersKHR_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateVideoSessionParametersKHR_IgnoreArg_pAllocator() vkCreateVideoSessionParametersKHR_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateVideoSessionParametersKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateVideoSessionParametersKHR_IgnoreArg_pVideoSessionParameters() vkCreateVideoSessionParametersKHR_CMockIgnoreArg_pVideoSessionParameters(__LINE__) +void vkCreateVideoSessionParametersKHR_CMockIgnoreArg_pVideoSessionParameters(UNITY_LINE_TYPE cmock_line); +#define vkUpdateVideoSessionParametersKHR_IgnoreAndReturn(cmock_retval) vkUpdateVideoSessionParametersKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkUpdateVideoSessionParametersKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkUpdateVideoSessionParametersKHR_StopIgnore() vkUpdateVideoSessionParametersKHR_CMockStopIgnore() +void vkUpdateVideoSessionParametersKHR_CMockStopIgnore(void); +#define vkUpdateVideoSessionParametersKHR_ExpectAnyArgsAndReturn(cmock_retval) vkUpdateVideoSessionParametersKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkUpdateVideoSessionParametersKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkUpdateVideoSessionParametersKHR_ExpectAndReturn(device, videoSessionParameters, pUpdateInfo, cmock_retval) vkUpdateVideoSessionParametersKHR_CMockExpectAndReturn(__LINE__, device, videoSessionParameters, pUpdateInfo, cmock_retval) +void vkUpdateVideoSessionParametersKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkUpdateVideoSessionParametersKHR_CALLBACK)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo, int cmock_num_calls); +void vkUpdateVideoSessionParametersKHR_AddCallback(CMOCK_vkUpdateVideoSessionParametersKHR_CALLBACK Callback); +void vkUpdateVideoSessionParametersKHR_Stub(CMOCK_vkUpdateVideoSessionParametersKHR_CALLBACK Callback); +#define vkUpdateVideoSessionParametersKHR_StubWithCallback vkUpdateVideoSessionParametersKHR_AddCallback +#define vkUpdateVideoSessionParametersKHR_IgnoreArg_device() vkUpdateVideoSessionParametersKHR_CMockIgnoreArg_device(__LINE__) +void vkUpdateVideoSessionParametersKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkUpdateVideoSessionParametersKHR_IgnoreArg_videoSessionParameters() vkUpdateVideoSessionParametersKHR_CMockIgnoreArg_videoSessionParameters(__LINE__) +void vkUpdateVideoSessionParametersKHR_CMockIgnoreArg_videoSessionParameters(UNITY_LINE_TYPE cmock_line); +#define vkUpdateVideoSessionParametersKHR_IgnoreArg_pUpdateInfo() vkUpdateVideoSessionParametersKHR_CMockIgnoreArg_pUpdateInfo(__LINE__) +void vkUpdateVideoSessionParametersKHR_CMockIgnoreArg_pUpdateInfo(UNITY_LINE_TYPE cmock_line); +#define vkDestroyVideoSessionParametersKHR_Ignore() vkDestroyVideoSessionParametersKHR_CMockIgnore() +void vkDestroyVideoSessionParametersKHR_CMockIgnore(void); +#define vkDestroyVideoSessionParametersKHR_StopIgnore() vkDestroyVideoSessionParametersKHR_CMockStopIgnore() +void vkDestroyVideoSessionParametersKHR_CMockStopIgnore(void); +#define vkDestroyVideoSessionParametersKHR_ExpectAnyArgs() vkDestroyVideoSessionParametersKHR_CMockExpectAnyArgs(__LINE__) +void vkDestroyVideoSessionParametersKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyVideoSessionParametersKHR_Expect(device, videoSessionParameters, pAllocator) vkDestroyVideoSessionParametersKHR_CMockExpect(__LINE__, device, videoSessionParameters, pAllocator) +void vkDestroyVideoSessionParametersKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyVideoSessionParametersKHR_CALLBACK)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyVideoSessionParametersKHR_AddCallback(CMOCK_vkDestroyVideoSessionParametersKHR_CALLBACK Callback); +void vkDestroyVideoSessionParametersKHR_Stub(CMOCK_vkDestroyVideoSessionParametersKHR_CALLBACK Callback); +#define vkDestroyVideoSessionParametersKHR_StubWithCallback vkDestroyVideoSessionParametersKHR_AddCallback +#define vkDestroyVideoSessionParametersKHR_IgnoreArg_device() vkDestroyVideoSessionParametersKHR_CMockIgnoreArg_device(__LINE__) +void vkDestroyVideoSessionParametersKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyVideoSessionParametersKHR_IgnoreArg_videoSessionParameters() vkDestroyVideoSessionParametersKHR_CMockIgnoreArg_videoSessionParameters(__LINE__) +void vkDestroyVideoSessionParametersKHR_CMockIgnoreArg_videoSessionParameters(UNITY_LINE_TYPE cmock_line); +#define vkDestroyVideoSessionParametersKHR_IgnoreArg_pAllocator() vkDestroyVideoSessionParametersKHR_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyVideoSessionParametersKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginVideoCodingKHR_Ignore() vkCmdBeginVideoCodingKHR_CMockIgnore() +void vkCmdBeginVideoCodingKHR_CMockIgnore(void); +#define vkCmdBeginVideoCodingKHR_StopIgnore() vkCmdBeginVideoCodingKHR_CMockStopIgnore() +void vkCmdBeginVideoCodingKHR_CMockStopIgnore(void); +#define vkCmdBeginVideoCodingKHR_ExpectAnyArgs() vkCmdBeginVideoCodingKHR_CMockExpectAnyArgs(__LINE__) +void vkCmdBeginVideoCodingKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginVideoCodingKHR_Expect(commandBuffer, pBeginInfo) vkCmdBeginVideoCodingKHR_CMockExpect(__LINE__, commandBuffer, pBeginInfo) +void vkCmdBeginVideoCodingKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo); +typedef void (* CMOCK_vkCmdBeginVideoCodingKHR_CALLBACK)(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo, int cmock_num_calls); +void vkCmdBeginVideoCodingKHR_AddCallback(CMOCK_vkCmdBeginVideoCodingKHR_CALLBACK Callback); +void vkCmdBeginVideoCodingKHR_Stub(CMOCK_vkCmdBeginVideoCodingKHR_CALLBACK Callback); +#define vkCmdBeginVideoCodingKHR_StubWithCallback vkCmdBeginVideoCodingKHR_AddCallback +#define vkCmdBeginVideoCodingKHR_IgnoreArg_commandBuffer() vkCmdBeginVideoCodingKHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBeginVideoCodingKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginVideoCodingKHR_IgnoreArg_pBeginInfo() vkCmdBeginVideoCodingKHR_CMockIgnoreArg_pBeginInfo(__LINE__) +void vkCmdBeginVideoCodingKHR_CMockIgnoreArg_pBeginInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndVideoCodingKHR_Ignore() vkCmdEndVideoCodingKHR_CMockIgnore() +void vkCmdEndVideoCodingKHR_CMockIgnore(void); +#define vkCmdEndVideoCodingKHR_StopIgnore() vkCmdEndVideoCodingKHR_CMockStopIgnore() +void vkCmdEndVideoCodingKHR_CMockStopIgnore(void); +#define vkCmdEndVideoCodingKHR_ExpectAnyArgs() vkCmdEndVideoCodingKHR_CMockExpectAnyArgs(__LINE__) +void vkCmdEndVideoCodingKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndVideoCodingKHR_Expect(commandBuffer, pEndCodingInfo) vkCmdEndVideoCodingKHR_CMockExpect(__LINE__, commandBuffer, pEndCodingInfo) +void vkCmdEndVideoCodingKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo); +typedef void (* CMOCK_vkCmdEndVideoCodingKHR_CALLBACK)(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo, int cmock_num_calls); +void vkCmdEndVideoCodingKHR_AddCallback(CMOCK_vkCmdEndVideoCodingKHR_CALLBACK Callback); +void vkCmdEndVideoCodingKHR_Stub(CMOCK_vkCmdEndVideoCodingKHR_CALLBACK Callback); +#define vkCmdEndVideoCodingKHR_StubWithCallback vkCmdEndVideoCodingKHR_AddCallback +#define vkCmdEndVideoCodingKHR_IgnoreArg_commandBuffer() vkCmdEndVideoCodingKHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdEndVideoCodingKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndVideoCodingKHR_IgnoreArg_pEndCodingInfo() vkCmdEndVideoCodingKHR_CMockIgnoreArg_pEndCodingInfo(__LINE__) +void vkCmdEndVideoCodingKHR_CMockIgnoreArg_pEndCodingInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdControlVideoCodingKHR_Ignore() vkCmdControlVideoCodingKHR_CMockIgnore() +void vkCmdControlVideoCodingKHR_CMockIgnore(void); +#define vkCmdControlVideoCodingKHR_StopIgnore() vkCmdControlVideoCodingKHR_CMockStopIgnore() +void vkCmdControlVideoCodingKHR_CMockStopIgnore(void); +#define vkCmdControlVideoCodingKHR_ExpectAnyArgs() vkCmdControlVideoCodingKHR_CMockExpectAnyArgs(__LINE__) +void vkCmdControlVideoCodingKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdControlVideoCodingKHR_Expect(commandBuffer, pCodingControlInfo) vkCmdControlVideoCodingKHR_CMockExpect(__LINE__, commandBuffer, pCodingControlInfo) +void vkCmdControlVideoCodingKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo); +typedef void (* CMOCK_vkCmdControlVideoCodingKHR_CALLBACK)(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo, int cmock_num_calls); +void vkCmdControlVideoCodingKHR_AddCallback(CMOCK_vkCmdControlVideoCodingKHR_CALLBACK Callback); +void vkCmdControlVideoCodingKHR_Stub(CMOCK_vkCmdControlVideoCodingKHR_CALLBACK Callback); +#define vkCmdControlVideoCodingKHR_StubWithCallback vkCmdControlVideoCodingKHR_AddCallback +#define vkCmdControlVideoCodingKHR_IgnoreArg_commandBuffer() vkCmdControlVideoCodingKHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdControlVideoCodingKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdControlVideoCodingKHR_IgnoreArg_pCodingControlInfo() vkCmdControlVideoCodingKHR_CMockIgnoreArg_pCodingControlInfo(__LINE__) +void vkCmdControlVideoCodingKHR_CMockIgnoreArg_pCodingControlInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdDecodeVideoKHR_Ignore() vkCmdDecodeVideoKHR_CMockIgnore() +void vkCmdDecodeVideoKHR_CMockIgnore(void); +#define vkCmdDecodeVideoKHR_StopIgnore() vkCmdDecodeVideoKHR_CMockStopIgnore() +void vkCmdDecodeVideoKHR_CMockStopIgnore(void); +#define vkCmdDecodeVideoKHR_ExpectAnyArgs() vkCmdDecodeVideoKHR_CMockExpectAnyArgs(__LINE__) +void vkCmdDecodeVideoKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDecodeVideoKHR_Expect(commandBuffer, pDecodeInfo) vkCmdDecodeVideoKHR_CMockExpect(__LINE__, commandBuffer, pDecodeInfo) +void vkCmdDecodeVideoKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo); +typedef void (* CMOCK_vkCmdDecodeVideoKHR_CALLBACK)(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo, int cmock_num_calls); +void vkCmdDecodeVideoKHR_AddCallback(CMOCK_vkCmdDecodeVideoKHR_CALLBACK Callback); +void vkCmdDecodeVideoKHR_Stub(CMOCK_vkCmdDecodeVideoKHR_CALLBACK Callback); +#define vkCmdDecodeVideoKHR_StubWithCallback vkCmdDecodeVideoKHR_AddCallback +#define vkCmdDecodeVideoKHR_IgnoreArg_commandBuffer() vkCmdDecodeVideoKHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDecodeVideoKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDecodeVideoKHR_IgnoreArg_pDecodeInfo() vkCmdDecodeVideoKHR_CMockIgnoreArg_pDecodeInfo(__LINE__) +void vkCmdDecodeVideoKHR_CMockIgnoreArg_pDecodeInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginRenderingKHR_Ignore() vkCmdBeginRenderingKHR_CMockIgnore() +void vkCmdBeginRenderingKHR_CMockIgnore(void); +#define vkCmdBeginRenderingKHR_StopIgnore() vkCmdBeginRenderingKHR_CMockStopIgnore() +void vkCmdBeginRenderingKHR_CMockStopIgnore(void); +#define vkCmdBeginRenderingKHR_ExpectAnyArgs() vkCmdBeginRenderingKHR_CMockExpectAnyArgs(__LINE__) +void vkCmdBeginRenderingKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginRenderingKHR_Expect(commandBuffer, pRenderingInfo) vkCmdBeginRenderingKHR_CMockExpect(__LINE__, commandBuffer, pRenderingInfo) +void vkCmdBeginRenderingKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo); +typedef void (* CMOCK_vkCmdBeginRenderingKHR_CALLBACK)(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo, int cmock_num_calls); +void vkCmdBeginRenderingKHR_AddCallback(CMOCK_vkCmdBeginRenderingKHR_CALLBACK Callback); +void vkCmdBeginRenderingKHR_Stub(CMOCK_vkCmdBeginRenderingKHR_CALLBACK Callback); +#define vkCmdBeginRenderingKHR_StubWithCallback vkCmdBeginRenderingKHR_AddCallback +#define vkCmdBeginRenderingKHR_IgnoreArg_commandBuffer() vkCmdBeginRenderingKHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBeginRenderingKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginRenderingKHR_IgnoreArg_pRenderingInfo() vkCmdBeginRenderingKHR_CMockIgnoreArg_pRenderingInfo(__LINE__) +void vkCmdBeginRenderingKHR_CMockIgnoreArg_pRenderingInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndRenderingKHR_Ignore() vkCmdEndRenderingKHR_CMockIgnore() +void vkCmdEndRenderingKHR_CMockIgnore(void); +#define vkCmdEndRenderingKHR_StopIgnore() vkCmdEndRenderingKHR_CMockStopIgnore() +void vkCmdEndRenderingKHR_CMockStopIgnore(void); +#define vkCmdEndRenderingKHR_ExpectAnyArgs() vkCmdEndRenderingKHR_CMockExpectAnyArgs(__LINE__) +void vkCmdEndRenderingKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndRenderingKHR_Expect(commandBuffer) vkCmdEndRenderingKHR_CMockExpect(__LINE__, commandBuffer) +void vkCmdEndRenderingKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer); +typedef void (* CMOCK_vkCmdEndRenderingKHR_CALLBACK)(VkCommandBuffer commandBuffer, int cmock_num_calls); +void vkCmdEndRenderingKHR_AddCallback(CMOCK_vkCmdEndRenderingKHR_CALLBACK Callback); +void vkCmdEndRenderingKHR_Stub(CMOCK_vkCmdEndRenderingKHR_CALLBACK Callback); +#define vkCmdEndRenderingKHR_StubWithCallback vkCmdEndRenderingKHR_AddCallback +#define vkCmdEndRenderingKHR_IgnoreArg_commandBuffer() vkCmdEndRenderingKHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdEndRenderingKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceFeatures2KHR_Ignore() vkGetPhysicalDeviceFeatures2KHR_CMockIgnore() +void vkGetPhysicalDeviceFeatures2KHR_CMockIgnore(void); +#define vkGetPhysicalDeviceFeatures2KHR_StopIgnore() vkGetPhysicalDeviceFeatures2KHR_CMockStopIgnore() +void vkGetPhysicalDeviceFeatures2KHR_CMockStopIgnore(void); +#define vkGetPhysicalDeviceFeatures2KHR_ExpectAnyArgs() vkGetPhysicalDeviceFeatures2KHR_CMockExpectAnyArgs(__LINE__) +void vkGetPhysicalDeviceFeatures2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceFeatures2KHR_Expect(physicalDevice, pFeatures) vkGetPhysicalDeviceFeatures2KHR_CMockExpect(__LINE__, physicalDevice, pFeatures) +void vkGetPhysicalDeviceFeatures2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); +typedef void (* CMOCK_vkGetPhysicalDeviceFeatures2KHR_CALLBACK)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures, int cmock_num_calls); +void vkGetPhysicalDeviceFeatures2KHR_AddCallback(CMOCK_vkGetPhysicalDeviceFeatures2KHR_CALLBACK Callback); +void vkGetPhysicalDeviceFeatures2KHR_Stub(CMOCK_vkGetPhysicalDeviceFeatures2KHR_CALLBACK Callback); +#define vkGetPhysicalDeviceFeatures2KHR_StubWithCallback vkGetPhysicalDeviceFeatures2KHR_AddCallback +#define vkGetPhysicalDeviceFeatures2KHR_ReturnThruPtr_pFeatures(pFeatures) vkGetPhysicalDeviceFeatures2KHR_CMockReturnMemThruPtr_pFeatures(__LINE__, pFeatures, sizeof(VkPhysicalDeviceFeatures2)) +#define vkGetPhysicalDeviceFeatures2KHR_ReturnArrayThruPtr_pFeatures(pFeatures, cmock_len) vkGetPhysicalDeviceFeatures2KHR_CMockReturnMemThruPtr_pFeatures(__LINE__, pFeatures, cmock_len * sizeof(*pFeatures)) +#define vkGetPhysicalDeviceFeatures2KHR_ReturnMemThruPtr_pFeatures(pFeatures, cmock_size) vkGetPhysicalDeviceFeatures2KHR_CMockReturnMemThruPtr_pFeatures(__LINE__, pFeatures, cmock_size) +void vkGetPhysicalDeviceFeatures2KHR_CMockReturnMemThruPtr_pFeatures(UNITY_LINE_TYPE cmock_line, VkPhysicalDeviceFeatures2 const* pFeatures, size_t cmock_size); +#define vkGetPhysicalDeviceFeatures2KHR_IgnoreArg_physicalDevice() vkGetPhysicalDeviceFeatures2KHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceFeatures2KHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceFeatures2KHR_IgnoreArg_pFeatures() vkGetPhysicalDeviceFeatures2KHR_CMockIgnoreArg_pFeatures(__LINE__) +void vkGetPhysicalDeviceFeatures2KHR_CMockIgnoreArg_pFeatures(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceProperties2KHR_Ignore() vkGetPhysicalDeviceProperties2KHR_CMockIgnore() +void vkGetPhysicalDeviceProperties2KHR_CMockIgnore(void); +#define vkGetPhysicalDeviceProperties2KHR_StopIgnore() vkGetPhysicalDeviceProperties2KHR_CMockStopIgnore() +void vkGetPhysicalDeviceProperties2KHR_CMockStopIgnore(void); +#define vkGetPhysicalDeviceProperties2KHR_ExpectAnyArgs() vkGetPhysicalDeviceProperties2KHR_CMockExpectAnyArgs(__LINE__) +void vkGetPhysicalDeviceProperties2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceProperties2KHR_Expect(physicalDevice, pProperties) vkGetPhysicalDeviceProperties2KHR_CMockExpect(__LINE__, physicalDevice, pProperties) +void vkGetPhysicalDeviceProperties2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); +typedef void (* CMOCK_vkGetPhysicalDeviceProperties2KHR_CALLBACK)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties, int cmock_num_calls); +void vkGetPhysicalDeviceProperties2KHR_AddCallback(CMOCK_vkGetPhysicalDeviceProperties2KHR_CALLBACK Callback); +void vkGetPhysicalDeviceProperties2KHR_Stub(CMOCK_vkGetPhysicalDeviceProperties2KHR_CALLBACK Callback); +#define vkGetPhysicalDeviceProperties2KHR_StubWithCallback vkGetPhysicalDeviceProperties2KHR_AddCallback +#define vkGetPhysicalDeviceProperties2KHR_ReturnThruPtr_pProperties(pProperties) vkGetPhysicalDeviceProperties2KHR_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, sizeof(VkPhysicalDeviceProperties2)) +#define vkGetPhysicalDeviceProperties2KHR_ReturnArrayThruPtr_pProperties(pProperties, cmock_len) vkGetPhysicalDeviceProperties2KHR_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_len * sizeof(*pProperties)) +#define vkGetPhysicalDeviceProperties2KHR_ReturnMemThruPtr_pProperties(pProperties, cmock_size) vkGetPhysicalDeviceProperties2KHR_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_size) +void vkGetPhysicalDeviceProperties2KHR_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkPhysicalDeviceProperties2 const* pProperties, size_t cmock_size); +#define vkGetPhysicalDeviceProperties2KHR_IgnoreArg_physicalDevice() vkGetPhysicalDeviceProperties2KHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceProperties2KHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceProperties2KHR_IgnoreArg_pProperties() vkGetPhysicalDeviceProperties2KHR_CMockIgnoreArg_pProperties(__LINE__) +void vkGetPhysicalDeviceProperties2KHR_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceFormatProperties2KHR_Ignore() vkGetPhysicalDeviceFormatProperties2KHR_CMockIgnore() +void vkGetPhysicalDeviceFormatProperties2KHR_CMockIgnore(void); +#define vkGetPhysicalDeviceFormatProperties2KHR_StopIgnore() vkGetPhysicalDeviceFormatProperties2KHR_CMockStopIgnore() +void vkGetPhysicalDeviceFormatProperties2KHR_CMockStopIgnore(void); +#define vkGetPhysicalDeviceFormatProperties2KHR_ExpectAnyArgs() vkGetPhysicalDeviceFormatProperties2KHR_CMockExpectAnyArgs(__LINE__) +void vkGetPhysicalDeviceFormatProperties2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceFormatProperties2KHR_Expect(physicalDevice, format, pFormatProperties) vkGetPhysicalDeviceFormatProperties2KHR_CMockExpect(__LINE__, physicalDevice, format, pFormatProperties) +void vkGetPhysicalDeviceFormatProperties2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); +typedef void (* CMOCK_vkGetPhysicalDeviceFormatProperties2KHR_CALLBACK)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties, int cmock_num_calls); +void vkGetPhysicalDeviceFormatProperties2KHR_AddCallback(CMOCK_vkGetPhysicalDeviceFormatProperties2KHR_CALLBACK Callback); +void vkGetPhysicalDeviceFormatProperties2KHR_Stub(CMOCK_vkGetPhysicalDeviceFormatProperties2KHR_CALLBACK Callback); +#define vkGetPhysicalDeviceFormatProperties2KHR_StubWithCallback vkGetPhysicalDeviceFormatProperties2KHR_AddCallback +#define vkGetPhysicalDeviceFormatProperties2KHR_ReturnThruPtr_pFormatProperties(pFormatProperties) vkGetPhysicalDeviceFormatProperties2KHR_CMockReturnMemThruPtr_pFormatProperties(__LINE__, pFormatProperties, sizeof(VkFormatProperties2)) +#define vkGetPhysicalDeviceFormatProperties2KHR_ReturnArrayThruPtr_pFormatProperties(pFormatProperties, cmock_len) vkGetPhysicalDeviceFormatProperties2KHR_CMockReturnMemThruPtr_pFormatProperties(__LINE__, pFormatProperties, cmock_len * sizeof(*pFormatProperties)) +#define vkGetPhysicalDeviceFormatProperties2KHR_ReturnMemThruPtr_pFormatProperties(pFormatProperties, cmock_size) vkGetPhysicalDeviceFormatProperties2KHR_CMockReturnMemThruPtr_pFormatProperties(__LINE__, pFormatProperties, cmock_size) +void vkGetPhysicalDeviceFormatProperties2KHR_CMockReturnMemThruPtr_pFormatProperties(UNITY_LINE_TYPE cmock_line, VkFormatProperties2 const* pFormatProperties, size_t cmock_size); +#define vkGetPhysicalDeviceFormatProperties2KHR_IgnoreArg_physicalDevice() vkGetPhysicalDeviceFormatProperties2KHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceFormatProperties2KHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceFormatProperties2KHR_IgnoreArg_format() vkGetPhysicalDeviceFormatProperties2KHR_CMockIgnoreArg_format(__LINE__) +void vkGetPhysicalDeviceFormatProperties2KHR_CMockIgnoreArg_format(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceFormatProperties2KHR_IgnoreArg_pFormatProperties() vkGetPhysicalDeviceFormatProperties2KHR_CMockIgnoreArg_pFormatProperties(__LINE__) +void vkGetPhysicalDeviceFormatProperties2KHR_CMockIgnoreArg_pFormatProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceImageFormatProperties2KHR_IgnoreAndReturn(cmock_retval) vkGetPhysicalDeviceImageFormatProperties2KHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceImageFormatProperties2KHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceImageFormatProperties2KHR_StopIgnore() vkGetPhysicalDeviceImageFormatProperties2KHR_CMockStopIgnore() +void vkGetPhysicalDeviceImageFormatProperties2KHR_CMockStopIgnore(void); +#define vkGetPhysicalDeviceImageFormatProperties2KHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetPhysicalDeviceImageFormatProperties2KHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceImageFormatProperties2KHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceImageFormatProperties2KHR_ExpectAndReturn(physicalDevice, pImageFormatInfo, pImageFormatProperties, cmock_retval) vkGetPhysicalDeviceImageFormatProperties2KHR_CMockExpectAndReturn(__LINE__, physicalDevice, pImageFormatInfo, pImageFormatProperties, cmock_retval) +void vkGetPhysicalDeviceImageFormatProperties2KHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPhysicalDeviceImageFormatProperties2KHR_CALLBACK)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties, int cmock_num_calls); +void vkGetPhysicalDeviceImageFormatProperties2KHR_AddCallback(CMOCK_vkGetPhysicalDeviceImageFormatProperties2KHR_CALLBACK Callback); +void vkGetPhysicalDeviceImageFormatProperties2KHR_Stub(CMOCK_vkGetPhysicalDeviceImageFormatProperties2KHR_CALLBACK Callback); +#define vkGetPhysicalDeviceImageFormatProperties2KHR_StubWithCallback vkGetPhysicalDeviceImageFormatProperties2KHR_AddCallback +#define vkGetPhysicalDeviceImageFormatProperties2KHR_ReturnThruPtr_pImageFormatProperties(pImageFormatProperties) vkGetPhysicalDeviceImageFormatProperties2KHR_CMockReturnMemThruPtr_pImageFormatProperties(__LINE__, pImageFormatProperties, sizeof(VkImageFormatProperties2)) +#define vkGetPhysicalDeviceImageFormatProperties2KHR_ReturnArrayThruPtr_pImageFormatProperties(pImageFormatProperties, cmock_len) vkGetPhysicalDeviceImageFormatProperties2KHR_CMockReturnMemThruPtr_pImageFormatProperties(__LINE__, pImageFormatProperties, cmock_len * sizeof(*pImageFormatProperties)) +#define vkGetPhysicalDeviceImageFormatProperties2KHR_ReturnMemThruPtr_pImageFormatProperties(pImageFormatProperties, cmock_size) vkGetPhysicalDeviceImageFormatProperties2KHR_CMockReturnMemThruPtr_pImageFormatProperties(__LINE__, pImageFormatProperties, cmock_size) +void vkGetPhysicalDeviceImageFormatProperties2KHR_CMockReturnMemThruPtr_pImageFormatProperties(UNITY_LINE_TYPE cmock_line, VkImageFormatProperties2 const* pImageFormatProperties, size_t cmock_size); +#define vkGetPhysicalDeviceImageFormatProperties2KHR_IgnoreArg_physicalDevice() vkGetPhysicalDeviceImageFormatProperties2KHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceImageFormatProperties2KHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceImageFormatProperties2KHR_IgnoreArg_pImageFormatInfo() vkGetPhysicalDeviceImageFormatProperties2KHR_CMockIgnoreArg_pImageFormatInfo(__LINE__) +void vkGetPhysicalDeviceImageFormatProperties2KHR_CMockIgnoreArg_pImageFormatInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceImageFormatProperties2KHR_IgnoreArg_pImageFormatProperties() vkGetPhysicalDeviceImageFormatProperties2KHR_CMockIgnoreArg_pImageFormatProperties(__LINE__) +void vkGetPhysicalDeviceImageFormatProperties2KHR_CMockIgnoreArg_pImageFormatProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceQueueFamilyProperties2KHR_Ignore() vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockIgnore() +void vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockIgnore(void); +#define vkGetPhysicalDeviceQueueFamilyProperties2KHR_StopIgnore() vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockStopIgnore() +void vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockStopIgnore(void); +#define vkGetPhysicalDeviceQueueFamilyProperties2KHR_ExpectAnyArgs() vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockExpectAnyArgs(__LINE__) +void vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceQueueFamilyProperties2KHR_Expect(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties) vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockExpect(__LINE__, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties) +void vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); +typedef void (* CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2KHR_CALLBACK)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties, int cmock_num_calls); +void vkGetPhysicalDeviceQueueFamilyProperties2KHR_AddCallback(CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2KHR_CALLBACK Callback); +void vkGetPhysicalDeviceQueueFamilyProperties2KHR_Stub(CMOCK_vkGetPhysicalDeviceQueueFamilyProperties2KHR_CALLBACK Callback); +#define vkGetPhysicalDeviceQueueFamilyProperties2KHR_StubWithCallback vkGetPhysicalDeviceQueueFamilyProperties2KHR_AddCallback +#define vkGetPhysicalDeviceQueueFamilyProperties2KHR_ReturnThruPtr_pQueueFamilyPropertyCount(pQueueFamilyPropertyCount) vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockReturnMemThruPtr_pQueueFamilyPropertyCount(__LINE__, pQueueFamilyPropertyCount, sizeof(uint32_t)) +#define vkGetPhysicalDeviceQueueFamilyProperties2KHR_ReturnArrayThruPtr_pQueueFamilyPropertyCount(pQueueFamilyPropertyCount, cmock_len) vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockReturnMemThruPtr_pQueueFamilyPropertyCount(__LINE__, pQueueFamilyPropertyCount, cmock_len * sizeof(*pQueueFamilyPropertyCount)) +#define vkGetPhysicalDeviceQueueFamilyProperties2KHR_ReturnMemThruPtr_pQueueFamilyPropertyCount(pQueueFamilyPropertyCount, cmock_size) vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockReturnMemThruPtr_pQueueFamilyPropertyCount(__LINE__, pQueueFamilyPropertyCount, cmock_size) +void vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockReturnMemThruPtr_pQueueFamilyPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pQueueFamilyPropertyCount, size_t cmock_size); +#define vkGetPhysicalDeviceQueueFamilyProperties2KHR_ReturnThruPtr_pQueueFamilyProperties(pQueueFamilyProperties) vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockReturnMemThruPtr_pQueueFamilyProperties(__LINE__, pQueueFamilyProperties, sizeof(VkQueueFamilyProperties2)) +#define vkGetPhysicalDeviceQueueFamilyProperties2KHR_ReturnArrayThruPtr_pQueueFamilyProperties(pQueueFamilyProperties, cmock_len) vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockReturnMemThruPtr_pQueueFamilyProperties(__LINE__, pQueueFamilyProperties, cmock_len * sizeof(*pQueueFamilyProperties)) +#define vkGetPhysicalDeviceQueueFamilyProperties2KHR_ReturnMemThruPtr_pQueueFamilyProperties(pQueueFamilyProperties, cmock_size) vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockReturnMemThruPtr_pQueueFamilyProperties(__LINE__, pQueueFamilyProperties, cmock_size) +void vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockReturnMemThruPtr_pQueueFamilyProperties(UNITY_LINE_TYPE cmock_line, VkQueueFamilyProperties2 const* pQueueFamilyProperties, size_t cmock_size); +#define vkGetPhysicalDeviceQueueFamilyProperties2KHR_IgnoreArg_physicalDevice() vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceQueueFamilyProperties2KHR_IgnoreArg_pQueueFamilyPropertyCount() vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockIgnoreArg_pQueueFamilyPropertyCount(__LINE__) +void vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockIgnoreArg_pQueueFamilyPropertyCount(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceQueueFamilyProperties2KHR_IgnoreArg_pQueueFamilyProperties() vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockIgnoreArg_pQueueFamilyProperties(__LINE__) +void vkGetPhysicalDeviceQueueFamilyProperties2KHR_CMockIgnoreArg_pQueueFamilyProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceMemoryProperties2KHR_Ignore() vkGetPhysicalDeviceMemoryProperties2KHR_CMockIgnore() +void vkGetPhysicalDeviceMemoryProperties2KHR_CMockIgnore(void); +#define vkGetPhysicalDeviceMemoryProperties2KHR_StopIgnore() vkGetPhysicalDeviceMemoryProperties2KHR_CMockStopIgnore() +void vkGetPhysicalDeviceMemoryProperties2KHR_CMockStopIgnore(void); +#define vkGetPhysicalDeviceMemoryProperties2KHR_ExpectAnyArgs() vkGetPhysicalDeviceMemoryProperties2KHR_CMockExpectAnyArgs(__LINE__) +void vkGetPhysicalDeviceMemoryProperties2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceMemoryProperties2KHR_Expect(physicalDevice, pMemoryProperties) vkGetPhysicalDeviceMemoryProperties2KHR_CMockExpect(__LINE__, physicalDevice, pMemoryProperties) +void vkGetPhysicalDeviceMemoryProperties2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); +typedef void (* CMOCK_vkGetPhysicalDeviceMemoryProperties2KHR_CALLBACK)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties, int cmock_num_calls); +void vkGetPhysicalDeviceMemoryProperties2KHR_AddCallback(CMOCK_vkGetPhysicalDeviceMemoryProperties2KHR_CALLBACK Callback); +void vkGetPhysicalDeviceMemoryProperties2KHR_Stub(CMOCK_vkGetPhysicalDeviceMemoryProperties2KHR_CALLBACK Callback); +#define vkGetPhysicalDeviceMemoryProperties2KHR_StubWithCallback vkGetPhysicalDeviceMemoryProperties2KHR_AddCallback +#define vkGetPhysicalDeviceMemoryProperties2KHR_ReturnThruPtr_pMemoryProperties(pMemoryProperties) vkGetPhysicalDeviceMemoryProperties2KHR_CMockReturnMemThruPtr_pMemoryProperties(__LINE__, pMemoryProperties, sizeof(VkPhysicalDeviceMemoryProperties2)) +#define vkGetPhysicalDeviceMemoryProperties2KHR_ReturnArrayThruPtr_pMemoryProperties(pMemoryProperties, cmock_len) vkGetPhysicalDeviceMemoryProperties2KHR_CMockReturnMemThruPtr_pMemoryProperties(__LINE__, pMemoryProperties, cmock_len * sizeof(*pMemoryProperties)) +#define vkGetPhysicalDeviceMemoryProperties2KHR_ReturnMemThruPtr_pMemoryProperties(pMemoryProperties, cmock_size) vkGetPhysicalDeviceMemoryProperties2KHR_CMockReturnMemThruPtr_pMemoryProperties(__LINE__, pMemoryProperties, cmock_size) +void vkGetPhysicalDeviceMemoryProperties2KHR_CMockReturnMemThruPtr_pMemoryProperties(UNITY_LINE_TYPE cmock_line, VkPhysicalDeviceMemoryProperties2 const* pMemoryProperties, size_t cmock_size); +#define vkGetPhysicalDeviceMemoryProperties2KHR_IgnoreArg_physicalDevice() vkGetPhysicalDeviceMemoryProperties2KHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceMemoryProperties2KHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceMemoryProperties2KHR_IgnoreArg_pMemoryProperties() vkGetPhysicalDeviceMemoryProperties2KHR_CMockIgnoreArg_pMemoryProperties(__LINE__) +void vkGetPhysicalDeviceMemoryProperties2KHR_CMockIgnoreArg_pMemoryProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSparseImageFormatProperties2KHR_Ignore() vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockIgnore() +void vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockIgnore(void); +#define vkGetPhysicalDeviceSparseImageFormatProperties2KHR_StopIgnore() vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockStopIgnore() +void vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockStopIgnore(void); +#define vkGetPhysicalDeviceSparseImageFormatProperties2KHR_ExpectAnyArgs() vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockExpectAnyArgs(__LINE__) +void vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSparseImageFormatProperties2KHR_Expect(physicalDevice, pFormatInfo, pPropertyCount, pProperties) vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockExpect(__LINE__, physicalDevice, pFormatInfo, pPropertyCount, pProperties) +void vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); +typedef void (* CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CALLBACK)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties, int cmock_num_calls); +void vkGetPhysicalDeviceSparseImageFormatProperties2KHR_AddCallback(CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CALLBACK Callback); +void vkGetPhysicalDeviceSparseImageFormatProperties2KHR_Stub(CMOCK_vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CALLBACK Callback); +#define vkGetPhysicalDeviceSparseImageFormatProperties2KHR_StubWithCallback vkGetPhysicalDeviceSparseImageFormatProperties2KHR_AddCallback +#define vkGetPhysicalDeviceSparseImageFormatProperties2KHR_ReturnThruPtr_pPropertyCount(pPropertyCount) vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, sizeof(uint32_t)) +#define vkGetPhysicalDeviceSparseImageFormatProperties2KHR_ReturnArrayThruPtr_pPropertyCount(pPropertyCount, cmock_len) vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, cmock_len * sizeof(*pPropertyCount)) +#define vkGetPhysicalDeviceSparseImageFormatProperties2KHR_ReturnMemThruPtr_pPropertyCount(pPropertyCount, cmock_size) vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, cmock_size) +void vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockReturnMemThruPtr_pPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPropertyCount, size_t cmock_size); +#define vkGetPhysicalDeviceSparseImageFormatProperties2KHR_ReturnThruPtr_pProperties(pProperties) vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, sizeof(VkSparseImageFormatProperties2)) +#define vkGetPhysicalDeviceSparseImageFormatProperties2KHR_ReturnArrayThruPtr_pProperties(pProperties, cmock_len) vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_len * sizeof(*pProperties)) +#define vkGetPhysicalDeviceSparseImageFormatProperties2KHR_ReturnMemThruPtr_pProperties(pProperties, cmock_size) vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_size) +void vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkSparseImageFormatProperties2 const* pProperties, size_t cmock_size); +#define vkGetPhysicalDeviceSparseImageFormatProperties2KHR_IgnoreArg_physicalDevice() vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSparseImageFormatProperties2KHR_IgnoreArg_pFormatInfo() vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockIgnoreArg_pFormatInfo(__LINE__) +void vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockIgnoreArg_pFormatInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSparseImageFormatProperties2KHR_IgnoreArg_pPropertyCount() vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockIgnoreArg_pPropertyCount(__LINE__) +void vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockIgnoreArg_pPropertyCount(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSparseImageFormatProperties2KHR_IgnoreArg_pProperties() vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockIgnoreArg_pProperties(__LINE__) +void vkGetPhysicalDeviceSparseImageFormatProperties2KHR_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceGroupPeerMemoryFeaturesKHR_Ignore() vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockIgnore() +void vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockIgnore(void); +#define vkGetDeviceGroupPeerMemoryFeaturesKHR_StopIgnore() vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockStopIgnore() +void vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockStopIgnore(void); +#define vkGetDeviceGroupPeerMemoryFeaturesKHR_ExpectAnyArgs() vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockExpectAnyArgs(__LINE__) +void vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceGroupPeerMemoryFeaturesKHR_Expect(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures) vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockExpect(__LINE__, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures) +void vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); +typedef void (* CMOCK_vkGetDeviceGroupPeerMemoryFeaturesKHR_CALLBACK)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures, int cmock_num_calls); +void vkGetDeviceGroupPeerMemoryFeaturesKHR_AddCallback(CMOCK_vkGetDeviceGroupPeerMemoryFeaturesKHR_CALLBACK Callback); +void vkGetDeviceGroupPeerMemoryFeaturesKHR_Stub(CMOCK_vkGetDeviceGroupPeerMemoryFeaturesKHR_CALLBACK Callback); +#define vkGetDeviceGroupPeerMemoryFeaturesKHR_StubWithCallback vkGetDeviceGroupPeerMemoryFeaturesKHR_AddCallback +#define vkGetDeviceGroupPeerMemoryFeaturesKHR_ReturnThruPtr_pPeerMemoryFeatures(pPeerMemoryFeatures) vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockReturnMemThruPtr_pPeerMemoryFeatures(__LINE__, pPeerMemoryFeatures, sizeof(VkPeerMemoryFeatureFlags)) +#define vkGetDeviceGroupPeerMemoryFeaturesKHR_ReturnArrayThruPtr_pPeerMemoryFeatures(pPeerMemoryFeatures, cmock_len) vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockReturnMemThruPtr_pPeerMemoryFeatures(__LINE__, pPeerMemoryFeatures, cmock_len * sizeof(*pPeerMemoryFeatures)) +#define vkGetDeviceGroupPeerMemoryFeaturesKHR_ReturnMemThruPtr_pPeerMemoryFeatures(pPeerMemoryFeatures, cmock_size) vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockReturnMemThruPtr_pPeerMemoryFeatures(__LINE__, pPeerMemoryFeatures, cmock_size) +void vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockReturnMemThruPtr_pPeerMemoryFeatures(UNITY_LINE_TYPE cmock_line, VkPeerMemoryFeatureFlags const* pPeerMemoryFeatures, size_t cmock_size); +#define vkGetDeviceGroupPeerMemoryFeaturesKHR_IgnoreArg_device() vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockIgnoreArg_device(__LINE__) +void vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceGroupPeerMemoryFeaturesKHR_IgnoreArg_heapIndex() vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockIgnoreArg_heapIndex(__LINE__) +void vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockIgnoreArg_heapIndex(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceGroupPeerMemoryFeaturesKHR_IgnoreArg_localDeviceIndex() vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockIgnoreArg_localDeviceIndex(__LINE__) +void vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockIgnoreArg_localDeviceIndex(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceGroupPeerMemoryFeaturesKHR_IgnoreArg_remoteDeviceIndex() vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockIgnoreArg_remoteDeviceIndex(__LINE__) +void vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockIgnoreArg_remoteDeviceIndex(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceGroupPeerMemoryFeaturesKHR_IgnoreArg_pPeerMemoryFeatures() vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockIgnoreArg_pPeerMemoryFeatures(__LINE__) +void vkGetDeviceGroupPeerMemoryFeaturesKHR_CMockIgnoreArg_pPeerMemoryFeatures(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDeviceMaskKHR_Ignore() vkCmdSetDeviceMaskKHR_CMockIgnore() +void vkCmdSetDeviceMaskKHR_CMockIgnore(void); +#define vkCmdSetDeviceMaskKHR_StopIgnore() vkCmdSetDeviceMaskKHR_CMockStopIgnore() +void vkCmdSetDeviceMaskKHR_CMockStopIgnore(void); +#define vkCmdSetDeviceMaskKHR_ExpectAnyArgs() vkCmdSetDeviceMaskKHR_CMockExpectAnyArgs(__LINE__) +void vkCmdSetDeviceMaskKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDeviceMaskKHR_Expect(commandBuffer, deviceMask) vkCmdSetDeviceMaskKHR_CMockExpect(__LINE__, commandBuffer, deviceMask) +void vkCmdSetDeviceMaskKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t deviceMask); +typedef void (* CMOCK_vkCmdSetDeviceMaskKHR_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t deviceMask, int cmock_num_calls); +void vkCmdSetDeviceMaskKHR_AddCallback(CMOCK_vkCmdSetDeviceMaskKHR_CALLBACK Callback); +void vkCmdSetDeviceMaskKHR_Stub(CMOCK_vkCmdSetDeviceMaskKHR_CALLBACK Callback); +#define vkCmdSetDeviceMaskKHR_StubWithCallback vkCmdSetDeviceMaskKHR_AddCallback +#define vkCmdSetDeviceMaskKHR_IgnoreArg_commandBuffer() vkCmdSetDeviceMaskKHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetDeviceMaskKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDeviceMaskKHR_IgnoreArg_deviceMask() vkCmdSetDeviceMaskKHR_CMockIgnoreArg_deviceMask(__LINE__) +void vkCmdSetDeviceMaskKHR_CMockIgnoreArg_deviceMask(UNITY_LINE_TYPE cmock_line); +#define vkCmdDispatchBaseKHR_Ignore() vkCmdDispatchBaseKHR_CMockIgnore() +void vkCmdDispatchBaseKHR_CMockIgnore(void); +#define vkCmdDispatchBaseKHR_StopIgnore() vkCmdDispatchBaseKHR_CMockStopIgnore() +void vkCmdDispatchBaseKHR_CMockStopIgnore(void); +#define vkCmdDispatchBaseKHR_ExpectAnyArgs() vkCmdDispatchBaseKHR_CMockExpectAnyArgs(__LINE__) +void vkCmdDispatchBaseKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDispatchBaseKHR_Expect(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ) vkCmdDispatchBaseKHR_CMockExpect(__LINE__, commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ) +void vkCmdDispatchBaseKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef void (* CMOCK_vkCmdDispatchBaseKHR_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, int cmock_num_calls); +void vkCmdDispatchBaseKHR_AddCallback(CMOCK_vkCmdDispatchBaseKHR_CALLBACK Callback); +void vkCmdDispatchBaseKHR_Stub(CMOCK_vkCmdDispatchBaseKHR_CALLBACK Callback); +#define vkCmdDispatchBaseKHR_StubWithCallback vkCmdDispatchBaseKHR_AddCallback +#define vkCmdDispatchBaseKHR_IgnoreArg_commandBuffer() vkCmdDispatchBaseKHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDispatchBaseKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDispatchBaseKHR_IgnoreArg_baseGroupX() vkCmdDispatchBaseKHR_CMockIgnoreArg_baseGroupX(__LINE__) +void vkCmdDispatchBaseKHR_CMockIgnoreArg_baseGroupX(UNITY_LINE_TYPE cmock_line); +#define vkCmdDispatchBaseKHR_IgnoreArg_baseGroupY() vkCmdDispatchBaseKHR_CMockIgnoreArg_baseGroupY(__LINE__) +void vkCmdDispatchBaseKHR_CMockIgnoreArg_baseGroupY(UNITY_LINE_TYPE cmock_line); +#define vkCmdDispatchBaseKHR_IgnoreArg_baseGroupZ() vkCmdDispatchBaseKHR_CMockIgnoreArg_baseGroupZ(__LINE__) +void vkCmdDispatchBaseKHR_CMockIgnoreArg_baseGroupZ(UNITY_LINE_TYPE cmock_line); +#define vkCmdDispatchBaseKHR_IgnoreArg_groupCountX() vkCmdDispatchBaseKHR_CMockIgnoreArg_groupCountX(__LINE__) +void vkCmdDispatchBaseKHR_CMockIgnoreArg_groupCountX(UNITY_LINE_TYPE cmock_line); +#define vkCmdDispatchBaseKHR_IgnoreArg_groupCountY() vkCmdDispatchBaseKHR_CMockIgnoreArg_groupCountY(__LINE__) +void vkCmdDispatchBaseKHR_CMockIgnoreArg_groupCountY(UNITY_LINE_TYPE cmock_line); +#define vkCmdDispatchBaseKHR_IgnoreArg_groupCountZ() vkCmdDispatchBaseKHR_CMockIgnoreArg_groupCountZ(__LINE__) +void vkCmdDispatchBaseKHR_CMockIgnoreArg_groupCountZ(UNITY_LINE_TYPE cmock_line); +#define vkTrimCommandPoolKHR_Ignore() vkTrimCommandPoolKHR_CMockIgnore() +void vkTrimCommandPoolKHR_CMockIgnore(void); +#define vkTrimCommandPoolKHR_StopIgnore() vkTrimCommandPoolKHR_CMockStopIgnore() +void vkTrimCommandPoolKHR_CMockStopIgnore(void); +#define vkTrimCommandPoolKHR_ExpectAnyArgs() vkTrimCommandPoolKHR_CMockExpectAnyArgs(__LINE__) +void vkTrimCommandPoolKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkTrimCommandPoolKHR_Expect(device, commandPool, flags) vkTrimCommandPoolKHR_CMockExpect(__LINE__, device, commandPool, flags) +void vkTrimCommandPoolKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); +typedef void (* CMOCK_vkTrimCommandPoolKHR_CALLBACK)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags, int cmock_num_calls); +void vkTrimCommandPoolKHR_AddCallback(CMOCK_vkTrimCommandPoolKHR_CALLBACK Callback); +void vkTrimCommandPoolKHR_Stub(CMOCK_vkTrimCommandPoolKHR_CALLBACK Callback); +#define vkTrimCommandPoolKHR_StubWithCallback vkTrimCommandPoolKHR_AddCallback +#define vkTrimCommandPoolKHR_IgnoreArg_device() vkTrimCommandPoolKHR_CMockIgnoreArg_device(__LINE__) +void vkTrimCommandPoolKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkTrimCommandPoolKHR_IgnoreArg_commandPool() vkTrimCommandPoolKHR_CMockIgnoreArg_commandPool(__LINE__) +void vkTrimCommandPoolKHR_CMockIgnoreArg_commandPool(UNITY_LINE_TYPE cmock_line); +#define vkTrimCommandPoolKHR_IgnoreArg_flags() vkTrimCommandPoolKHR_CMockIgnoreArg_flags(__LINE__) +void vkTrimCommandPoolKHR_CMockIgnoreArg_flags(UNITY_LINE_TYPE cmock_line); +#define vkEnumeratePhysicalDeviceGroupsKHR_IgnoreAndReturn(cmock_retval) vkEnumeratePhysicalDeviceGroupsKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkEnumeratePhysicalDeviceGroupsKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkEnumeratePhysicalDeviceGroupsKHR_StopIgnore() vkEnumeratePhysicalDeviceGroupsKHR_CMockStopIgnore() +void vkEnumeratePhysicalDeviceGroupsKHR_CMockStopIgnore(void); +#define vkEnumeratePhysicalDeviceGroupsKHR_ExpectAnyArgsAndReturn(cmock_retval) vkEnumeratePhysicalDeviceGroupsKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkEnumeratePhysicalDeviceGroupsKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkEnumeratePhysicalDeviceGroupsKHR_ExpectAndReturn(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, cmock_retval) vkEnumeratePhysicalDeviceGroupsKHR_CMockExpectAndReturn(__LINE__, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, cmock_retval) +void vkEnumeratePhysicalDeviceGroupsKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALLBACK)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, int cmock_num_calls); +void vkEnumeratePhysicalDeviceGroupsKHR_AddCallback(CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALLBACK Callback); +void vkEnumeratePhysicalDeviceGroupsKHR_Stub(CMOCK_vkEnumeratePhysicalDeviceGroupsKHR_CALLBACK Callback); +#define vkEnumeratePhysicalDeviceGroupsKHR_StubWithCallback vkEnumeratePhysicalDeviceGroupsKHR_AddCallback +#define vkEnumeratePhysicalDeviceGroupsKHR_ReturnThruPtr_pPhysicalDeviceGroupCount(pPhysicalDeviceGroupCount) vkEnumeratePhysicalDeviceGroupsKHR_CMockReturnMemThruPtr_pPhysicalDeviceGroupCount(__LINE__, pPhysicalDeviceGroupCount, sizeof(uint32_t)) +#define vkEnumeratePhysicalDeviceGroupsKHR_ReturnArrayThruPtr_pPhysicalDeviceGroupCount(pPhysicalDeviceGroupCount, cmock_len) vkEnumeratePhysicalDeviceGroupsKHR_CMockReturnMemThruPtr_pPhysicalDeviceGroupCount(__LINE__, pPhysicalDeviceGroupCount, cmock_len * sizeof(*pPhysicalDeviceGroupCount)) +#define vkEnumeratePhysicalDeviceGroupsKHR_ReturnMemThruPtr_pPhysicalDeviceGroupCount(pPhysicalDeviceGroupCount, cmock_size) vkEnumeratePhysicalDeviceGroupsKHR_CMockReturnMemThruPtr_pPhysicalDeviceGroupCount(__LINE__, pPhysicalDeviceGroupCount, cmock_size) +void vkEnumeratePhysicalDeviceGroupsKHR_CMockReturnMemThruPtr_pPhysicalDeviceGroupCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPhysicalDeviceGroupCount, size_t cmock_size); +#define vkEnumeratePhysicalDeviceGroupsKHR_ReturnThruPtr_pPhysicalDeviceGroupProperties(pPhysicalDeviceGroupProperties) vkEnumeratePhysicalDeviceGroupsKHR_CMockReturnMemThruPtr_pPhysicalDeviceGroupProperties(__LINE__, pPhysicalDeviceGroupProperties, sizeof(VkPhysicalDeviceGroupProperties)) +#define vkEnumeratePhysicalDeviceGroupsKHR_ReturnArrayThruPtr_pPhysicalDeviceGroupProperties(pPhysicalDeviceGroupProperties, cmock_len) vkEnumeratePhysicalDeviceGroupsKHR_CMockReturnMemThruPtr_pPhysicalDeviceGroupProperties(__LINE__, pPhysicalDeviceGroupProperties, cmock_len * sizeof(*pPhysicalDeviceGroupProperties)) +#define vkEnumeratePhysicalDeviceGroupsKHR_ReturnMemThruPtr_pPhysicalDeviceGroupProperties(pPhysicalDeviceGroupProperties, cmock_size) vkEnumeratePhysicalDeviceGroupsKHR_CMockReturnMemThruPtr_pPhysicalDeviceGroupProperties(__LINE__, pPhysicalDeviceGroupProperties, cmock_size) +void vkEnumeratePhysicalDeviceGroupsKHR_CMockReturnMemThruPtr_pPhysicalDeviceGroupProperties(UNITY_LINE_TYPE cmock_line, VkPhysicalDeviceGroupProperties const* pPhysicalDeviceGroupProperties, size_t cmock_size); +#define vkEnumeratePhysicalDeviceGroupsKHR_IgnoreArg_instance() vkEnumeratePhysicalDeviceGroupsKHR_CMockIgnoreArg_instance(__LINE__) +void vkEnumeratePhysicalDeviceGroupsKHR_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line); +#define vkEnumeratePhysicalDeviceGroupsKHR_IgnoreArg_pPhysicalDeviceGroupCount() vkEnumeratePhysicalDeviceGroupsKHR_CMockIgnoreArg_pPhysicalDeviceGroupCount(__LINE__) +void vkEnumeratePhysicalDeviceGroupsKHR_CMockIgnoreArg_pPhysicalDeviceGroupCount(UNITY_LINE_TYPE cmock_line); +#define vkEnumeratePhysicalDeviceGroupsKHR_IgnoreArg_pPhysicalDeviceGroupProperties() vkEnumeratePhysicalDeviceGroupsKHR_CMockIgnoreArg_pPhysicalDeviceGroupProperties(__LINE__) +void vkEnumeratePhysicalDeviceGroupsKHR_CMockIgnoreArg_pPhysicalDeviceGroupProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalBufferPropertiesKHR_Ignore() vkGetPhysicalDeviceExternalBufferPropertiesKHR_CMockIgnore() +void vkGetPhysicalDeviceExternalBufferPropertiesKHR_CMockIgnore(void); +#define vkGetPhysicalDeviceExternalBufferPropertiesKHR_StopIgnore() vkGetPhysicalDeviceExternalBufferPropertiesKHR_CMockStopIgnore() +void vkGetPhysicalDeviceExternalBufferPropertiesKHR_CMockStopIgnore(void); +#define vkGetPhysicalDeviceExternalBufferPropertiesKHR_ExpectAnyArgs() vkGetPhysicalDeviceExternalBufferPropertiesKHR_CMockExpectAnyArgs(__LINE__) +void vkGetPhysicalDeviceExternalBufferPropertiesKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalBufferPropertiesKHR_Expect(physicalDevice, pExternalBufferInfo, pExternalBufferProperties) vkGetPhysicalDeviceExternalBufferPropertiesKHR_CMockExpect(__LINE__, physicalDevice, pExternalBufferInfo, pExternalBufferProperties) +void vkGetPhysicalDeviceExternalBufferPropertiesKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); +typedef void (* CMOCK_vkGetPhysicalDeviceExternalBufferPropertiesKHR_CALLBACK)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties, int cmock_num_calls); +void vkGetPhysicalDeviceExternalBufferPropertiesKHR_AddCallback(CMOCK_vkGetPhysicalDeviceExternalBufferPropertiesKHR_CALLBACK Callback); +void vkGetPhysicalDeviceExternalBufferPropertiesKHR_Stub(CMOCK_vkGetPhysicalDeviceExternalBufferPropertiesKHR_CALLBACK Callback); +#define vkGetPhysicalDeviceExternalBufferPropertiesKHR_StubWithCallback vkGetPhysicalDeviceExternalBufferPropertiesKHR_AddCallback +#define vkGetPhysicalDeviceExternalBufferPropertiesKHR_ReturnThruPtr_pExternalBufferProperties(pExternalBufferProperties) vkGetPhysicalDeviceExternalBufferPropertiesKHR_CMockReturnMemThruPtr_pExternalBufferProperties(__LINE__, pExternalBufferProperties, sizeof(VkExternalBufferProperties)) +#define vkGetPhysicalDeviceExternalBufferPropertiesKHR_ReturnArrayThruPtr_pExternalBufferProperties(pExternalBufferProperties, cmock_len) vkGetPhysicalDeviceExternalBufferPropertiesKHR_CMockReturnMemThruPtr_pExternalBufferProperties(__LINE__, pExternalBufferProperties, cmock_len * sizeof(*pExternalBufferProperties)) +#define vkGetPhysicalDeviceExternalBufferPropertiesKHR_ReturnMemThruPtr_pExternalBufferProperties(pExternalBufferProperties, cmock_size) vkGetPhysicalDeviceExternalBufferPropertiesKHR_CMockReturnMemThruPtr_pExternalBufferProperties(__LINE__, pExternalBufferProperties, cmock_size) +void vkGetPhysicalDeviceExternalBufferPropertiesKHR_CMockReturnMemThruPtr_pExternalBufferProperties(UNITY_LINE_TYPE cmock_line, VkExternalBufferProperties const* pExternalBufferProperties, size_t cmock_size); +#define vkGetPhysicalDeviceExternalBufferPropertiesKHR_IgnoreArg_physicalDevice() vkGetPhysicalDeviceExternalBufferPropertiesKHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceExternalBufferPropertiesKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalBufferPropertiesKHR_IgnoreArg_pExternalBufferInfo() vkGetPhysicalDeviceExternalBufferPropertiesKHR_CMockIgnoreArg_pExternalBufferInfo(__LINE__) +void vkGetPhysicalDeviceExternalBufferPropertiesKHR_CMockIgnoreArg_pExternalBufferInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalBufferPropertiesKHR_IgnoreArg_pExternalBufferProperties() vkGetPhysicalDeviceExternalBufferPropertiesKHR_CMockIgnoreArg_pExternalBufferProperties(__LINE__) +void vkGetPhysicalDeviceExternalBufferPropertiesKHR_CMockIgnoreArg_pExternalBufferProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetMemoryFdKHR_IgnoreAndReturn(cmock_retval) vkGetMemoryFdKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetMemoryFdKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetMemoryFdKHR_StopIgnore() vkGetMemoryFdKHR_CMockStopIgnore() +void vkGetMemoryFdKHR_CMockStopIgnore(void); +#define vkGetMemoryFdKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetMemoryFdKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetMemoryFdKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetMemoryFdKHR_ExpectAndReturn(device, pGetFdInfo, pFd, cmock_retval) vkGetMemoryFdKHR_CMockExpectAndReturn(__LINE__, device, pGetFdInfo, pFd, cmock_retval) +void vkGetMemoryFdKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetMemoryFdKHR_CALLBACK)(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd, int cmock_num_calls); +void vkGetMemoryFdKHR_AddCallback(CMOCK_vkGetMemoryFdKHR_CALLBACK Callback); +void vkGetMemoryFdKHR_Stub(CMOCK_vkGetMemoryFdKHR_CALLBACK Callback); +#define vkGetMemoryFdKHR_StubWithCallback vkGetMemoryFdKHR_AddCallback +#define vkGetMemoryFdKHR_ReturnThruPtr_pFd(pFd) vkGetMemoryFdKHR_CMockReturnMemThruPtr_pFd(__LINE__, pFd, sizeof(int)) +#define vkGetMemoryFdKHR_ReturnArrayThruPtr_pFd(pFd, cmock_len) vkGetMemoryFdKHR_CMockReturnMemThruPtr_pFd(__LINE__, pFd, cmock_len * sizeof(*pFd)) +#define vkGetMemoryFdKHR_ReturnMemThruPtr_pFd(pFd, cmock_size) vkGetMemoryFdKHR_CMockReturnMemThruPtr_pFd(__LINE__, pFd, cmock_size) +void vkGetMemoryFdKHR_CMockReturnMemThruPtr_pFd(UNITY_LINE_TYPE cmock_line, int const* pFd, size_t cmock_size); +#define vkGetMemoryFdKHR_IgnoreArg_device() vkGetMemoryFdKHR_CMockIgnoreArg_device(__LINE__) +void vkGetMemoryFdKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetMemoryFdKHR_IgnoreArg_pGetFdInfo() vkGetMemoryFdKHR_CMockIgnoreArg_pGetFdInfo(__LINE__) +void vkGetMemoryFdKHR_CMockIgnoreArg_pGetFdInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetMemoryFdKHR_IgnoreArg_pFd() vkGetMemoryFdKHR_CMockIgnoreArg_pFd(__LINE__) +void vkGetMemoryFdKHR_CMockIgnoreArg_pFd(UNITY_LINE_TYPE cmock_line); +#define vkGetMemoryFdPropertiesKHR_IgnoreAndReturn(cmock_retval) vkGetMemoryFdPropertiesKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetMemoryFdPropertiesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetMemoryFdPropertiesKHR_StopIgnore() vkGetMemoryFdPropertiesKHR_CMockStopIgnore() +void vkGetMemoryFdPropertiesKHR_CMockStopIgnore(void); +#define vkGetMemoryFdPropertiesKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetMemoryFdPropertiesKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetMemoryFdPropertiesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetMemoryFdPropertiesKHR_ExpectAndReturn(device, handleType, fd, pMemoryFdProperties, cmock_retval) vkGetMemoryFdPropertiesKHR_CMockExpectAndReturn(__LINE__, device, handleType, fd, pMemoryFdProperties, cmock_retval) +void vkGetMemoryFdPropertiesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetMemoryFdPropertiesKHR_CALLBACK)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties, int cmock_num_calls); +void vkGetMemoryFdPropertiesKHR_AddCallback(CMOCK_vkGetMemoryFdPropertiesKHR_CALLBACK Callback); +void vkGetMemoryFdPropertiesKHR_Stub(CMOCK_vkGetMemoryFdPropertiesKHR_CALLBACK Callback); +#define vkGetMemoryFdPropertiesKHR_StubWithCallback vkGetMemoryFdPropertiesKHR_AddCallback +#define vkGetMemoryFdPropertiesKHR_ReturnThruPtr_pMemoryFdProperties(pMemoryFdProperties) vkGetMemoryFdPropertiesKHR_CMockReturnMemThruPtr_pMemoryFdProperties(__LINE__, pMemoryFdProperties, sizeof(VkMemoryFdPropertiesKHR)) +#define vkGetMemoryFdPropertiesKHR_ReturnArrayThruPtr_pMemoryFdProperties(pMemoryFdProperties, cmock_len) vkGetMemoryFdPropertiesKHR_CMockReturnMemThruPtr_pMemoryFdProperties(__LINE__, pMemoryFdProperties, cmock_len * sizeof(*pMemoryFdProperties)) +#define vkGetMemoryFdPropertiesKHR_ReturnMemThruPtr_pMemoryFdProperties(pMemoryFdProperties, cmock_size) vkGetMemoryFdPropertiesKHR_CMockReturnMemThruPtr_pMemoryFdProperties(__LINE__, pMemoryFdProperties, cmock_size) +void vkGetMemoryFdPropertiesKHR_CMockReturnMemThruPtr_pMemoryFdProperties(UNITY_LINE_TYPE cmock_line, VkMemoryFdPropertiesKHR const* pMemoryFdProperties, size_t cmock_size); +#define vkGetMemoryFdPropertiesKHR_IgnoreArg_device() vkGetMemoryFdPropertiesKHR_CMockIgnoreArg_device(__LINE__) +void vkGetMemoryFdPropertiesKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetMemoryFdPropertiesKHR_IgnoreArg_handleType() vkGetMemoryFdPropertiesKHR_CMockIgnoreArg_handleType(__LINE__) +void vkGetMemoryFdPropertiesKHR_CMockIgnoreArg_handleType(UNITY_LINE_TYPE cmock_line); +#define vkGetMemoryFdPropertiesKHR_IgnoreArg_fd() vkGetMemoryFdPropertiesKHR_CMockIgnoreArg_fd(__LINE__) +void vkGetMemoryFdPropertiesKHR_CMockIgnoreArg_fd(UNITY_LINE_TYPE cmock_line); +#define vkGetMemoryFdPropertiesKHR_IgnoreArg_pMemoryFdProperties() vkGetMemoryFdPropertiesKHR_CMockIgnoreArg_pMemoryFdProperties(__LINE__) +void vkGetMemoryFdPropertiesKHR_CMockIgnoreArg_pMemoryFdProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_Ignore() vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CMockIgnore() +void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CMockIgnore(void); +#define vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_StopIgnore() vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CMockStopIgnore() +void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CMockStopIgnore(void); +#define vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_ExpectAnyArgs() vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CMockExpectAnyArgs(__LINE__) +void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_Expect(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties) vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CMockExpect(__LINE__, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties) +void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); +typedef void (* CMOCK_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CALLBACK)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties, int cmock_num_calls); +void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_AddCallback(CMOCK_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CALLBACK Callback); +void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_Stub(CMOCK_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CALLBACK Callback); +#define vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_StubWithCallback vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_AddCallback +#define vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_ReturnThruPtr_pExternalSemaphoreProperties(pExternalSemaphoreProperties) vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CMockReturnMemThruPtr_pExternalSemaphoreProperties(__LINE__, pExternalSemaphoreProperties, sizeof(VkExternalSemaphoreProperties)) +#define vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_ReturnArrayThruPtr_pExternalSemaphoreProperties(pExternalSemaphoreProperties, cmock_len) vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CMockReturnMemThruPtr_pExternalSemaphoreProperties(__LINE__, pExternalSemaphoreProperties, cmock_len * sizeof(*pExternalSemaphoreProperties)) +#define vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_ReturnMemThruPtr_pExternalSemaphoreProperties(pExternalSemaphoreProperties, cmock_size) vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CMockReturnMemThruPtr_pExternalSemaphoreProperties(__LINE__, pExternalSemaphoreProperties, cmock_size) +void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CMockReturnMemThruPtr_pExternalSemaphoreProperties(UNITY_LINE_TYPE cmock_line, VkExternalSemaphoreProperties const* pExternalSemaphoreProperties, size_t cmock_size); +#define vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_IgnoreArg_physicalDevice() vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_IgnoreArg_pExternalSemaphoreInfo() vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CMockIgnoreArg_pExternalSemaphoreInfo(__LINE__) +void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CMockIgnoreArg_pExternalSemaphoreInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_IgnoreArg_pExternalSemaphoreProperties() vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CMockIgnoreArg_pExternalSemaphoreProperties(__LINE__) +void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_CMockIgnoreArg_pExternalSemaphoreProperties(UNITY_LINE_TYPE cmock_line); +#define vkImportSemaphoreFdKHR_IgnoreAndReturn(cmock_retval) vkImportSemaphoreFdKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkImportSemaphoreFdKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkImportSemaphoreFdKHR_StopIgnore() vkImportSemaphoreFdKHR_CMockStopIgnore() +void vkImportSemaphoreFdKHR_CMockStopIgnore(void); +#define vkImportSemaphoreFdKHR_ExpectAnyArgsAndReturn(cmock_retval) vkImportSemaphoreFdKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkImportSemaphoreFdKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkImportSemaphoreFdKHR_ExpectAndReturn(device, pImportSemaphoreFdInfo, cmock_retval) vkImportSemaphoreFdKHR_CMockExpectAndReturn(__LINE__, device, pImportSemaphoreFdInfo, cmock_retval) +void vkImportSemaphoreFdKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkImportSemaphoreFdKHR_CALLBACK)(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo, int cmock_num_calls); +void vkImportSemaphoreFdKHR_AddCallback(CMOCK_vkImportSemaphoreFdKHR_CALLBACK Callback); +void vkImportSemaphoreFdKHR_Stub(CMOCK_vkImportSemaphoreFdKHR_CALLBACK Callback); +#define vkImportSemaphoreFdKHR_StubWithCallback vkImportSemaphoreFdKHR_AddCallback +#define vkImportSemaphoreFdKHR_IgnoreArg_device() vkImportSemaphoreFdKHR_CMockIgnoreArg_device(__LINE__) +void vkImportSemaphoreFdKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkImportSemaphoreFdKHR_IgnoreArg_pImportSemaphoreFdInfo() vkImportSemaphoreFdKHR_CMockIgnoreArg_pImportSemaphoreFdInfo(__LINE__) +void vkImportSemaphoreFdKHR_CMockIgnoreArg_pImportSemaphoreFdInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetSemaphoreFdKHR_IgnoreAndReturn(cmock_retval) vkGetSemaphoreFdKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetSemaphoreFdKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetSemaphoreFdKHR_StopIgnore() vkGetSemaphoreFdKHR_CMockStopIgnore() +void vkGetSemaphoreFdKHR_CMockStopIgnore(void); +#define vkGetSemaphoreFdKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetSemaphoreFdKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetSemaphoreFdKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetSemaphoreFdKHR_ExpectAndReturn(device, pGetFdInfo, pFd, cmock_retval) vkGetSemaphoreFdKHR_CMockExpectAndReturn(__LINE__, device, pGetFdInfo, pFd, cmock_retval) +void vkGetSemaphoreFdKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetSemaphoreFdKHR_CALLBACK)(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd, int cmock_num_calls); +void vkGetSemaphoreFdKHR_AddCallback(CMOCK_vkGetSemaphoreFdKHR_CALLBACK Callback); +void vkGetSemaphoreFdKHR_Stub(CMOCK_vkGetSemaphoreFdKHR_CALLBACK Callback); +#define vkGetSemaphoreFdKHR_StubWithCallback vkGetSemaphoreFdKHR_AddCallback +#define vkGetSemaphoreFdKHR_ReturnThruPtr_pFd(pFd) vkGetSemaphoreFdKHR_CMockReturnMemThruPtr_pFd(__LINE__, pFd, sizeof(int)) +#define vkGetSemaphoreFdKHR_ReturnArrayThruPtr_pFd(pFd, cmock_len) vkGetSemaphoreFdKHR_CMockReturnMemThruPtr_pFd(__LINE__, pFd, cmock_len * sizeof(*pFd)) +#define vkGetSemaphoreFdKHR_ReturnMemThruPtr_pFd(pFd, cmock_size) vkGetSemaphoreFdKHR_CMockReturnMemThruPtr_pFd(__LINE__, pFd, cmock_size) +void vkGetSemaphoreFdKHR_CMockReturnMemThruPtr_pFd(UNITY_LINE_TYPE cmock_line, int const* pFd, size_t cmock_size); +#define vkGetSemaphoreFdKHR_IgnoreArg_device() vkGetSemaphoreFdKHR_CMockIgnoreArg_device(__LINE__) +void vkGetSemaphoreFdKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetSemaphoreFdKHR_IgnoreArg_pGetFdInfo() vkGetSemaphoreFdKHR_CMockIgnoreArg_pGetFdInfo(__LINE__) +void vkGetSemaphoreFdKHR_CMockIgnoreArg_pGetFdInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetSemaphoreFdKHR_IgnoreArg_pFd() vkGetSemaphoreFdKHR_CMockIgnoreArg_pFd(__LINE__) +void vkGetSemaphoreFdKHR_CMockIgnoreArg_pFd(UNITY_LINE_TYPE cmock_line); +#define vkCmdPushDescriptorSetKHR_Ignore() vkCmdPushDescriptorSetKHR_CMockIgnore() +void vkCmdPushDescriptorSetKHR_CMockIgnore(void); +#define vkCmdPushDescriptorSetKHR_StopIgnore() vkCmdPushDescriptorSetKHR_CMockStopIgnore() +void vkCmdPushDescriptorSetKHR_CMockStopIgnore(void); +#define vkCmdPushDescriptorSetKHR_ExpectAnyArgs() vkCmdPushDescriptorSetKHR_CMockExpectAnyArgs(__LINE__) +void vkCmdPushDescriptorSetKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdPushDescriptorSetKHR_Expect(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites) vkCmdPushDescriptorSetKHR_CMockExpect(__LINE__, commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites) +void vkCmdPushDescriptorSetKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites); +typedef void (* CMOCK_vkCmdPushDescriptorSetKHR_CALLBACK)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, int cmock_num_calls); +void vkCmdPushDescriptorSetKHR_AddCallback(CMOCK_vkCmdPushDescriptorSetKHR_CALLBACK Callback); +void vkCmdPushDescriptorSetKHR_Stub(CMOCK_vkCmdPushDescriptorSetKHR_CALLBACK Callback); +#define vkCmdPushDescriptorSetKHR_StubWithCallback vkCmdPushDescriptorSetKHR_AddCallback +#define vkCmdPushDescriptorSetKHR_IgnoreArg_commandBuffer() vkCmdPushDescriptorSetKHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdPushDescriptorSetKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdPushDescriptorSetKHR_IgnoreArg_pipelineBindPoint() vkCmdPushDescriptorSetKHR_CMockIgnoreArg_pipelineBindPoint(__LINE__) +void vkCmdPushDescriptorSetKHR_CMockIgnoreArg_pipelineBindPoint(UNITY_LINE_TYPE cmock_line); +#define vkCmdPushDescriptorSetKHR_IgnoreArg_layout() vkCmdPushDescriptorSetKHR_CMockIgnoreArg_layout(__LINE__) +void vkCmdPushDescriptorSetKHR_CMockIgnoreArg_layout(UNITY_LINE_TYPE cmock_line); +#define vkCmdPushDescriptorSetKHR_IgnoreArg_set() vkCmdPushDescriptorSetKHR_CMockIgnoreArg_set(__LINE__) +void vkCmdPushDescriptorSetKHR_CMockIgnoreArg_set(UNITY_LINE_TYPE cmock_line); +#define vkCmdPushDescriptorSetKHR_IgnoreArg_descriptorWriteCount() vkCmdPushDescriptorSetKHR_CMockIgnoreArg_descriptorWriteCount(__LINE__) +void vkCmdPushDescriptorSetKHR_CMockIgnoreArg_descriptorWriteCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdPushDescriptorSetKHR_IgnoreArg_pDescriptorWrites() vkCmdPushDescriptorSetKHR_CMockIgnoreArg_pDescriptorWrites(__LINE__) +void vkCmdPushDescriptorSetKHR_CMockIgnoreArg_pDescriptorWrites(UNITY_LINE_TYPE cmock_line); +#define vkCmdPushDescriptorSetWithTemplateKHR_Ignore() vkCmdPushDescriptorSetWithTemplateKHR_CMockIgnore() +void vkCmdPushDescriptorSetWithTemplateKHR_CMockIgnore(void); +#define vkCmdPushDescriptorSetWithTemplateKHR_StopIgnore() vkCmdPushDescriptorSetWithTemplateKHR_CMockStopIgnore() +void vkCmdPushDescriptorSetWithTemplateKHR_CMockStopIgnore(void); +#define vkCmdPushDescriptorSetWithTemplateKHR_ExpectAnyArgs() vkCmdPushDescriptorSetWithTemplateKHR_CMockExpectAnyArgs(__LINE__) +void vkCmdPushDescriptorSetWithTemplateKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdPushDescriptorSetWithTemplateKHR_Expect(commandBuffer, descriptorUpdateTemplate, layout, set, pData) vkCmdPushDescriptorSetWithTemplateKHR_CMockExpect(__LINE__, commandBuffer, descriptorUpdateTemplate, layout, set, pData) +void vkCmdPushDescriptorSetWithTemplateKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData); +typedef void (* CMOCK_vkCmdPushDescriptorSetWithTemplateKHR_CALLBACK)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData, int cmock_num_calls); +void vkCmdPushDescriptorSetWithTemplateKHR_AddCallback(CMOCK_vkCmdPushDescriptorSetWithTemplateKHR_CALLBACK Callback); +void vkCmdPushDescriptorSetWithTemplateKHR_Stub(CMOCK_vkCmdPushDescriptorSetWithTemplateKHR_CALLBACK Callback); +#define vkCmdPushDescriptorSetWithTemplateKHR_StubWithCallback vkCmdPushDescriptorSetWithTemplateKHR_AddCallback +#define vkCmdPushDescriptorSetWithTemplateKHR_IgnoreArg_commandBuffer() vkCmdPushDescriptorSetWithTemplateKHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdPushDescriptorSetWithTemplateKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdPushDescriptorSetWithTemplateKHR_IgnoreArg_descriptorUpdateTemplate() vkCmdPushDescriptorSetWithTemplateKHR_CMockIgnoreArg_descriptorUpdateTemplate(__LINE__) +void vkCmdPushDescriptorSetWithTemplateKHR_CMockIgnoreArg_descriptorUpdateTemplate(UNITY_LINE_TYPE cmock_line); +#define vkCmdPushDescriptorSetWithTemplateKHR_IgnoreArg_layout() vkCmdPushDescriptorSetWithTemplateKHR_CMockIgnoreArg_layout(__LINE__) +void vkCmdPushDescriptorSetWithTemplateKHR_CMockIgnoreArg_layout(UNITY_LINE_TYPE cmock_line); +#define vkCmdPushDescriptorSetWithTemplateKHR_IgnoreArg_set() vkCmdPushDescriptorSetWithTemplateKHR_CMockIgnoreArg_set(__LINE__) +void vkCmdPushDescriptorSetWithTemplateKHR_CMockIgnoreArg_set(UNITY_LINE_TYPE cmock_line); +#define vkCmdPushDescriptorSetWithTemplateKHR_IgnoreArg_pData() vkCmdPushDescriptorSetWithTemplateKHR_CMockIgnoreArg_pData(__LINE__) +void vkCmdPushDescriptorSetWithTemplateKHR_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line); +#define vkCreateDescriptorUpdateTemplateKHR_IgnoreAndReturn(cmock_retval) vkCreateDescriptorUpdateTemplateKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateDescriptorUpdateTemplateKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateDescriptorUpdateTemplateKHR_StopIgnore() vkCreateDescriptorUpdateTemplateKHR_CMockStopIgnore() +void vkCreateDescriptorUpdateTemplateKHR_CMockStopIgnore(void); +#define vkCreateDescriptorUpdateTemplateKHR_ExpectAnyArgsAndReturn(cmock_retval) vkCreateDescriptorUpdateTemplateKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateDescriptorUpdateTemplateKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateDescriptorUpdateTemplateKHR_ExpectAndReturn(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, cmock_retval) vkCreateDescriptorUpdateTemplateKHR_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, cmock_retval) +void vkCreateDescriptorUpdateTemplateKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALLBACK)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate, int cmock_num_calls); +void vkCreateDescriptorUpdateTemplateKHR_AddCallback(CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALLBACK Callback); +void vkCreateDescriptorUpdateTemplateKHR_Stub(CMOCK_vkCreateDescriptorUpdateTemplateKHR_CALLBACK Callback); +#define vkCreateDescriptorUpdateTemplateKHR_StubWithCallback vkCreateDescriptorUpdateTemplateKHR_AddCallback +#define vkCreateDescriptorUpdateTemplateKHR_ReturnThruPtr_pDescriptorUpdateTemplate(pDescriptorUpdateTemplate) vkCreateDescriptorUpdateTemplateKHR_CMockReturnMemThruPtr_pDescriptorUpdateTemplate(__LINE__, pDescriptorUpdateTemplate, sizeof(VkDescriptorUpdateTemplate)) +#define vkCreateDescriptorUpdateTemplateKHR_ReturnArrayThruPtr_pDescriptorUpdateTemplate(pDescriptorUpdateTemplate, cmock_len) vkCreateDescriptorUpdateTemplateKHR_CMockReturnMemThruPtr_pDescriptorUpdateTemplate(__LINE__, pDescriptorUpdateTemplate, cmock_len * sizeof(*pDescriptorUpdateTemplate)) +#define vkCreateDescriptorUpdateTemplateKHR_ReturnMemThruPtr_pDescriptorUpdateTemplate(pDescriptorUpdateTemplate, cmock_size) vkCreateDescriptorUpdateTemplateKHR_CMockReturnMemThruPtr_pDescriptorUpdateTemplate(__LINE__, pDescriptorUpdateTemplate, cmock_size) +void vkCreateDescriptorUpdateTemplateKHR_CMockReturnMemThruPtr_pDescriptorUpdateTemplate(UNITY_LINE_TYPE cmock_line, VkDescriptorUpdateTemplate const* pDescriptorUpdateTemplate, size_t cmock_size); +#define vkCreateDescriptorUpdateTemplateKHR_IgnoreArg_device() vkCreateDescriptorUpdateTemplateKHR_CMockIgnoreArg_device(__LINE__) +void vkCreateDescriptorUpdateTemplateKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateDescriptorUpdateTemplateKHR_IgnoreArg_pCreateInfo() vkCreateDescriptorUpdateTemplateKHR_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateDescriptorUpdateTemplateKHR_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateDescriptorUpdateTemplateKHR_IgnoreArg_pAllocator() vkCreateDescriptorUpdateTemplateKHR_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateDescriptorUpdateTemplateKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateDescriptorUpdateTemplateKHR_IgnoreArg_pDescriptorUpdateTemplate() vkCreateDescriptorUpdateTemplateKHR_CMockIgnoreArg_pDescriptorUpdateTemplate(__LINE__) +void vkCreateDescriptorUpdateTemplateKHR_CMockIgnoreArg_pDescriptorUpdateTemplate(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDescriptorUpdateTemplateKHR_Ignore() vkDestroyDescriptorUpdateTemplateKHR_CMockIgnore() +void vkDestroyDescriptorUpdateTemplateKHR_CMockIgnore(void); +#define vkDestroyDescriptorUpdateTemplateKHR_StopIgnore() vkDestroyDescriptorUpdateTemplateKHR_CMockStopIgnore() +void vkDestroyDescriptorUpdateTemplateKHR_CMockStopIgnore(void); +#define vkDestroyDescriptorUpdateTemplateKHR_ExpectAnyArgs() vkDestroyDescriptorUpdateTemplateKHR_CMockExpectAnyArgs(__LINE__) +void vkDestroyDescriptorUpdateTemplateKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDescriptorUpdateTemplateKHR_Expect(device, descriptorUpdateTemplate, pAllocator) vkDestroyDescriptorUpdateTemplateKHR_CMockExpect(__LINE__, device, descriptorUpdateTemplate, pAllocator) +void vkDestroyDescriptorUpdateTemplateKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyDescriptorUpdateTemplateKHR_CALLBACK)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyDescriptorUpdateTemplateKHR_AddCallback(CMOCK_vkDestroyDescriptorUpdateTemplateKHR_CALLBACK Callback); +void vkDestroyDescriptorUpdateTemplateKHR_Stub(CMOCK_vkDestroyDescriptorUpdateTemplateKHR_CALLBACK Callback); +#define vkDestroyDescriptorUpdateTemplateKHR_StubWithCallback vkDestroyDescriptorUpdateTemplateKHR_AddCallback +#define vkDestroyDescriptorUpdateTemplateKHR_IgnoreArg_device() vkDestroyDescriptorUpdateTemplateKHR_CMockIgnoreArg_device(__LINE__) +void vkDestroyDescriptorUpdateTemplateKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDescriptorUpdateTemplateKHR_IgnoreArg_descriptorUpdateTemplate() vkDestroyDescriptorUpdateTemplateKHR_CMockIgnoreArg_descriptorUpdateTemplate(__LINE__) +void vkDestroyDescriptorUpdateTemplateKHR_CMockIgnoreArg_descriptorUpdateTemplate(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDescriptorUpdateTemplateKHR_IgnoreArg_pAllocator() vkDestroyDescriptorUpdateTemplateKHR_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyDescriptorUpdateTemplateKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkUpdateDescriptorSetWithTemplateKHR_Ignore() vkUpdateDescriptorSetWithTemplateKHR_CMockIgnore() +void vkUpdateDescriptorSetWithTemplateKHR_CMockIgnore(void); +#define vkUpdateDescriptorSetWithTemplateKHR_StopIgnore() vkUpdateDescriptorSetWithTemplateKHR_CMockStopIgnore() +void vkUpdateDescriptorSetWithTemplateKHR_CMockStopIgnore(void); +#define vkUpdateDescriptorSetWithTemplateKHR_ExpectAnyArgs() vkUpdateDescriptorSetWithTemplateKHR_CMockExpectAnyArgs(__LINE__) +void vkUpdateDescriptorSetWithTemplateKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkUpdateDescriptorSetWithTemplateKHR_Expect(device, descriptorSet, descriptorUpdateTemplate, pData) vkUpdateDescriptorSetWithTemplateKHR_CMockExpect(__LINE__, device, descriptorSet, descriptorUpdateTemplate, pData) +void vkUpdateDescriptorSetWithTemplateKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); +typedef void (* CMOCK_vkUpdateDescriptorSetWithTemplateKHR_CALLBACK)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData, int cmock_num_calls); +void vkUpdateDescriptorSetWithTemplateKHR_AddCallback(CMOCK_vkUpdateDescriptorSetWithTemplateKHR_CALLBACK Callback); +void vkUpdateDescriptorSetWithTemplateKHR_Stub(CMOCK_vkUpdateDescriptorSetWithTemplateKHR_CALLBACK Callback); +#define vkUpdateDescriptorSetWithTemplateKHR_StubWithCallback vkUpdateDescriptorSetWithTemplateKHR_AddCallback +#define vkUpdateDescriptorSetWithTemplateKHR_IgnoreArg_device() vkUpdateDescriptorSetWithTemplateKHR_CMockIgnoreArg_device(__LINE__) +void vkUpdateDescriptorSetWithTemplateKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkUpdateDescriptorSetWithTemplateKHR_IgnoreArg_descriptorSet() vkUpdateDescriptorSetWithTemplateKHR_CMockIgnoreArg_descriptorSet(__LINE__) +void vkUpdateDescriptorSetWithTemplateKHR_CMockIgnoreArg_descriptorSet(UNITY_LINE_TYPE cmock_line); +#define vkUpdateDescriptorSetWithTemplateKHR_IgnoreArg_descriptorUpdateTemplate() vkUpdateDescriptorSetWithTemplateKHR_CMockIgnoreArg_descriptorUpdateTemplate(__LINE__) +void vkUpdateDescriptorSetWithTemplateKHR_CMockIgnoreArg_descriptorUpdateTemplate(UNITY_LINE_TYPE cmock_line); +#define vkUpdateDescriptorSetWithTemplateKHR_IgnoreArg_pData() vkUpdateDescriptorSetWithTemplateKHR_CMockIgnoreArg_pData(__LINE__) +void vkUpdateDescriptorSetWithTemplateKHR_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line); +#define vkCreateRenderPass2KHR_IgnoreAndReturn(cmock_retval) vkCreateRenderPass2KHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateRenderPass2KHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateRenderPass2KHR_StopIgnore() vkCreateRenderPass2KHR_CMockStopIgnore() +void vkCreateRenderPass2KHR_CMockStopIgnore(void); +#define vkCreateRenderPass2KHR_ExpectAnyArgsAndReturn(cmock_retval) vkCreateRenderPass2KHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateRenderPass2KHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateRenderPass2KHR_ExpectAndReturn(device, pCreateInfo, pAllocator, pRenderPass, cmock_retval) vkCreateRenderPass2KHR_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pRenderPass, cmock_retval) +void vkCreateRenderPass2KHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateRenderPass2KHR_CALLBACK)(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, int cmock_num_calls); +void vkCreateRenderPass2KHR_AddCallback(CMOCK_vkCreateRenderPass2KHR_CALLBACK Callback); +void vkCreateRenderPass2KHR_Stub(CMOCK_vkCreateRenderPass2KHR_CALLBACK Callback); +#define vkCreateRenderPass2KHR_StubWithCallback vkCreateRenderPass2KHR_AddCallback +#define vkCreateRenderPass2KHR_ReturnThruPtr_pRenderPass(pRenderPass) vkCreateRenderPass2KHR_CMockReturnMemThruPtr_pRenderPass(__LINE__, pRenderPass, sizeof(VkRenderPass)) +#define vkCreateRenderPass2KHR_ReturnArrayThruPtr_pRenderPass(pRenderPass, cmock_len) vkCreateRenderPass2KHR_CMockReturnMemThruPtr_pRenderPass(__LINE__, pRenderPass, cmock_len * sizeof(*pRenderPass)) +#define vkCreateRenderPass2KHR_ReturnMemThruPtr_pRenderPass(pRenderPass, cmock_size) vkCreateRenderPass2KHR_CMockReturnMemThruPtr_pRenderPass(__LINE__, pRenderPass, cmock_size) +void vkCreateRenderPass2KHR_CMockReturnMemThruPtr_pRenderPass(UNITY_LINE_TYPE cmock_line, VkRenderPass const* pRenderPass, size_t cmock_size); +#define vkCreateRenderPass2KHR_IgnoreArg_device() vkCreateRenderPass2KHR_CMockIgnoreArg_device(__LINE__) +void vkCreateRenderPass2KHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateRenderPass2KHR_IgnoreArg_pCreateInfo() vkCreateRenderPass2KHR_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateRenderPass2KHR_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateRenderPass2KHR_IgnoreArg_pAllocator() vkCreateRenderPass2KHR_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateRenderPass2KHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateRenderPass2KHR_IgnoreArg_pRenderPass() vkCreateRenderPass2KHR_CMockIgnoreArg_pRenderPass(__LINE__) +void vkCreateRenderPass2KHR_CMockIgnoreArg_pRenderPass(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginRenderPass2KHR_Ignore() vkCmdBeginRenderPass2KHR_CMockIgnore() +void vkCmdBeginRenderPass2KHR_CMockIgnore(void); +#define vkCmdBeginRenderPass2KHR_StopIgnore() vkCmdBeginRenderPass2KHR_CMockStopIgnore() +void vkCmdBeginRenderPass2KHR_CMockStopIgnore(void); +#define vkCmdBeginRenderPass2KHR_ExpectAnyArgs() vkCmdBeginRenderPass2KHR_CMockExpectAnyArgs(__LINE__) +void vkCmdBeginRenderPass2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginRenderPass2KHR_Expect(commandBuffer, pRenderPassBegin, pSubpassBeginInfo) vkCmdBeginRenderPass2KHR_CMockExpect(__LINE__, commandBuffer, pRenderPassBegin, pSubpassBeginInfo) +void vkCmdBeginRenderPass2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo); +typedef void (* CMOCK_vkCmdBeginRenderPass2KHR_CALLBACK)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo, int cmock_num_calls); +void vkCmdBeginRenderPass2KHR_AddCallback(CMOCK_vkCmdBeginRenderPass2KHR_CALLBACK Callback); +void vkCmdBeginRenderPass2KHR_Stub(CMOCK_vkCmdBeginRenderPass2KHR_CALLBACK Callback); +#define vkCmdBeginRenderPass2KHR_StubWithCallback vkCmdBeginRenderPass2KHR_AddCallback +#define vkCmdBeginRenderPass2KHR_IgnoreArg_commandBuffer() vkCmdBeginRenderPass2KHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBeginRenderPass2KHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginRenderPass2KHR_IgnoreArg_pRenderPassBegin() vkCmdBeginRenderPass2KHR_CMockIgnoreArg_pRenderPassBegin(__LINE__) +void vkCmdBeginRenderPass2KHR_CMockIgnoreArg_pRenderPassBegin(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginRenderPass2KHR_IgnoreArg_pSubpassBeginInfo() vkCmdBeginRenderPass2KHR_CMockIgnoreArg_pSubpassBeginInfo(__LINE__) +void vkCmdBeginRenderPass2KHR_CMockIgnoreArg_pSubpassBeginInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdNextSubpass2KHR_Ignore() vkCmdNextSubpass2KHR_CMockIgnore() +void vkCmdNextSubpass2KHR_CMockIgnore(void); +#define vkCmdNextSubpass2KHR_StopIgnore() vkCmdNextSubpass2KHR_CMockStopIgnore() +void vkCmdNextSubpass2KHR_CMockStopIgnore(void); +#define vkCmdNextSubpass2KHR_ExpectAnyArgs() vkCmdNextSubpass2KHR_CMockExpectAnyArgs(__LINE__) +void vkCmdNextSubpass2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdNextSubpass2KHR_Expect(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo) vkCmdNextSubpass2KHR_CMockExpect(__LINE__, commandBuffer, pSubpassBeginInfo, pSubpassEndInfo) +void vkCmdNextSubpass2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo); +typedef void (* CMOCK_vkCmdNextSubpass2KHR_CALLBACK)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo, int cmock_num_calls); +void vkCmdNextSubpass2KHR_AddCallback(CMOCK_vkCmdNextSubpass2KHR_CALLBACK Callback); +void vkCmdNextSubpass2KHR_Stub(CMOCK_vkCmdNextSubpass2KHR_CALLBACK Callback); +#define vkCmdNextSubpass2KHR_StubWithCallback vkCmdNextSubpass2KHR_AddCallback +#define vkCmdNextSubpass2KHR_IgnoreArg_commandBuffer() vkCmdNextSubpass2KHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdNextSubpass2KHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdNextSubpass2KHR_IgnoreArg_pSubpassBeginInfo() vkCmdNextSubpass2KHR_CMockIgnoreArg_pSubpassBeginInfo(__LINE__) +void vkCmdNextSubpass2KHR_CMockIgnoreArg_pSubpassBeginInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdNextSubpass2KHR_IgnoreArg_pSubpassEndInfo() vkCmdNextSubpass2KHR_CMockIgnoreArg_pSubpassEndInfo(__LINE__) +void vkCmdNextSubpass2KHR_CMockIgnoreArg_pSubpassEndInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndRenderPass2KHR_Ignore() vkCmdEndRenderPass2KHR_CMockIgnore() +void vkCmdEndRenderPass2KHR_CMockIgnore(void); +#define vkCmdEndRenderPass2KHR_StopIgnore() vkCmdEndRenderPass2KHR_CMockStopIgnore() +void vkCmdEndRenderPass2KHR_CMockStopIgnore(void); +#define vkCmdEndRenderPass2KHR_ExpectAnyArgs() vkCmdEndRenderPass2KHR_CMockExpectAnyArgs(__LINE__) +void vkCmdEndRenderPass2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndRenderPass2KHR_Expect(commandBuffer, pSubpassEndInfo) vkCmdEndRenderPass2KHR_CMockExpect(__LINE__, commandBuffer, pSubpassEndInfo) +void vkCmdEndRenderPass2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo); +typedef void (* CMOCK_vkCmdEndRenderPass2KHR_CALLBACK)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo, int cmock_num_calls); +void vkCmdEndRenderPass2KHR_AddCallback(CMOCK_vkCmdEndRenderPass2KHR_CALLBACK Callback); +void vkCmdEndRenderPass2KHR_Stub(CMOCK_vkCmdEndRenderPass2KHR_CALLBACK Callback); +#define vkCmdEndRenderPass2KHR_StubWithCallback vkCmdEndRenderPass2KHR_AddCallback +#define vkCmdEndRenderPass2KHR_IgnoreArg_commandBuffer() vkCmdEndRenderPass2KHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdEndRenderPass2KHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndRenderPass2KHR_IgnoreArg_pSubpassEndInfo() vkCmdEndRenderPass2KHR_CMockIgnoreArg_pSubpassEndInfo(__LINE__) +void vkCmdEndRenderPass2KHR_CMockIgnoreArg_pSubpassEndInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetSwapchainStatusKHR_IgnoreAndReturn(cmock_retval) vkGetSwapchainStatusKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetSwapchainStatusKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetSwapchainStatusKHR_StopIgnore() vkGetSwapchainStatusKHR_CMockStopIgnore() +void vkGetSwapchainStatusKHR_CMockStopIgnore(void); +#define vkGetSwapchainStatusKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetSwapchainStatusKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetSwapchainStatusKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetSwapchainStatusKHR_ExpectAndReturn(device, swapchain, cmock_retval) vkGetSwapchainStatusKHR_CMockExpectAndReturn(__LINE__, device, swapchain, cmock_retval) +void vkGetSwapchainStatusKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSwapchainKHR swapchain, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetSwapchainStatusKHR_CALLBACK)(VkDevice device, VkSwapchainKHR swapchain, int cmock_num_calls); +void vkGetSwapchainStatusKHR_AddCallback(CMOCK_vkGetSwapchainStatusKHR_CALLBACK Callback); +void vkGetSwapchainStatusKHR_Stub(CMOCK_vkGetSwapchainStatusKHR_CALLBACK Callback); +#define vkGetSwapchainStatusKHR_StubWithCallback vkGetSwapchainStatusKHR_AddCallback +#define vkGetSwapchainStatusKHR_IgnoreArg_device() vkGetSwapchainStatusKHR_CMockIgnoreArg_device(__LINE__) +void vkGetSwapchainStatusKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetSwapchainStatusKHR_IgnoreArg_swapchain() vkGetSwapchainStatusKHR_CMockIgnoreArg_swapchain(__LINE__) +void vkGetSwapchainStatusKHR_CMockIgnoreArg_swapchain(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalFencePropertiesKHR_Ignore() vkGetPhysicalDeviceExternalFencePropertiesKHR_CMockIgnore() +void vkGetPhysicalDeviceExternalFencePropertiesKHR_CMockIgnore(void); +#define vkGetPhysicalDeviceExternalFencePropertiesKHR_StopIgnore() vkGetPhysicalDeviceExternalFencePropertiesKHR_CMockStopIgnore() +void vkGetPhysicalDeviceExternalFencePropertiesKHR_CMockStopIgnore(void); +#define vkGetPhysicalDeviceExternalFencePropertiesKHR_ExpectAnyArgs() vkGetPhysicalDeviceExternalFencePropertiesKHR_CMockExpectAnyArgs(__LINE__) +void vkGetPhysicalDeviceExternalFencePropertiesKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalFencePropertiesKHR_Expect(physicalDevice, pExternalFenceInfo, pExternalFenceProperties) vkGetPhysicalDeviceExternalFencePropertiesKHR_CMockExpect(__LINE__, physicalDevice, pExternalFenceInfo, pExternalFenceProperties) +void vkGetPhysicalDeviceExternalFencePropertiesKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); +typedef void (* CMOCK_vkGetPhysicalDeviceExternalFencePropertiesKHR_CALLBACK)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties, int cmock_num_calls); +void vkGetPhysicalDeviceExternalFencePropertiesKHR_AddCallback(CMOCK_vkGetPhysicalDeviceExternalFencePropertiesKHR_CALLBACK Callback); +void vkGetPhysicalDeviceExternalFencePropertiesKHR_Stub(CMOCK_vkGetPhysicalDeviceExternalFencePropertiesKHR_CALLBACK Callback); +#define vkGetPhysicalDeviceExternalFencePropertiesKHR_StubWithCallback vkGetPhysicalDeviceExternalFencePropertiesKHR_AddCallback +#define vkGetPhysicalDeviceExternalFencePropertiesKHR_ReturnThruPtr_pExternalFenceProperties(pExternalFenceProperties) vkGetPhysicalDeviceExternalFencePropertiesKHR_CMockReturnMemThruPtr_pExternalFenceProperties(__LINE__, pExternalFenceProperties, sizeof(VkExternalFenceProperties)) +#define vkGetPhysicalDeviceExternalFencePropertiesKHR_ReturnArrayThruPtr_pExternalFenceProperties(pExternalFenceProperties, cmock_len) vkGetPhysicalDeviceExternalFencePropertiesKHR_CMockReturnMemThruPtr_pExternalFenceProperties(__LINE__, pExternalFenceProperties, cmock_len * sizeof(*pExternalFenceProperties)) +#define vkGetPhysicalDeviceExternalFencePropertiesKHR_ReturnMemThruPtr_pExternalFenceProperties(pExternalFenceProperties, cmock_size) vkGetPhysicalDeviceExternalFencePropertiesKHR_CMockReturnMemThruPtr_pExternalFenceProperties(__LINE__, pExternalFenceProperties, cmock_size) +void vkGetPhysicalDeviceExternalFencePropertiesKHR_CMockReturnMemThruPtr_pExternalFenceProperties(UNITY_LINE_TYPE cmock_line, VkExternalFenceProperties const* pExternalFenceProperties, size_t cmock_size); +#define vkGetPhysicalDeviceExternalFencePropertiesKHR_IgnoreArg_physicalDevice() vkGetPhysicalDeviceExternalFencePropertiesKHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceExternalFencePropertiesKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalFencePropertiesKHR_IgnoreArg_pExternalFenceInfo() vkGetPhysicalDeviceExternalFencePropertiesKHR_CMockIgnoreArg_pExternalFenceInfo(__LINE__) +void vkGetPhysicalDeviceExternalFencePropertiesKHR_CMockIgnoreArg_pExternalFenceInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalFencePropertiesKHR_IgnoreArg_pExternalFenceProperties() vkGetPhysicalDeviceExternalFencePropertiesKHR_CMockIgnoreArg_pExternalFenceProperties(__LINE__) +void vkGetPhysicalDeviceExternalFencePropertiesKHR_CMockIgnoreArg_pExternalFenceProperties(UNITY_LINE_TYPE cmock_line); +#define vkImportFenceFdKHR_IgnoreAndReturn(cmock_retval) vkImportFenceFdKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkImportFenceFdKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkImportFenceFdKHR_StopIgnore() vkImportFenceFdKHR_CMockStopIgnore() +void vkImportFenceFdKHR_CMockStopIgnore(void); +#define vkImportFenceFdKHR_ExpectAnyArgsAndReturn(cmock_retval) vkImportFenceFdKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkImportFenceFdKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkImportFenceFdKHR_ExpectAndReturn(device, pImportFenceFdInfo, cmock_retval) vkImportFenceFdKHR_CMockExpectAndReturn(__LINE__, device, pImportFenceFdInfo, cmock_retval) +void vkImportFenceFdKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkImportFenceFdKHR_CALLBACK)(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo, int cmock_num_calls); +void vkImportFenceFdKHR_AddCallback(CMOCK_vkImportFenceFdKHR_CALLBACK Callback); +void vkImportFenceFdKHR_Stub(CMOCK_vkImportFenceFdKHR_CALLBACK Callback); +#define vkImportFenceFdKHR_StubWithCallback vkImportFenceFdKHR_AddCallback +#define vkImportFenceFdKHR_IgnoreArg_device() vkImportFenceFdKHR_CMockIgnoreArg_device(__LINE__) +void vkImportFenceFdKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkImportFenceFdKHR_IgnoreArg_pImportFenceFdInfo() vkImportFenceFdKHR_CMockIgnoreArg_pImportFenceFdInfo(__LINE__) +void vkImportFenceFdKHR_CMockIgnoreArg_pImportFenceFdInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetFenceFdKHR_IgnoreAndReturn(cmock_retval) vkGetFenceFdKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetFenceFdKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetFenceFdKHR_StopIgnore() vkGetFenceFdKHR_CMockStopIgnore() +void vkGetFenceFdKHR_CMockStopIgnore(void); +#define vkGetFenceFdKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetFenceFdKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetFenceFdKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetFenceFdKHR_ExpectAndReturn(device, pGetFdInfo, pFd, cmock_retval) vkGetFenceFdKHR_CMockExpectAndReturn(__LINE__, device, pGetFdInfo, pFd, cmock_retval) +void vkGetFenceFdKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetFenceFdKHR_CALLBACK)(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd, int cmock_num_calls); +void vkGetFenceFdKHR_AddCallback(CMOCK_vkGetFenceFdKHR_CALLBACK Callback); +void vkGetFenceFdKHR_Stub(CMOCK_vkGetFenceFdKHR_CALLBACK Callback); +#define vkGetFenceFdKHR_StubWithCallback vkGetFenceFdKHR_AddCallback +#define vkGetFenceFdKHR_ReturnThruPtr_pFd(pFd) vkGetFenceFdKHR_CMockReturnMemThruPtr_pFd(__LINE__, pFd, sizeof(int)) +#define vkGetFenceFdKHR_ReturnArrayThruPtr_pFd(pFd, cmock_len) vkGetFenceFdKHR_CMockReturnMemThruPtr_pFd(__LINE__, pFd, cmock_len * sizeof(*pFd)) +#define vkGetFenceFdKHR_ReturnMemThruPtr_pFd(pFd, cmock_size) vkGetFenceFdKHR_CMockReturnMemThruPtr_pFd(__LINE__, pFd, cmock_size) +void vkGetFenceFdKHR_CMockReturnMemThruPtr_pFd(UNITY_LINE_TYPE cmock_line, int const* pFd, size_t cmock_size); +#define vkGetFenceFdKHR_IgnoreArg_device() vkGetFenceFdKHR_CMockIgnoreArg_device(__LINE__) +void vkGetFenceFdKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetFenceFdKHR_IgnoreArg_pGetFdInfo() vkGetFenceFdKHR_CMockIgnoreArg_pGetFdInfo(__LINE__) +void vkGetFenceFdKHR_CMockIgnoreArg_pGetFdInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetFenceFdKHR_IgnoreArg_pFd() vkGetFenceFdKHR_CMockIgnoreArg_pFd(__LINE__) +void vkGetFenceFdKHR_CMockIgnoreArg_pFd(UNITY_LINE_TYPE cmock_line); +#define vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_IgnoreAndReturn(cmock_retval) vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_StopIgnore() vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockStopIgnore() +void vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockStopIgnore(void); +#define vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_ExpectAnyArgsAndReturn(cmock_retval) vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_ExpectAndReturn(physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions, cmock_retval) vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockExpectAndReturn(__LINE__, physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions, cmock_retval) +void vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALLBACK)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions, int cmock_num_calls); +void vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_AddCallback(CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALLBACK Callback); +void vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_Stub(CMOCK_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CALLBACK Callback); +#define vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_StubWithCallback vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_AddCallback +#define vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_ReturnThruPtr_pCounterCount(pCounterCount) vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockReturnMemThruPtr_pCounterCount(__LINE__, pCounterCount, sizeof(uint32_t)) +#define vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_ReturnArrayThruPtr_pCounterCount(pCounterCount, cmock_len) vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockReturnMemThruPtr_pCounterCount(__LINE__, pCounterCount, cmock_len * sizeof(*pCounterCount)) +#define vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_ReturnMemThruPtr_pCounterCount(pCounterCount, cmock_size) vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockReturnMemThruPtr_pCounterCount(__LINE__, pCounterCount, cmock_size) +void vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockReturnMemThruPtr_pCounterCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pCounterCount, size_t cmock_size); +#define vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_ReturnThruPtr_pCounters(pCounters) vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockReturnMemThruPtr_pCounters(__LINE__, pCounters, sizeof(VkPerformanceCounterKHR)) +#define vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_ReturnArrayThruPtr_pCounters(pCounters, cmock_len) vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockReturnMemThruPtr_pCounters(__LINE__, pCounters, cmock_len * sizeof(*pCounters)) +#define vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_ReturnMemThruPtr_pCounters(pCounters, cmock_size) vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockReturnMemThruPtr_pCounters(__LINE__, pCounters, cmock_size) +void vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockReturnMemThruPtr_pCounters(UNITY_LINE_TYPE cmock_line, VkPerformanceCounterKHR const* pCounters, size_t cmock_size); +#define vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_ReturnThruPtr_pCounterDescriptions(pCounterDescriptions) vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockReturnMemThruPtr_pCounterDescriptions(__LINE__, pCounterDescriptions, sizeof(VkPerformanceCounterDescriptionKHR)) +#define vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_ReturnArrayThruPtr_pCounterDescriptions(pCounterDescriptions, cmock_len) vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockReturnMemThruPtr_pCounterDescriptions(__LINE__, pCounterDescriptions, cmock_len * sizeof(*pCounterDescriptions)) +#define vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_ReturnMemThruPtr_pCounterDescriptions(pCounterDescriptions, cmock_size) vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockReturnMemThruPtr_pCounterDescriptions(__LINE__, pCounterDescriptions, cmock_size) +void vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockReturnMemThruPtr_pCounterDescriptions(UNITY_LINE_TYPE cmock_line, VkPerformanceCounterDescriptionKHR const* pCounterDescriptions, size_t cmock_size); +#define vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_IgnoreArg_physicalDevice() vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_IgnoreArg_queueFamilyIndex() vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockIgnoreArg_queueFamilyIndex(__LINE__) +void vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockIgnoreArg_queueFamilyIndex(UNITY_LINE_TYPE cmock_line); +#define vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_IgnoreArg_pCounterCount() vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockIgnoreArg_pCounterCount(__LINE__) +void vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockIgnoreArg_pCounterCount(UNITY_LINE_TYPE cmock_line); +#define vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_IgnoreArg_pCounters() vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockIgnoreArg_pCounters(__LINE__) +void vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockIgnoreArg_pCounters(UNITY_LINE_TYPE cmock_line); +#define vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_IgnoreArg_pCounterDescriptions() vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockIgnoreArg_pCounterDescriptions(__LINE__) +void vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_CMockIgnoreArg_pCounterDescriptions(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_Ignore() vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CMockIgnore() +void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CMockIgnore(void); +#define vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_StopIgnore() vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CMockStopIgnore() +void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CMockStopIgnore(void); +#define vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_ExpectAnyArgs() vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CMockExpectAnyArgs(__LINE__) +void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_Expect(physicalDevice, pPerformanceQueryCreateInfo, pNumPasses) vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CMockExpect(__LINE__, physicalDevice, pPerformanceQueryCreateInfo, pNumPasses) +void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses); +typedef void (* CMOCK_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CALLBACK)(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses, int cmock_num_calls); +void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_AddCallback(CMOCK_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CALLBACK Callback); +void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_Stub(CMOCK_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CALLBACK Callback); +#define vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_StubWithCallback vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_AddCallback +#define vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_ReturnThruPtr_pNumPasses(pNumPasses) vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CMockReturnMemThruPtr_pNumPasses(__LINE__, pNumPasses, sizeof(uint32_t)) +#define vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_ReturnArrayThruPtr_pNumPasses(pNumPasses, cmock_len) vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CMockReturnMemThruPtr_pNumPasses(__LINE__, pNumPasses, cmock_len * sizeof(*pNumPasses)) +#define vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_ReturnMemThruPtr_pNumPasses(pNumPasses, cmock_size) vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CMockReturnMemThruPtr_pNumPasses(__LINE__, pNumPasses, cmock_size) +void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CMockReturnMemThruPtr_pNumPasses(UNITY_LINE_TYPE cmock_line, uint32_t const* pNumPasses, size_t cmock_size); +#define vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_IgnoreArg_physicalDevice() vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_IgnoreArg_pPerformanceQueryCreateInfo() vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CMockIgnoreArg_pPerformanceQueryCreateInfo(__LINE__) +void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CMockIgnoreArg_pPerformanceQueryCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_IgnoreArg_pNumPasses() vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CMockIgnoreArg_pNumPasses(__LINE__) +void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_CMockIgnoreArg_pNumPasses(UNITY_LINE_TYPE cmock_line); +#define vkAcquireProfilingLockKHR_IgnoreAndReturn(cmock_retval) vkAcquireProfilingLockKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkAcquireProfilingLockKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkAcquireProfilingLockKHR_StopIgnore() vkAcquireProfilingLockKHR_CMockStopIgnore() +void vkAcquireProfilingLockKHR_CMockStopIgnore(void); +#define vkAcquireProfilingLockKHR_ExpectAnyArgsAndReturn(cmock_retval) vkAcquireProfilingLockKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkAcquireProfilingLockKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkAcquireProfilingLockKHR_ExpectAndReturn(device, pInfo, cmock_retval) vkAcquireProfilingLockKHR_CMockExpectAndReturn(__LINE__, device, pInfo, cmock_retval) +void vkAcquireProfilingLockKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkAcquireProfilingLockKHR_CALLBACK)(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo, int cmock_num_calls); +void vkAcquireProfilingLockKHR_AddCallback(CMOCK_vkAcquireProfilingLockKHR_CALLBACK Callback); +void vkAcquireProfilingLockKHR_Stub(CMOCK_vkAcquireProfilingLockKHR_CALLBACK Callback); +#define vkAcquireProfilingLockKHR_StubWithCallback vkAcquireProfilingLockKHR_AddCallback +#define vkAcquireProfilingLockKHR_IgnoreArg_device() vkAcquireProfilingLockKHR_CMockIgnoreArg_device(__LINE__) +void vkAcquireProfilingLockKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkAcquireProfilingLockKHR_IgnoreArg_pInfo() vkAcquireProfilingLockKHR_CMockIgnoreArg_pInfo(__LINE__) +void vkAcquireProfilingLockKHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkReleaseProfilingLockKHR_Ignore() vkReleaseProfilingLockKHR_CMockIgnore() +void vkReleaseProfilingLockKHR_CMockIgnore(void); +#define vkReleaseProfilingLockKHR_StopIgnore() vkReleaseProfilingLockKHR_CMockStopIgnore() +void vkReleaseProfilingLockKHR_CMockStopIgnore(void); +#define vkReleaseProfilingLockKHR_ExpectAnyArgs() vkReleaseProfilingLockKHR_CMockExpectAnyArgs(__LINE__) +void vkReleaseProfilingLockKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkReleaseProfilingLockKHR_Expect(device) vkReleaseProfilingLockKHR_CMockExpect(__LINE__, device) +void vkReleaseProfilingLockKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device); +typedef void (* CMOCK_vkReleaseProfilingLockKHR_CALLBACK)(VkDevice device, int cmock_num_calls); +void vkReleaseProfilingLockKHR_AddCallback(CMOCK_vkReleaseProfilingLockKHR_CALLBACK Callback); +void vkReleaseProfilingLockKHR_Stub(CMOCK_vkReleaseProfilingLockKHR_CALLBACK Callback); +#define vkReleaseProfilingLockKHR_StubWithCallback vkReleaseProfilingLockKHR_AddCallback +#define vkReleaseProfilingLockKHR_IgnoreArg_device() vkReleaseProfilingLockKHR_CMockIgnoreArg_device(__LINE__) +void vkReleaseProfilingLockKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSurfaceCapabilities2KHR_IgnoreAndReturn(cmock_retval) vkGetPhysicalDeviceSurfaceCapabilities2KHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceSurfaceCapabilities2KHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceSurfaceCapabilities2KHR_StopIgnore() vkGetPhysicalDeviceSurfaceCapabilities2KHR_CMockStopIgnore() +void vkGetPhysicalDeviceSurfaceCapabilities2KHR_CMockStopIgnore(void); +#define vkGetPhysicalDeviceSurfaceCapabilities2KHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetPhysicalDeviceSurfaceCapabilities2KHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceSurfaceCapabilities2KHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceSurfaceCapabilities2KHR_ExpectAndReturn(physicalDevice, pSurfaceInfo, pSurfaceCapabilities, cmock_retval) vkGetPhysicalDeviceSurfaceCapabilities2KHR_CMockExpectAndReturn(__LINE__, physicalDevice, pSurfaceInfo, pSurfaceCapabilities, cmock_retval) +void vkGetPhysicalDeviceSurfaceCapabilities2KHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2KHR_CALLBACK)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities, int cmock_num_calls); +void vkGetPhysicalDeviceSurfaceCapabilities2KHR_AddCallback(CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2KHR_CALLBACK Callback); +void vkGetPhysicalDeviceSurfaceCapabilities2KHR_Stub(CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2KHR_CALLBACK Callback); +#define vkGetPhysicalDeviceSurfaceCapabilities2KHR_StubWithCallback vkGetPhysicalDeviceSurfaceCapabilities2KHR_AddCallback +#define vkGetPhysicalDeviceSurfaceCapabilities2KHR_ReturnThruPtr_pSurfaceCapabilities(pSurfaceCapabilities) vkGetPhysicalDeviceSurfaceCapabilities2KHR_CMockReturnMemThruPtr_pSurfaceCapabilities(__LINE__, pSurfaceCapabilities, sizeof(VkSurfaceCapabilities2KHR)) +#define vkGetPhysicalDeviceSurfaceCapabilities2KHR_ReturnArrayThruPtr_pSurfaceCapabilities(pSurfaceCapabilities, cmock_len) vkGetPhysicalDeviceSurfaceCapabilities2KHR_CMockReturnMemThruPtr_pSurfaceCapabilities(__LINE__, pSurfaceCapabilities, cmock_len * sizeof(*pSurfaceCapabilities)) +#define vkGetPhysicalDeviceSurfaceCapabilities2KHR_ReturnMemThruPtr_pSurfaceCapabilities(pSurfaceCapabilities, cmock_size) vkGetPhysicalDeviceSurfaceCapabilities2KHR_CMockReturnMemThruPtr_pSurfaceCapabilities(__LINE__, pSurfaceCapabilities, cmock_size) +void vkGetPhysicalDeviceSurfaceCapabilities2KHR_CMockReturnMemThruPtr_pSurfaceCapabilities(UNITY_LINE_TYPE cmock_line, VkSurfaceCapabilities2KHR const* pSurfaceCapabilities, size_t cmock_size); +#define vkGetPhysicalDeviceSurfaceCapabilities2KHR_IgnoreArg_physicalDevice() vkGetPhysicalDeviceSurfaceCapabilities2KHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceSurfaceCapabilities2KHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSurfaceCapabilities2KHR_IgnoreArg_pSurfaceInfo() vkGetPhysicalDeviceSurfaceCapabilities2KHR_CMockIgnoreArg_pSurfaceInfo(__LINE__) +void vkGetPhysicalDeviceSurfaceCapabilities2KHR_CMockIgnoreArg_pSurfaceInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSurfaceCapabilities2KHR_IgnoreArg_pSurfaceCapabilities() vkGetPhysicalDeviceSurfaceCapabilities2KHR_CMockIgnoreArg_pSurfaceCapabilities(__LINE__) +void vkGetPhysicalDeviceSurfaceCapabilities2KHR_CMockIgnoreArg_pSurfaceCapabilities(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSurfaceFormats2KHR_IgnoreAndReturn(cmock_retval) vkGetPhysicalDeviceSurfaceFormats2KHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceSurfaceFormats2KHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceSurfaceFormats2KHR_StopIgnore() vkGetPhysicalDeviceSurfaceFormats2KHR_CMockStopIgnore() +void vkGetPhysicalDeviceSurfaceFormats2KHR_CMockStopIgnore(void); +#define vkGetPhysicalDeviceSurfaceFormats2KHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetPhysicalDeviceSurfaceFormats2KHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceSurfaceFormats2KHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceSurfaceFormats2KHR_ExpectAndReturn(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats, cmock_retval) vkGetPhysicalDeviceSurfaceFormats2KHR_CMockExpectAndReturn(__LINE__, physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats, cmock_retval) +void vkGetPhysicalDeviceSurfaceFormats2KHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALLBACK)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats, int cmock_num_calls); +void vkGetPhysicalDeviceSurfaceFormats2KHR_AddCallback(CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALLBACK Callback); +void vkGetPhysicalDeviceSurfaceFormats2KHR_Stub(CMOCK_vkGetPhysicalDeviceSurfaceFormats2KHR_CALLBACK Callback); +#define vkGetPhysicalDeviceSurfaceFormats2KHR_StubWithCallback vkGetPhysicalDeviceSurfaceFormats2KHR_AddCallback +#define vkGetPhysicalDeviceSurfaceFormats2KHR_ReturnThruPtr_pSurfaceFormatCount(pSurfaceFormatCount) vkGetPhysicalDeviceSurfaceFormats2KHR_CMockReturnMemThruPtr_pSurfaceFormatCount(__LINE__, pSurfaceFormatCount, sizeof(uint32_t)) +#define vkGetPhysicalDeviceSurfaceFormats2KHR_ReturnArrayThruPtr_pSurfaceFormatCount(pSurfaceFormatCount, cmock_len) vkGetPhysicalDeviceSurfaceFormats2KHR_CMockReturnMemThruPtr_pSurfaceFormatCount(__LINE__, pSurfaceFormatCount, cmock_len * sizeof(*pSurfaceFormatCount)) +#define vkGetPhysicalDeviceSurfaceFormats2KHR_ReturnMemThruPtr_pSurfaceFormatCount(pSurfaceFormatCount, cmock_size) vkGetPhysicalDeviceSurfaceFormats2KHR_CMockReturnMemThruPtr_pSurfaceFormatCount(__LINE__, pSurfaceFormatCount, cmock_size) +void vkGetPhysicalDeviceSurfaceFormats2KHR_CMockReturnMemThruPtr_pSurfaceFormatCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pSurfaceFormatCount, size_t cmock_size); +#define vkGetPhysicalDeviceSurfaceFormats2KHR_ReturnThruPtr_pSurfaceFormats(pSurfaceFormats) vkGetPhysicalDeviceSurfaceFormats2KHR_CMockReturnMemThruPtr_pSurfaceFormats(__LINE__, pSurfaceFormats, sizeof(VkSurfaceFormat2KHR)) +#define vkGetPhysicalDeviceSurfaceFormats2KHR_ReturnArrayThruPtr_pSurfaceFormats(pSurfaceFormats, cmock_len) vkGetPhysicalDeviceSurfaceFormats2KHR_CMockReturnMemThruPtr_pSurfaceFormats(__LINE__, pSurfaceFormats, cmock_len * sizeof(*pSurfaceFormats)) +#define vkGetPhysicalDeviceSurfaceFormats2KHR_ReturnMemThruPtr_pSurfaceFormats(pSurfaceFormats, cmock_size) vkGetPhysicalDeviceSurfaceFormats2KHR_CMockReturnMemThruPtr_pSurfaceFormats(__LINE__, pSurfaceFormats, cmock_size) +void vkGetPhysicalDeviceSurfaceFormats2KHR_CMockReturnMemThruPtr_pSurfaceFormats(UNITY_LINE_TYPE cmock_line, VkSurfaceFormat2KHR const* pSurfaceFormats, size_t cmock_size); +#define vkGetPhysicalDeviceSurfaceFormats2KHR_IgnoreArg_physicalDevice() vkGetPhysicalDeviceSurfaceFormats2KHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceSurfaceFormats2KHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSurfaceFormats2KHR_IgnoreArg_pSurfaceInfo() vkGetPhysicalDeviceSurfaceFormats2KHR_CMockIgnoreArg_pSurfaceInfo(__LINE__) +void vkGetPhysicalDeviceSurfaceFormats2KHR_CMockIgnoreArg_pSurfaceInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSurfaceFormats2KHR_IgnoreArg_pSurfaceFormatCount() vkGetPhysicalDeviceSurfaceFormats2KHR_CMockIgnoreArg_pSurfaceFormatCount(__LINE__) +void vkGetPhysicalDeviceSurfaceFormats2KHR_CMockIgnoreArg_pSurfaceFormatCount(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSurfaceFormats2KHR_IgnoreArg_pSurfaceFormats() vkGetPhysicalDeviceSurfaceFormats2KHR_CMockIgnoreArg_pSurfaceFormats(__LINE__) +void vkGetPhysicalDeviceSurfaceFormats2KHR_CMockIgnoreArg_pSurfaceFormats(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceDisplayProperties2KHR_IgnoreAndReturn(cmock_retval) vkGetPhysicalDeviceDisplayProperties2KHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceDisplayProperties2KHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceDisplayProperties2KHR_StopIgnore() vkGetPhysicalDeviceDisplayProperties2KHR_CMockStopIgnore() +void vkGetPhysicalDeviceDisplayProperties2KHR_CMockStopIgnore(void); +#define vkGetPhysicalDeviceDisplayProperties2KHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetPhysicalDeviceDisplayProperties2KHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceDisplayProperties2KHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceDisplayProperties2KHR_ExpectAndReturn(physicalDevice, pPropertyCount, pProperties, cmock_retval) vkGetPhysicalDeviceDisplayProperties2KHR_CMockExpectAndReturn(__LINE__, physicalDevice, pPropertyCount, pProperties, cmock_retval) +void vkGetPhysicalDeviceDisplayProperties2KHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALLBACK)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties, int cmock_num_calls); +void vkGetPhysicalDeviceDisplayProperties2KHR_AddCallback(CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALLBACK Callback); +void vkGetPhysicalDeviceDisplayProperties2KHR_Stub(CMOCK_vkGetPhysicalDeviceDisplayProperties2KHR_CALLBACK Callback); +#define vkGetPhysicalDeviceDisplayProperties2KHR_StubWithCallback vkGetPhysicalDeviceDisplayProperties2KHR_AddCallback +#define vkGetPhysicalDeviceDisplayProperties2KHR_ReturnThruPtr_pPropertyCount(pPropertyCount) vkGetPhysicalDeviceDisplayProperties2KHR_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, sizeof(uint32_t)) +#define vkGetPhysicalDeviceDisplayProperties2KHR_ReturnArrayThruPtr_pPropertyCount(pPropertyCount, cmock_len) vkGetPhysicalDeviceDisplayProperties2KHR_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, cmock_len * sizeof(*pPropertyCount)) +#define vkGetPhysicalDeviceDisplayProperties2KHR_ReturnMemThruPtr_pPropertyCount(pPropertyCount, cmock_size) vkGetPhysicalDeviceDisplayProperties2KHR_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, cmock_size) +void vkGetPhysicalDeviceDisplayProperties2KHR_CMockReturnMemThruPtr_pPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPropertyCount, size_t cmock_size); +#define vkGetPhysicalDeviceDisplayProperties2KHR_ReturnThruPtr_pProperties(pProperties) vkGetPhysicalDeviceDisplayProperties2KHR_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, sizeof(VkDisplayProperties2KHR)) +#define vkGetPhysicalDeviceDisplayProperties2KHR_ReturnArrayThruPtr_pProperties(pProperties, cmock_len) vkGetPhysicalDeviceDisplayProperties2KHR_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_len * sizeof(*pProperties)) +#define vkGetPhysicalDeviceDisplayProperties2KHR_ReturnMemThruPtr_pProperties(pProperties, cmock_size) vkGetPhysicalDeviceDisplayProperties2KHR_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_size) +void vkGetPhysicalDeviceDisplayProperties2KHR_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkDisplayProperties2KHR const* pProperties, size_t cmock_size); +#define vkGetPhysicalDeviceDisplayProperties2KHR_IgnoreArg_physicalDevice() vkGetPhysicalDeviceDisplayProperties2KHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceDisplayProperties2KHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceDisplayProperties2KHR_IgnoreArg_pPropertyCount() vkGetPhysicalDeviceDisplayProperties2KHR_CMockIgnoreArg_pPropertyCount(__LINE__) +void vkGetPhysicalDeviceDisplayProperties2KHR_CMockIgnoreArg_pPropertyCount(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceDisplayProperties2KHR_IgnoreArg_pProperties() vkGetPhysicalDeviceDisplayProperties2KHR_CMockIgnoreArg_pProperties(__LINE__) +void vkGetPhysicalDeviceDisplayProperties2KHR_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceDisplayPlaneProperties2KHR_IgnoreAndReturn(cmock_retval) vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceDisplayPlaneProperties2KHR_StopIgnore() vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockStopIgnore() +void vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockStopIgnore(void); +#define vkGetPhysicalDeviceDisplayPlaneProperties2KHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceDisplayPlaneProperties2KHR_ExpectAndReturn(physicalDevice, pPropertyCount, pProperties, cmock_retval) vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockExpectAndReturn(__LINE__, physicalDevice, pPropertyCount, pProperties, cmock_retval) +void vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALLBACK)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties, int cmock_num_calls); +void vkGetPhysicalDeviceDisplayPlaneProperties2KHR_AddCallback(CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALLBACK Callback); +void vkGetPhysicalDeviceDisplayPlaneProperties2KHR_Stub(CMOCK_vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CALLBACK Callback); +#define vkGetPhysicalDeviceDisplayPlaneProperties2KHR_StubWithCallback vkGetPhysicalDeviceDisplayPlaneProperties2KHR_AddCallback +#define vkGetPhysicalDeviceDisplayPlaneProperties2KHR_ReturnThruPtr_pPropertyCount(pPropertyCount) vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, sizeof(uint32_t)) +#define vkGetPhysicalDeviceDisplayPlaneProperties2KHR_ReturnArrayThruPtr_pPropertyCount(pPropertyCount, cmock_len) vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, cmock_len * sizeof(*pPropertyCount)) +#define vkGetPhysicalDeviceDisplayPlaneProperties2KHR_ReturnMemThruPtr_pPropertyCount(pPropertyCount, cmock_size) vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, cmock_size) +void vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockReturnMemThruPtr_pPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPropertyCount, size_t cmock_size); +#define vkGetPhysicalDeviceDisplayPlaneProperties2KHR_ReturnThruPtr_pProperties(pProperties) vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, sizeof(VkDisplayPlaneProperties2KHR)) +#define vkGetPhysicalDeviceDisplayPlaneProperties2KHR_ReturnArrayThruPtr_pProperties(pProperties, cmock_len) vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_len * sizeof(*pProperties)) +#define vkGetPhysicalDeviceDisplayPlaneProperties2KHR_ReturnMemThruPtr_pProperties(pProperties, cmock_size) vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_size) +void vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkDisplayPlaneProperties2KHR const* pProperties, size_t cmock_size); +#define vkGetPhysicalDeviceDisplayPlaneProperties2KHR_IgnoreArg_physicalDevice() vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceDisplayPlaneProperties2KHR_IgnoreArg_pPropertyCount() vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockIgnoreArg_pPropertyCount(__LINE__) +void vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockIgnoreArg_pPropertyCount(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceDisplayPlaneProperties2KHR_IgnoreArg_pProperties() vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockIgnoreArg_pProperties(__LINE__) +void vkGetPhysicalDeviceDisplayPlaneProperties2KHR_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetDisplayModeProperties2KHR_IgnoreAndReturn(cmock_retval) vkGetDisplayModeProperties2KHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetDisplayModeProperties2KHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetDisplayModeProperties2KHR_StopIgnore() vkGetDisplayModeProperties2KHR_CMockStopIgnore() +void vkGetDisplayModeProperties2KHR_CMockStopIgnore(void); +#define vkGetDisplayModeProperties2KHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetDisplayModeProperties2KHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetDisplayModeProperties2KHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetDisplayModeProperties2KHR_ExpectAndReturn(physicalDevice, display, pPropertyCount, pProperties, cmock_retval) vkGetDisplayModeProperties2KHR_CMockExpectAndReturn(__LINE__, physicalDevice, display, pPropertyCount, pProperties, cmock_retval) +void vkGetDisplayModeProperties2KHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetDisplayModeProperties2KHR_CALLBACK)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties, int cmock_num_calls); +void vkGetDisplayModeProperties2KHR_AddCallback(CMOCK_vkGetDisplayModeProperties2KHR_CALLBACK Callback); +void vkGetDisplayModeProperties2KHR_Stub(CMOCK_vkGetDisplayModeProperties2KHR_CALLBACK Callback); +#define vkGetDisplayModeProperties2KHR_StubWithCallback vkGetDisplayModeProperties2KHR_AddCallback +#define vkGetDisplayModeProperties2KHR_ReturnThruPtr_pPropertyCount(pPropertyCount) vkGetDisplayModeProperties2KHR_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, sizeof(uint32_t)) +#define vkGetDisplayModeProperties2KHR_ReturnArrayThruPtr_pPropertyCount(pPropertyCount, cmock_len) vkGetDisplayModeProperties2KHR_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, cmock_len * sizeof(*pPropertyCount)) +#define vkGetDisplayModeProperties2KHR_ReturnMemThruPtr_pPropertyCount(pPropertyCount, cmock_size) vkGetDisplayModeProperties2KHR_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, cmock_size) +void vkGetDisplayModeProperties2KHR_CMockReturnMemThruPtr_pPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPropertyCount, size_t cmock_size); +#define vkGetDisplayModeProperties2KHR_ReturnThruPtr_pProperties(pProperties) vkGetDisplayModeProperties2KHR_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, sizeof(VkDisplayModeProperties2KHR)) +#define vkGetDisplayModeProperties2KHR_ReturnArrayThruPtr_pProperties(pProperties, cmock_len) vkGetDisplayModeProperties2KHR_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_len * sizeof(*pProperties)) +#define vkGetDisplayModeProperties2KHR_ReturnMemThruPtr_pProperties(pProperties, cmock_size) vkGetDisplayModeProperties2KHR_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_size) +void vkGetDisplayModeProperties2KHR_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkDisplayModeProperties2KHR const* pProperties, size_t cmock_size); +#define vkGetDisplayModeProperties2KHR_IgnoreArg_physicalDevice() vkGetDisplayModeProperties2KHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetDisplayModeProperties2KHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetDisplayModeProperties2KHR_IgnoreArg_display() vkGetDisplayModeProperties2KHR_CMockIgnoreArg_display(__LINE__) +void vkGetDisplayModeProperties2KHR_CMockIgnoreArg_display(UNITY_LINE_TYPE cmock_line); +#define vkGetDisplayModeProperties2KHR_IgnoreArg_pPropertyCount() vkGetDisplayModeProperties2KHR_CMockIgnoreArg_pPropertyCount(__LINE__) +void vkGetDisplayModeProperties2KHR_CMockIgnoreArg_pPropertyCount(UNITY_LINE_TYPE cmock_line); +#define vkGetDisplayModeProperties2KHR_IgnoreArg_pProperties() vkGetDisplayModeProperties2KHR_CMockIgnoreArg_pProperties(__LINE__) +void vkGetDisplayModeProperties2KHR_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetDisplayPlaneCapabilities2KHR_IgnoreAndReturn(cmock_retval) vkGetDisplayPlaneCapabilities2KHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetDisplayPlaneCapabilities2KHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetDisplayPlaneCapabilities2KHR_StopIgnore() vkGetDisplayPlaneCapabilities2KHR_CMockStopIgnore() +void vkGetDisplayPlaneCapabilities2KHR_CMockStopIgnore(void); +#define vkGetDisplayPlaneCapabilities2KHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetDisplayPlaneCapabilities2KHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetDisplayPlaneCapabilities2KHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetDisplayPlaneCapabilities2KHR_ExpectAndReturn(physicalDevice, pDisplayPlaneInfo, pCapabilities, cmock_retval) vkGetDisplayPlaneCapabilities2KHR_CMockExpectAndReturn(__LINE__, physicalDevice, pDisplayPlaneInfo, pCapabilities, cmock_retval) +void vkGetDisplayPlaneCapabilities2KHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetDisplayPlaneCapabilities2KHR_CALLBACK)(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities, int cmock_num_calls); +void vkGetDisplayPlaneCapabilities2KHR_AddCallback(CMOCK_vkGetDisplayPlaneCapabilities2KHR_CALLBACK Callback); +void vkGetDisplayPlaneCapabilities2KHR_Stub(CMOCK_vkGetDisplayPlaneCapabilities2KHR_CALLBACK Callback); +#define vkGetDisplayPlaneCapabilities2KHR_StubWithCallback vkGetDisplayPlaneCapabilities2KHR_AddCallback +#define vkGetDisplayPlaneCapabilities2KHR_ReturnThruPtr_pCapabilities(pCapabilities) vkGetDisplayPlaneCapabilities2KHR_CMockReturnMemThruPtr_pCapabilities(__LINE__, pCapabilities, sizeof(VkDisplayPlaneCapabilities2KHR)) +#define vkGetDisplayPlaneCapabilities2KHR_ReturnArrayThruPtr_pCapabilities(pCapabilities, cmock_len) vkGetDisplayPlaneCapabilities2KHR_CMockReturnMemThruPtr_pCapabilities(__LINE__, pCapabilities, cmock_len * sizeof(*pCapabilities)) +#define vkGetDisplayPlaneCapabilities2KHR_ReturnMemThruPtr_pCapabilities(pCapabilities, cmock_size) vkGetDisplayPlaneCapabilities2KHR_CMockReturnMemThruPtr_pCapabilities(__LINE__, pCapabilities, cmock_size) +void vkGetDisplayPlaneCapabilities2KHR_CMockReturnMemThruPtr_pCapabilities(UNITY_LINE_TYPE cmock_line, VkDisplayPlaneCapabilities2KHR const* pCapabilities, size_t cmock_size); +#define vkGetDisplayPlaneCapabilities2KHR_IgnoreArg_physicalDevice() vkGetDisplayPlaneCapabilities2KHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetDisplayPlaneCapabilities2KHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetDisplayPlaneCapabilities2KHR_IgnoreArg_pDisplayPlaneInfo() vkGetDisplayPlaneCapabilities2KHR_CMockIgnoreArg_pDisplayPlaneInfo(__LINE__) +void vkGetDisplayPlaneCapabilities2KHR_CMockIgnoreArg_pDisplayPlaneInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetDisplayPlaneCapabilities2KHR_IgnoreArg_pCapabilities() vkGetDisplayPlaneCapabilities2KHR_CMockIgnoreArg_pCapabilities(__LINE__) +void vkGetDisplayPlaneCapabilities2KHR_CMockIgnoreArg_pCapabilities(UNITY_LINE_TYPE cmock_line); +#define vkGetImageMemoryRequirements2KHR_Ignore() vkGetImageMemoryRequirements2KHR_CMockIgnore() +void vkGetImageMemoryRequirements2KHR_CMockIgnore(void); +#define vkGetImageMemoryRequirements2KHR_StopIgnore() vkGetImageMemoryRequirements2KHR_CMockStopIgnore() +void vkGetImageMemoryRequirements2KHR_CMockStopIgnore(void); +#define vkGetImageMemoryRequirements2KHR_ExpectAnyArgs() vkGetImageMemoryRequirements2KHR_CMockExpectAnyArgs(__LINE__) +void vkGetImageMemoryRequirements2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetImageMemoryRequirements2KHR_Expect(device, pInfo, pMemoryRequirements) vkGetImageMemoryRequirements2KHR_CMockExpect(__LINE__, device, pInfo, pMemoryRequirements) +void vkGetImageMemoryRequirements2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (* CMOCK_vkGetImageMemoryRequirements2KHR_CALLBACK)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements, int cmock_num_calls); +void vkGetImageMemoryRequirements2KHR_AddCallback(CMOCK_vkGetImageMemoryRequirements2KHR_CALLBACK Callback); +void vkGetImageMemoryRequirements2KHR_Stub(CMOCK_vkGetImageMemoryRequirements2KHR_CALLBACK Callback); +#define vkGetImageMemoryRequirements2KHR_StubWithCallback vkGetImageMemoryRequirements2KHR_AddCallback +#define vkGetImageMemoryRequirements2KHR_ReturnThruPtr_pMemoryRequirements(pMemoryRequirements) vkGetImageMemoryRequirements2KHR_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, sizeof(VkMemoryRequirements2)) +#define vkGetImageMemoryRequirements2KHR_ReturnArrayThruPtr_pMemoryRequirements(pMemoryRequirements, cmock_len) vkGetImageMemoryRequirements2KHR_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, cmock_len * sizeof(*pMemoryRequirements)) +#define vkGetImageMemoryRequirements2KHR_ReturnMemThruPtr_pMemoryRequirements(pMemoryRequirements, cmock_size) vkGetImageMemoryRequirements2KHR_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, cmock_size) +void vkGetImageMemoryRequirements2KHR_CMockReturnMemThruPtr_pMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkMemoryRequirements2 const* pMemoryRequirements, size_t cmock_size); +#define vkGetImageMemoryRequirements2KHR_IgnoreArg_device() vkGetImageMemoryRequirements2KHR_CMockIgnoreArg_device(__LINE__) +void vkGetImageMemoryRequirements2KHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetImageMemoryRequirements2KHR_IgnoreArg_pInfo() vkGetImageMemoryRequirements2KHR_CMockIgnoreArg_pInfo(__LINE__) +void vkGetImageMemoryRequirements2KHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetImageMemoryRequirements2KHR_IgnoreArg_pMemoryRequirements() vkGetImageMemoryRequirements2KHR_CMockIgnoreArg_pMemoryRequirements(__LINE__) +void vkGetImageMemoryRequirements2KHR_CMockIgnoreArg_pMemoryRequirements(UNITY_LINE_TYPE cmock_line); +#define vkGetBufferMemoryRequirements2KHR_Ignore() vkGetBufferMemoryRequirements2KHR_CMockIgnore() +void vkGetBufferMemoryRequirements2KHR_CMockIgnore(void); +#define vkGetBufferMemoryRequirements2KHR_StopIgnore() vkGetBufferMemoryRequirements2KHR_CMockStopIgnore() +void vkGetBufferMemoryRequirements2KHR_CMockStopIgnore(void); +#define vkGetBufferMemoryRequirements2KHR_ExpectAnyArgs() vkGetBufferMemoryRequirements2KHR_CMockExpectAnyArgs(__LINE__) +void vkGetBufferMemoryRequirements2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetBufferMemoryRequirements2KHR_Expect(device, pInfo, pMemoryRequirements) vkGetBufferMemoryRequirements2KHR_CMockExpect(__LINE__, device, pInfo, pMemoryRequirements) +void vkGetBufferMemoryRequirements2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (* CMOCK_vkGetBufferMemoryRequirements2KHR_CALLBACK)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements, int cmock_num_calls); +void vkGetBufferMemoryRequirements2KHR_AddCallback(CMOCK_vkGetBufferMemoryRequirements2KHR_CALLBACK Callback); +void vkGetBufferMemoryRequirements2KHR_Stub(CMOCK_vkGetBufferMemoryRequirements2KHR_CALLBACK Callback); +#define vkGetBufferMemoryRequirements2KHR_StubWithCallback vkGetBufferMemoryRequirements2KHR_AddCallback +#define vkGetBufferMemoryRequirements2KHR_ReturnThruPtr_pMemoryRequirements(pMemoryRequirements) vkGetBufferMemoryRequirements2KHR_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, sizeof(VkMemoryRequirements2)) +#define vkGetBufferMemoryRequirements2KHR_ReturnArrayThruPtr_pMemoryRequirements(pMemoryRequirements, cmock_len) vkGetBufferMemoryRequirements2KHR_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, cmock_len * sizeof(*pMemoryRequirements)) +#define vkGetBufferMemoryRequirements2KHR_ReturnMemThruPtr_pMemoryRequirements(pMemoryRequirements, cmock_size) vkGetBufferMemoryRequirements2KHR_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, cmock_size) +void vkGetBufferMemoryRequirements2KHR_CMockReturnMemThruPtr_pMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkMemoryRequirements2 const* pMemoryRequirements, size_t cmock_size); +#define vkGetBufferMemoryRequirements2KHR_IgnoreArg_device() vkGetBufferMemoryRequirements2KHR_CMockIgnoreArg_device(__LINE__) +void vkGetBufferMemoryRequirements2KHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetBufferMemoryRequirements2KHR_IgnoreArg_pInfo() vkGetBufferMemoryRequirements2KHR_CMockIgnoreArg_pInfo(__LINE__) +void vkGetBufferMemoryRequirements2KHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetBufferMemoryRequirements2KHR_IgnoreArg_pMemoryRequirements() vkGetBufferMemoryRequirements2KHR_CMockIgnoreArg_pMemoryRequirements(__LINE__) +void vkGetBufferMemoryRequirements2KHR_CMockIgnoreArg_pMemoryRequirements(UNITY_LINE_TYPE cmock_line); +#define vkGetImageSparseMemoryRequirements2KHR_Ignore() vkGetImageSparseMemoryRequirements2KHR_CMockIgnore() +void vkGetImageSparseMemoryRequirements2KHR_CMockIgnore(void); +#define vkGetImageSparseMemoryRequirements2KHR_StopIgnore() vkGetImageSparseMemoryRequirements2KHR_CMockStopIgnore() +void vkGetImageSparseMemoryRequirements2KHR_CMockStopIgnore(void); +#define vkGetImageSparseMemoryRequirements2KHR_ExpectAnyArgs() vkGetImageSparseMemoryRequirements2KHR_CMockExpectAnyArgs(__LINE__) +void vkGetImageSparseMemoryRequirements2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetImageSparseMemoryRequirements2KHR_Expect(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements) vkGetImageSparseMemoryRequirements2KHR_CMockExpect(__LINE__, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements) +void vkGetImageSparseMemoryRequirements2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +typedef void (* CMOCK_vkGetImageSparseMemoryRequirements2KHR_CALLBACK)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, int cmock_num_calls); +void vkGetImageSparseMemoryRequirements2KHR_AddCallback(CMOCK_vkGetImageSparseMemoryRequirements2KHR_CALLBACK Callback); +void vkGetImageSparseMemoryRequirements2KHR_Stub(CMOCK_vkGetImageSparseMemoryRequirements2KHR_CALLBACK Callback); +#define vkGetImageSparseMemoryRequirements2KHR_StubWithCallback vkGetImageSparseMemoryRequirements2KHR_AddCallback +#define vkGetImageSparseMemoryRequirements2KHR_ReturnThruPtr_pSparseMemoryRequirementCount(pSparseMemoryRequirementCount) vkGetImageSparseMemoryRequirements2KHR_CMockReturnMemThruPtr_pSparseMemoryRequirementCount(__LINE__, pSparseMemoryRequirementCount, sizeof(uint32_t)) +#define vkGetImageSparseMemoryRequirements2KHR_ReturnArrayThruPtr_pSparseMemoryRequirementCount(pSparseMemoryRequirementCount, cmock_len) vkGetImageSparseMemoryRequirements2KHR_CMockReturnMemThruPtr_pSparseMemoryRequirementCount(__LINE__, pSparseMemoryRequirementCount, cmock_len * sizeof(*pSparseMemoryRequirementCount)) +#define vkGetImageSparseMemoryRequirements2KHR_ReturnMemThruPtr_pSparseMemoryRequirementCount(pSparseMemoryRequirementCount, cmock_size) vkGetImageSparseMemoryRequirements2KHR_CMockReturnMemThruPtr_pSparseMemoryRequirementCount(__LINE__, pSparseMemoryRequirementCount, cmock_size) +void vkGetImageSparseMemoryRequirements2KHR_CMockReturnMemThruPtr_pSparseMemoryRequirementCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pSparseMemoryRequirementCount, size_t cmock_size); +#define vkGetImageSparseMemoryRequirements2KHR_ReturnThruPtr_pSparseMemoryRequirements(pSparseMemoryRequirements) vkGetImageSparseMemoryRequirements2KHR_CMockReturnMemThruPtr_pSparseMemoryRequirements(__LINE__, pSparseMemoryRequirements, sizeof(VkSparseImageMemoryRequirements2)) +#define vkGetImageSparseMemoryRequirements2KHR_ReturnArrayThruPtr_pSparseMemoryRequirements(pSparseMemoryRequirements, cmock_len) vkGetImageSparseMemoryRequirements2KHR_CMockReturnMemThruPtr_pSparseMemoryRequirements(__LINE__, pSparseMemoryRequirements, cmock_len * sizeof(*pSparseMemoryRequirements)) +#define vkGetImageSparseMemoryRequirements2KHR_ReturnMemThruPtr_pSparseMemoryRequirements(pSparseMemoryRequirements, cmock_size) vkGetImageSparseMemoryRequirements2KHR_CMockReturnMemThruPtr_pSparseMemoryRequirements(__LINE__, pSparseMemoryRequirements, cmock_size) +void vkGetImageSparseMemoryRequirements2KHR_CMockReturnMemThruPtr_pSparseMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkSparseImageMemoryRequirements2 const* pSparseMemoryRequirements, size_t cmock_size); +#define vkGetImageSparseMemoryRequirements2KHR_IgnoreArg_device() vkGetImageSparseMemoryRequirements2KHR_CMockIgnoreArg_device(__LINE__) +void vkGetImageSparseMemoryRequirements2KHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetImageSparseMemoryRequirements2KHR_IgnoreArg_pInfo() vkGetImageSparseMemoryRequirements2KHR_CMockIgnoreArg_pInfo(__LINE__) +void vkGetImageSparseMemoryRequirements2KHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetImageSparseMemoryRequirements2KHR_IgnoreArg_pSparseMemoryRequirementCount() vkGetImageSparseMemoryRequirements2KHR_CMockIgnoreArg_pSparseMemoryRequirementCount(__LINE__) +void vkGetImageSparseMemoryRequirements2KHR_CMockIgnoreArg_pSparseMemoryRequirementCount(UNITY_LINE_TYPE cmock_line); +#define vkGetImageSparseMemoryRequirements2KHR_IgnoreArg_pSparseMemoryRequirements() vkGetImageSparseMemoryRequirements2KHR_CMockIgnoreArg_pSparseMemoryRequirements(__LINE__) +void vkGetImageSparseMemoryRequirements2KHR_CMockIgnoreArg_pSparseMemoryRequirements(UNITY_LINE_TYPE cmock_line); +#define vkCreateSamplerYcbcrConversionKHR_IgnoreAndReturn(cmock_retval) vkCreateSamplerYcbcrConversionKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateSamplerYcbcrConversionKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateSamplerYcbcrConversionKHR_StopIgnore() vkCreateSamplerYcbcrConversionKHR_CMockStopIgnore() +void vkCreateSamplerYcbcrConversionKHR_CMockStopIgnore(void); +#define vkCreateSamplerYcbcrConversionKHR_ExpectAnyArgsAndReturn(cmock_retval) vkCreateSamplerYcbcrConversionKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateSamplerYcbcrConversionKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateSamplerYcbcrConversionKHR_ExpectAndReturn(device, pCreateInfo, pAllocator, pYcbcrConversion, cmock_retval) vkCreateSamplerYcbcrConversionKHR_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pYcbcrConversion, cmock_retval) +void vkCreateSamplerYcbcrConversionKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateSamplerYcbcrConversionKHR_CALLBACK)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion, int cmock_num_calls); +void vkCreateSamplerYcbcrConversionKHR_AddCallback(CMOCK_vkCreateSamplerYcbcrConversionKHR_CALLBACK Callback); +void vkCreateSamplerYcbcrConversionKHR_Stub(CMOCK_vkCreateSamplerYcbcrConversionKHR_CALLBACK Callback); +#define vkCreateSamplerYcbcrConversionKHR_StubWithCallback vkCreateSamplerYcbcrConversionKHR_AddCallback +#define vkCreateSamplerYcbcrConversionKHR_ReturnThruPtr_pYcbcrConversion(pYcbcrConversion) vkCreateSamplerYcbcrConversionKHR_CMockReturnMemThruPtr_pYcbcrConversion(__LINE__, pYcbcrConversion, sizeof(VkSamplerYcbcrConversion)) +#define vkCreateSamplerYcbcrConversionKHR_ReturnArrayThruPtr_pYcbcrConversion(pYcbcrConversion, cmock_len) vkCreateSamplerYcbcrConversionKHR_CMockReturnMemThruPtr_pYcbcrConversion(__LINE__, pYcbcrConversion, cmock_len * sizeof(*pYcbcrConversion)) +#define vkCreateSamplerYcbcrConversionKHR_ReturnMemThruPtr_pYcbcrConversion(pYcbcrConversion, cmock_size) vkCreateSamplerYcbcrConversionKHR_CMockReturnMemThruPtr_pYcbcrConversion(__LINE__, pYcbcrConversion, cmock_size) +void vkCreateSamplerYcbcrConversionKHR_CMockReturnMemThruPtr_pYcbcrConversion(UNITY_LINE_TYPE cmock_line, VkSamplerYcbcrConversion const* pYcbcrConversion, size_t cmock_size); +#define vkCreateSamplerYcbcrConversionKHR_IgnoreArg_device() vkCreateSamplerYcbcrConversionKHR_CMockIgnoreArg_device(__LINE__) +void vkCreateSamplerYcbcrConversionKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateSamplerYcbcrConversionKHR_IgnoreArg_pCreateInfo() vkCreateSamplerYcbcrConversionKHR_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateSamplerYcbcrConversionKHR_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateSamplerYcbcrConversionKHR_IgnoreArg_pAllocator() vkCreateSamplerYcbcrConversionKHR_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateSamplerYcbcrConversionKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateSamplerYcbcrConversionKHR_IgnoreArg_pYcbcrConversion() vkCreateSamplerYcbcrConversionKHR_CMockIgnoreArg_pYcbcrConversion(__LINE__) +void vkCreateSamplerYcbcrConversionKHR_CMockIgnoreArg_pYcbcrConversion(UNITY_LINE_TYPE cmock_line); +#define vkDestroySamplerYcbcrConversionKHR_Ignore() vkDestroySamplerYcbcrConversionKHR_CMockIgnore() +void vkDestroySamplerYcbcrConversionKHR_CMockIgnore(void); +#define vkDestroySamplerYcbcrConversionKHR_StopIgnore() vkDestroySamplerYcbcrConversionKHR_CMockStopIgnore() +void vkDestroySamplerYcbcrConversionKHR_CMockStopIgnore(void); +#define vkDestroySamplerYcbcrConversionKHR_ExpectAnyArgs() vkDestroySamplerYcbcrConversionKHR_CMockExpectAnyArgs(__LINE__) +void vkDestroySamplerYcbcrConversionKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroySamplerYcbcrConversionKHR_Expect(device, ycbcrConversion, pAllocator) vkDestroySamplerYcbcrConversionKHR_CMockExpect(__LINE__, device, ycbcrConversion, pAllocator) +void vkDestroySamplerYcbcrConversionKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroySamplerYcbcrConversionKHR_CALLBACK)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroySamplerYcbcrConversionKHR_AddCallback(CMOCK_vkDestroySamplerYcbcrConversionKHR_CALLBACK Callback); +void vkDestroySamplerYcbcrConversionKHR_Stub(CMOCK_vkDestroySamplerYcbcrConversionKHR_CALLBACK Callback); +#define vkDestroySamplerYcbcrConversionKHR_StubWithCallback vkDestroySamplerYcbcrConversionKHR_AddCallback +#define vkDestroySamplerYcbcrConversionKHR_IgnoreArg_device() vkDestroySamplerYcbcrConversionKHR_CMockIgnoreArg_device(__LINE__) +void vkDestroySamplerYcbcrConversionKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroySamplerYcbcrConversionKHR_IgnoreArg_ycbcrConversion() vkDestroySamplerYcbcrConversionKHR_CMockIgnoreArg_ycbcrConversion(__LINE__) +void vkDestroySamplerYcbcrConversionKHR_CMockIgnoreArg_ycbcrConversion(UNITY_LINE_TYPE cmock_line); +#define vkDestroySamplerYcbcrConversionKHR_IgnoreArg_pAllocator() vkDestroySamplerYcbcrConversionKHR_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroySamplerYcbcrConversionKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkBindBufferMemory2KHR_IgnoreAndReturn(cmock_retval) vkBindBufferMemory2KHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkBindBufferMemory2KHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkBindBufferMemory2KHR_StopIgnore() vkBindBufferMemory2KHR_CMockStopIgnore() +void vkBindBufferMemory2KHR_CMockStopIgnore(void); +#define vkBindBufferMemory2KHR_ExpectAnyArgsAndReturn(cmock_retval) vkBindBufferMemory2KHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkBindBufferMemory2KHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkBindBufferMemory2KHR_ExpectAndReturn(device, bindInfoCount, pBindInfos, cmock_retval) vkBindBufferMemory2KHR_CMockExpectAndReturn(__LINE__, device, bindInfoCount, pBindInfos, cmock_retval) +void vkBindBufferMemory2KHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkBindBufferMemory2KHR_CALLBACK)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos, int cmock_num_calls); +void vkBindBufferMemory2KHR_AddCallback(CMOCK_vkBindBufferMemory2KHR_CALLBACK Callback); +void vkBindBufferMemory2KHR_Stub(CMOCK_vkBindBufferMemory2KHR_CALLBACK Callback); +#define vkBindBufferMemory2KHR_StubWithCallback vkBindBufferMemory2KHR_AddCallback +#define vkBindBufferMemory2KHR_IgnoreArg_device() vkBindBufferMemory2KHR_CMockIgnoreArg_device(__LINE__) +void vkBindBufferMemory2KHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkBindBufferMemory2KHR_IgnoreArg_bindInfoCount() vkBindBufferMemory2KHR_CMockIgnoreArg_bindInfoCount(__LINE__) +void vkBindBufferMemory2KHR_CMockIgnoreArg_bindInfoCount(UNITY_LINE_TYPE cmock_line); +#define vkBindBufferMemory2KHR_IgnoreArg_pBindInfos() vkBindBufferMemory2KHR_CMockIgnoreArg_pBindInfos(__LINE__) +void vkBindBufferMemory2KHR_CMockIgnoreArg_pBindInfos(UNITY_LINE_TYPE cmock_line); +#define vkBindImageMemory2KHR_IgnoreAndReturn(cmock_retval) vkBindImageMemory2KHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkBindImageMemory2KHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkBindImageMemory2KHR_StopIgnore() vkBindImageMemory2KHR_CMockStopIgnore() +void vkBindImageMemory2KHR_CMockStopIgnore(void); +#define vkBindImageMemory2KHR_ExpectAnyArgsAndReturn(cmock_retval) vkBindImageMemory2KHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkBindImageMemory2KHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkBindImageMemory2KHR_ExpectAndReturn(device, bindInfoCount, pBindInfos, cmock_retval) vkBindImageMemory2KHR_CMockExpectAndReturn(__LINE__, device, bindInfoCount, pBindInfos, cmock_retval) +void vkBindImageMemory2KHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkBindImageMemory2KHR_CALLBACK)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos, int cmock_num_calls); +void vkBindImageMemory2KHR_AddCallback(CMOCK_vkBindImageMemory2KHR_CALLBACK Callback); +void vkBindImageMemory2KHR_Stub(CMOCK_vkBindImageMemory2KHR_CALLBACK Callback); +#define vkBindImageMemory2KHR_StubWithCallback vkBindImageMemory2KHR_AddCallback +#define vkBindImageMemory2KHR_IgnoreArg_device() vkBindImageMemory2KHR_CMockIgnoreArg_device(__LINE__) +void vkBindImageMemory2KHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkBindImageMemory2KHR_IgnoreArg_bindInfoCount() vkBindImageMemory2KHR_CMockIgnoreArg_bindInfoCount(__LINE__) +void vkBindImageMemory2KHR_CMockIgnoreArg_bindInfoCount(UNITY_LINE_TYPE cmock_line); +#define vkBindImageMemory2KHR_IgnoreArg_pBindInfos() vkBindImageMemory2KHR_CMockIgnoreArg_pBindInfos(__LINE__) +void vkBindImageMemory2KHR_CMockIgnoreArg_pBindInfos(UNITY_LINE_TYPE cmock_line); +#define vkGetDescriptorSetLayoutSupportKHR_Ignore() vkGetDescriptorSetLayoutSupportKHR_CMockIgnore() +void vkGetDescriptorSetLayoutSupportKHR_CMockIgnore(void); +#define vkGetDescriptorSetLayoutSupportKHR_StopIgnore() vkGetDescriptorSetLayoutSupportKHR_CMockStopIgnore() +void vkGetDescriptorSetLayoutSupportKHR_CMockStopIgnore(void); +#define vkGetDescriptorSetLayoutSupportKHR_ExpectAnyArgs() vkGetDescriptorSetLayoutSupportKHR_CMockExpectAnyArgs(__LINE__) +void vkGetDescriptorSetLayoutSupportKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetDescriptorSetLayoutSupportKHR_Expect(device, pCreateInfo, pSupport) vkGetDescriptorSetLayoutSupportKHR_CMockExpect(__LINE__, device, pCreateInfo, pSupport) +void vkGetDescriptorSetLayoutSupportKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); +typedef void (* CMOCK_vkGetDescriptorSetLayoutSupportKHR_CALLBACK)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport, int cmock_num_calls); +void vkGetDescriptorSetLayoutSupportKHR_AddCallback(CMOCK_vkGetDescriptorSetLayoutSupportKHR_CALLBACK Callback); +void vkGetDescriptorSetLayoutSupportKHR_Stub(CMOCK_vkGetDescriptorSetLayoutSupportKHR_CALLBACK Callback); +#define vkGetDescriptorSetLayoutSupportKHR_StubWithCallback vkGetDescriptorSetLayoutSupportKHR_AddCallback +#define vkGetDescriptorSetLayoutSupportKHR_ReturnThruPtr_pSupport(pSupport) vkGetDescriptorSetLayoutSupportKHR_CMockReturnMemThruPtr_pSupport(__LINE__, pSupport, sizeof(VkDescriptorSetLayoutSupport)) +#define vkGetDescriptorSetLayoutSupportKHR_ReturnArrayThruPtr_pSupport(pSupport, cmock_len) vkGetDescriptorSetLayoutSupportKHR_CMockReturnMemThruPtr_pSupport(__LINE__, pSupport, cmock_len * sizeof(*pSupport)) +#define vkGetDescriptorSetLayoutSupportKHR_ReturnMemThruPtr_pSupport(pSupport, cmock_size) vkGetDescriptorSetLayoutSupportKHR_CMockReturnMemThruPtr_pSupport(__LINE__, pSupport, cmock_size) +void vkGetDescriptorSetLayoutSupportKHR_CMockReturnMemThruPtr_pSupport(UNITY_LINE_TYPE cmock_line, VkDescriptorSetLayoutSupport const* pSupport, size_t cmock_size); +#define vkGetDescriptorSetLayoutSupportKHR_IgnoreArg_device() vkGetDescriptorSetLayoutSupportKHR_CMockIgnoreArg_device(__LINE__) +void vkGetDescriptorSetLayoutSupportKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetDescriptorSetLayoutSupportKHR_IgnoreArg_pCreateInfo() vkGetDescriptorSetLayoutSupportKHR_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkGetDescriptorSetLayoutSupportKHR_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetDescriptorSetLayoutSupportKHR_IgnoreArg_pSupport() vkGetDescriptorSetLayoutSupportKHR_CMockIgnoreArg_pSupport(__LINE__) +void vkGetDescriptorSetLayoutSupportKHR_CMockIgnoreArg_pSupport(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectCountKHR_Ignore() vkCmdDrawIndirectCountKHR_CMockIgnore() +void vkCmdDrawIndirectCountKHR_CMockIgnore(void); +#define vkCmdDrawIndirectCountKHR_StopIgnore() vkCmdDrawIndirectCountKHR_CMockStopIgnore() +void vkCmdDrawIndirectCountKHR_CMockStopIgnore(void); +#define vkCmdDrawIndirectCountKHR_ExpectAnyArgs() vkCmdDrawIndirectCountKHR_CMockExpectAnyArgs(__LINE__) +void vkCmdDrawIndirectCountKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectCountKHR_Expect(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride) vkCmdDrawIndirectCountKHR_CMockExpect(__LINE__, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride) +void vkCmdDrawIndirectCountKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef void (* CMOCK_vkCmdDrawIndirectCountKHR_CALLBACK)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, int cmock_num_calls); +void vkCmdDrawIndirectCountKHR_AddCallback(CMOCK_vkCmdDrawIndirectCountKHR_CALLBACK Callback); +void vkCmdDrawIndirectCountKHR_Stub(CMOCK_vkCmdDrawIndirectCountKHR_CALLBACK Callback); +#define vkCmdDrawIndirectCountKHR_StubWithCallback vkCmdDrawIndirectCountKHR_AddCallback +#define vkCmdDrawIndirectCountKHR_IgnoreArg_commandBuffer() vkCmdDrawIndirectCountKHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDrawIndirectCountKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectCountKHR_IgnoreArg_buffer() vkCmdDrawIndirectCountKHR_CMockIgnoreArg_buffer(__LINE__) +void vkCmdDrawIndirectCountKHR_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectCountKHR_IgnoreArg_offset() vkCmdDrawIndirectCountKHR_CMockIgnoreArg_offset(__LINE__) +void vkCmdDrawIndirectCountKHR_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectCountKHR_IgnoreArg_countBuffer() vkCmdDrawIndirectCountKHR_CMockIgnoreArg_countBuffer(__LINE__) +void vkCmdDrawIndirectCountKHR_CMockIgnoreArg_countBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectCountKHR_IgnoreArg_countBufferOffset() vkCmdDrawIndirectCountKHR_CMockIgnoreArg_countBufferOffset(__LINE__) +void vkCmdDrawIndirectCountKHR_CMockIgnoreArg_countBufferOffset(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectCountKHR_IgnoreArg_maxDrawCount() vkCmdDrawIndirectCountKHR_CMockIgnoreArg_maxDrawCount(__LINE__) +void vkCmdDrawIndirectCountKHR_CMockIgnoreArg_maxDrawCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectCountKHR_IgnoreArg_stride() vkCmdDrawIndirectCountKHR_CMockIgnoreArg_stride(__LINE__) +void vkCmdDrawIndirectCountKHR_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexedIndirectCountKHR_Ignore() vkCmdDrawIndexedIndirectCountKHR_CMockIgnore() +void vkCmdDrawIndexedIndirectCountKHR_CMockIgnore(void); +#define vkCmdDrawIndexedIndirectCountKHR_StopIgnore() vkCmdDrawIndexedIndirectCountKHR_CMockStopIgnore() +void vkCmdDrawIndexedIndirectCountKHR_CMockStopIgnore(void); +#define vkCmdDrawIndexedIndirectCountKHR_ExpectAnyArgs() vkCmdDrawIndexedIndirectCountKHR_CMockExpectAnyArgs(__LINE__) +void vkCmdDrawIndexedIndirectCountKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexedIndirectCountKHR_Expect(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride) vkCmdDrawIndexedIndirectCountKHR_CMockExpect(__LINE__, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride) +void vkCmdDrawIndexedIndirectCountKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef void (* CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALLBACK)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, int cmock_num_calls); +void vkCmdDrawIndexedIndirectCountKHR_AddCallback(CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALLBACK Callback); +void vkCmdDrawIndexedIndirectCountKHR_Stub(CMOCK_vkCmdDrawIndexedIndirectCountKHR_CALLBACK Callback); +#define vkCmdDrawIndexedIndirectCountKHR_StubWithCallback vkCmdDrawIndexedIndirectCountKHR_AddCallback +#define vkCmdDrawIndexedIndirectCountKHR_IgnoreArg_commandBuffer() vkCmdDrawIndexedIndirectCountKHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDrawIndexedIndirectCountKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexedIndirectCountKHR_IgnoreArg_buffer() vkCmdDrawIndexedIndirectCountKHR_CMockIgnoreArg_buffer(__LINE__) +void vkCmdDrawIndexedIndirectCountKHR_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexedIndirectCountKHR_IgnoreArg_offset() vkCmdDrawIndexedIndirectCountKHR_CMockIgnoreArg_offset(__LINE__) +void vkCmdDrawIndexedIndirectCountKHR_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexedIndirectCountKHR_IgnoreArg_countBuffer() vkCmdDrawIndexedIndirectCountKHR_CMockIgnoreArg_countBuffer(__LINE__) +void vkCmdDrawIndexedIndirectCountKHR_CMockIgnoreArg_countBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexedIndirectCountKHR_IgnoreArg_countBufferOffset() vkCmdDrawIndexedIndirectCountKHR_CMockIgnoreArg_countBufferOffset(__LINE__) +void vkCmdDrawIndexedIndirectCountKHR_CMockIgnoreArg_countBufferOffset(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexedIndirectCountKHR_IgnoreArg_maxDrawCount() vkCmdDrawIndexedIndirectCountKHR_CMockIgnoreArg_maxDrawCount(__LINE__) +void vkCmdDrawIndexedIndirectCountKHR_CMockIgnoreArg_maxDrawCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexedIndirectCountKHR_IgnoreArg_stride() vkCmdDrawIndexedIndirectCountKHR_CMockIgnoreArg_stride(__LINE__) +void vkCmdDrawIndexedIndirectCountKHR_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line); +#define vkGetSemaphoreCounterValueKHR_IgnoreAndReturn(cmock_retval) vkGetSemaphoreCounterValueKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetSemaphoreCounterValueKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetSemaphoreCounterValueKHR_StopIgnore() vkGetSemaphoreCounterValueKHR_CMockStopIgnore() +void vkGetSemaphoreCounterValueKHR_CMockStopIgnore(void); +#define vkGetSemaphoreCounterValueKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetSemaphoreCounterValueKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetSemaphoreCounterValueKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetSemaphoreCounterValueKHR_ExpectAndReturn(device, semaphore, pValue, cmock_retval) vkGetSemaphoreCounterValueKHR_CMockExpectAndReturn(__LINE__, device, semaphore, pValue, cmock_retval) +void vkGetSemaphoreCounterValueKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSemaphore semaphore, uint64_t* pValue, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetSemaphoreCounterValueKHR_CALLBACK)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue, int cmock_num_calls); +void vkGetSemaphoreCounterValueKHR_AddCallback(CMOCK_vkGetSemaphoreCounterValueKHR_CALLBACK Callback); +void vkGetSemaphoreCounterValueKHR_Stub(CMOCK_vkGetSemaphoreCounterValueKHR_CALLBACK Callback); +#define vkGetSemaphoreCounterValueKHR_StubWithCallback vkGetSemaphoreCounterValueKHR_AddCallback +#define vkGetSemaphoreCounterValueKHR_ReturnThruPtr_pValue(pValue) vkGetSemaphoreCounterValueKHR_CMockReturnMemThruPtr_pValue(__LINE__, pValue, sizeof(uint64_t)) +#define vkGetSemaphoreCounterValueKHR_ReturnArrayThruPtr_pValue(pValue, cmock_len) vkGetSemaphoreCounterValueKHR_CMockReturnMemThruPtr_pValue(__LINE__, pValue, cmock_len * sizeof(*pValue)) +#define vkGetSemaphoreCounterValueKHR_ReturnMemThruPtr_pValue(pValue, cmock_size) vkGetSemaphoreCounterValueKHR_CMockReturnMemThruPtr_pValue(__LINE__, pValue, cmock_size) +void vkGetSemaphoreCounterValueKHR_CMockReturnMemThruPtr_pValue(UNITY_LINE_TYPE cmock_line, uint64_t const* pValue, size_t cmock_size); +#define vkGetSemaphoreCounterValueKHR_IgnoreArg_device() vkGetSemaphoreCounterValueKHR_CMockIgnoreArg_device(__LINE__) +void vkGetSemaphoreCounterValueKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetSemaphoreCounterValueKHR_IgnoreArg_semaphore() vkGetSemaphoreCounterValueKHR_CMockIgnoreArg_semaphore(__LINE__) +void vkGetSemaphoreCounterValueKHR_CMockIgnoreArg_semaphore(UNITY_LINE_TYPE cmock_line); +#define vkGetSemaphoreCounterValueKHR_IgnoreArg_pValue() vkGetSemaphoreCounterValueKHR_CMockIgnoreArg_pValue(__LINE__) +void vkGetSemaphoreCounterValueKHR_CMockIgnoreArg_pValue(UNITY_LINE_TYPE cmock_line); +#define vkWaitSemaphoresKHR_IgnoreAndReturn(cmock_retval) vkWaitSemaphoresKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkWaitSemaphoresKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkWaitSemaphoresKHR_StopIgnore() vkWaitSemaphoresKHR_CMockStopIgnore() +void vkWaitSemaphoresKHR_CMockStopIgnore(void); +#define vkWaitSemaphoresKHR_ExpectAnyArgsAndReturn(cmock_retval) vkWaitSemaphoresKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkWaitSemaphoresKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkWaitSemaphoresKHR_ExpectAndReturn(device, pWaitInfo, timeout, cmock_retval) vkWaitSemaphoresKHR_CMockExpectAndReturn(__LINE__, device, pWaitInfo, timeout, cmock_retval) +void vkWaitSemaphoresKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkWaitSemaphoresKHR_CALLBACK)(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout, int cmock_num_calls); +void vkWaitSemaphoresKHR_AddCallback(CMOCK_vkWaitSemaphoresKHR_CALLBACK Callback); +void vkWaitSemaphoresKHR_Stub(CMOCK_vkWaitSemaphoresKHR_CALLBACK Callback); +#define vkWaitSemaphoresKHR_StubWithCallback vkWaitSemaphoresKHR_AddCallback +#define vkWaitSemaphoresKHR_IgnoreArg_device() vkWaitSemaphoresKHR_CMockIgnoreArg_device(__LINE__) +void vkWaitSemaphoresKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkWaitSemaphoresKHR_IgnoreArg_pWaitInfo() vkWaitSemaphoresKHR_CMockIgnoreArg_pWaitInfo(__LINE__) +void vkWaitSemaphoresKHR_CMockIgnoreArg_pWaitInfo(UNITY_LINE_TYPE cmock_line); +#define vkWaitSemaphoresKHR_IgnoreArg_timeout() vkWaitSemaphoresKHR_CMockIgnoreArg_timeout(__LINE__) +void vkWaitSemaphoresKHR_CMockIgnoreArg_timeout(UNITY_LINE_TYPE cmock_line); +#define vkSignalSemaphoreKHR_IgnoreAndReturn(cmock_retval) vkSignalSemaphoreKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkSignalSemaphoreKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkSignalSemaphoreKHR_StopIgnore() vkSignalSemaphoreKHR_CMockStopIgnore() +void vkSignalSemaphoreKHR_CMockStopIgnore(void); +#define vkSignalSemaphoreKHR_ExpectAnyArgsAndReturn(cmock_retval) vkSignalSemaphoreKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkSignalSemaphoreKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkSignalSemaphoreKHR_ExpectAndReturn(device, pSignalInfo, cmock_retval) vkSignalSemaphoreKHR_CMockExpectAndReturn(__LINE__, device, pSignalInfo, cmock_retval) +void vkSignalSemaphoreKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkSignalSemaphoreKHR_CALLBACK)(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo, int cmock_num_calls); +void vkSignalSemaphoreKHR_AddCallback(CMOCK_vkSignalSemaphoreKHR_CALLBACK Callback); +void vkSignalSemaphoreKHR_Stub(CMOCK_vkSignalSemaphoreKHR_CALLBACK Callback); +#define vkSignalSemaphoreKHR_StubWithCallback vkSignalSemaphoreKHR_AddCallback +#define vkSignalSemaphoreKHR_IgnoreArg_device() vkSignalSemaphoreKHR_CMockIgnoreArg_device(__LINE__) +void vkSignalSemaphoreKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkSignalSemaphoreKHR_IgnoreArg_pSignalInfo() vkSignalSemaphoreKHR_CMockIgnoreArg_pSignalInfo(__LINE__) +void vkSignalSemaphoreKHR_CMockIgnoreArg_pSignalInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceFragmentShadingRatesKHR_IgnoreAndReturn(cmock_retval) vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceFragmentShadingRatesKHR_StopIgnore() vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockStopIgnore() +void vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockStopIgnore(void); +#define vkGetPhysicalDeviceFragmentShadingRatesKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceFragmentShadingRatesKHR_ExpectAndReturn(physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates, cmock_retval) vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockExpectAndReturn(__LINE__, physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates, cmock_retval) +void vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALLBACK)(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates, int cmock_num_calls); +void vkGetPhysicalDeviceFragmentShadingRatesKHR_AddCallback(CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALLBACK Callback); +void vkGetPhysicalDeviceFragmentShadingRatesKHR_Stub(CMOCK_vkGetPhysicalDeviceFragmentShadingRatesKHR_CALLBACK Callback); +#define vkGetPhysicalDeviceFragmentShadingRatesKHR_StubWithCallback vkGetPhysicalDeviceFragmentShadingRatesKHR_AddCallback +#define vkGetPhysicalDeviceFragmentShadingRatesKHR_ReturnThruPtr_pFragmentShadingRateCount(pFragmentShadingRateCount) vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockReturnMemThruPtr_pFragmentShadingRateCount(__LINE__, pFragmentShadingRateCount, sizeof(uint32_t)) +#define vkGetPhysicalDeviceFragmentShadingRatesKHR_ReturnArrayThruPtr_pFragmentShadingRateCount(pFragmentShadingRateCount, cmock_len) vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockReturnMemThruPtr_pFragmentShadingRateCount(__LINE__, pFragmentShadingRateCount, cmock_len * sizeof(*pFragmentShadingRateCount)) +#define vkGetPhysicalDeviceFragmentShadingRatesKHR_ReturnMemThruPtr_pFragmentShadingRateCount(pFragmentShadingRateCount, cmock_size) vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockReturnMemThruPtr_pFragmentShadingRateCount(__LINE__, pFragmentShadingRateCount, cmock_size) +void vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockReturnMemThruPtr_pFragmentShadingRateCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pFragmentShadingRateCount, size_t cmock_size); +#define vkGetPhysicalDeviceFragmentShadingRatesKHR_ReturnThruPtr_pFragmentShadingRates(pFragmentShadingRates) vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockReturnMemThruPtr_pFragmentShadingRates(__LINE__, pFragmentShadingRates, sizeof(VkPhysicalDeviceFragmentShadingRateKHR)) +#define vkGetPhysicalDeviceFragmentShadingRatesKHR_ReturnArrayThruPtr_pFragmentShadingRates(pFragmentShadingRates, cmock_len) vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockReturnMemThruPtr_pFragmentShadingRates(__LINE__, pFragmentShadingRates, cmock_len * sizeof(*pFragmentShadingRates)) +#define vkGetPhysicalDeviceFragmentShadingRatesKHR_ReturnMemThruPtr_pFragmentShadingRates(pFragmentShadingRates, cmock_size) vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockReturnMemThruPtr_pFragmentShadingRates(__LINE__, pFragmentShadingRates, cmock_size) +void vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockReturnMemThruPtr_pFragmentShadingRates(UNITY_LINE_TYPE cmock_line, VkPhysicalDeviceFragmentShadingRateKHR const* pFragmentShadingRates, size_t cmock_size); +#define vkGetPhysicalDeviceFragmentShadingRatesKHR_IgnoreArg_physicalDevice() vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceFragmentShadingRatesKHR_IgnoreArg_pFragmentShadingRateCount() vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockIgnoreArg_pFragmentShadingRateCount(__LINE__) +void vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockIgnoreArg_pFragmentShadingRateCount(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceFragmentShadingRatesKHR_IgnoreArg_pFragmentShadingRates() vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockIgnoreArg_pFragmentShadingRates(__LINE__) +void vkGetPhysicalDeviceFragmentShadingRatesKHR_CMockIgnoreArg_pFragmentShadingRates(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetFragmentShadingRateKHR_Ignore() vkCmdSetFragmentShadingRateKHR_CMockIgnore() +void vkCmdSetFragmentShadingRateKHR_CMockIgnore(void); +#define vkCmdSetFragmentShadingRateKHR_StopIgnore() vkCmdSetFragmentShadingRateKHR_CMockStopIgnore() +void vkCmdSetFragmentShadingRateKHR_CMockStopIgnore(void); +#define vkCmdSetFragmentShadingRateKHR_ExpectAnyArgs() vkCmdSetFragmentShadingRateKHR_CMockExpectAnyArgs(__LINE__) +void vkCmdSetFragmentShadingRateKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetFragmentShadingRateKHR_Expect(commandBuffer, pFragmentSize, combinerOps) vkCmdSetFragmentShadingRateKHR_CMockExpect(__LINE__, commandBuffer, pFragmentSize, combinerOps) +void vkCmdSetFragmentShadingRateKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR* combinerOps); +typedef void (* CMOCK_vkCmdSetFragmentShadingRateKHR_CALLBACK)(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR* combinerOps, int cmock_num_calls); +void vkCmdSetFragmentShadingRateKHR_AddCallback(CMOCK_vkCmdSetFragmentShadingRateKHR_CALLBACK Callback); +void vkCmdSetFragmentShadingRateKHR_Stub(CMOCK_vkCmdSetFragmentShadingRateKHR_CALLBACK Callback); +#define vkCmdSetFragmentShadingRateKHR_StubWithCallback vkCmdSetFragmentShadingRateKHR_AddCallback +#define vkCmdSetFragmentShadingRateKHR_IgnoreArg_commandBuffer() vkCmdSetFragmentShadingRateKHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetFragmentShadingRateKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetFragmentShadingRateKHR_IgnoreArg_pFragmentSize() vkCmdSetFragmentShadingRateKHR_CMockIgnoreArg_pFragmentSize(__LINE__) +void vkCmdSetFragmentShadingRateKHR_CMockIgnoreArg_pFragmentSize(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetFragmentShadingRateKHR_IgnoreArg_combinerOps() vkCmdSetFragmentShadingRateKHR_CMockIgnoreArg_combinerOps(__LINE__) +void vkCmdSetFragmentShadingRateKHR_CMockIgnoreArg_combinerOps(UNITY_LINE_TYPE cmock_line); +#define vkWaitForPresentKHR_IgnoreAndReturn(cmock_retval) vkWaitForPresentKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkWaitForPresentKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkWaitForPresentKHR_StopIgnore() vkWaitForPresentKHR_CMockStopIgnore() +void vkWaitForPresentKHR_CMockStopIgnore(void); +#define vkWaitForPresentKHR_ExpectAnyArgsAndReturn(cmock_retval) vkWaitForPresentKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkWaitForPresentKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkWaitForPresentKHR_ExpectAndReturn(device, swapchain, presentId, timeout, cmock_retval) vkWaitForPresentKHR_CMockExpectAndReturn(__LINE__, device, swapchain, presentId, timeout, cmock_retval) +void vkWaitForPresentKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkWaitForPresentKHR_CALLBACK)(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout, int cmock_num_calls); +void vkWaitForPresentKHR_AddCallback(CMOCK_vkWaitForPresentKHR_CALLBACK Callback); +void vkWaitForPresentKHR_Stub(CMOCK_vkWaitForPresentKHR_CALLBACK Callback); +#define vkWaitForPresentKHR_StubWithCallback vkWaitForPresentKHR_AddCallback +#define vkWaitForPresentKHR_IgnoreArg_device() vkWaitForPresentKHR_CMockIgnoreArg_device(__LINE__) +void vkWaitForPresentKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkWaitForPresentKHR_IgnoreArg_swapchain() vkWaitForPresentKHR_CMockIgnoreArg_swapchain(__LINE__) +void vkWaitForPresentKHR_CMockIgnoreArg_swapchain(UNITY_LINE_TYPE cmock_line); +#define vkWaitForPresentKHR_IgnoreArg_presentId() vkWaitForPresentKHR_CMockIgnoreArg_presentId(__LINE__) +void vkWaitForPresentKHR_CMockIgnoreArg_presentId(UNITY_LINE_TYPE cmock_line); +#define vkWaitForPresentKHR_IgnoreArg_timeout() vkWaitForPresentKHR_CMockIgnoreArg_timeout(__LINE__) +void vkWaitForPresentKHR_CMockIgnoreArg_timeout(UNITY_LINE_TYPE cmock_line); +#define vkGetBufferDeviceAddressKHR_IgnoreAndReturn(cmock_retval) vkGetBufferDeviceAddressKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetBufferDeviceAddressKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkDeviceAddress cmock_to_return); +#define vkGetBufferDeviceAddressKHR_StopIgnore() vkGetBufferDeviceAddressKHR_CMockStopIgnore() +void vkGetBufferDeviceAddressKHR_CMockStopIgnore(void); +#define vkGetBufferDeviceAddressKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetBufferDeviceAddressKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetBufferDeviceAddressKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkDeviceAddress cmock_to_return); +#define vkGetBufferDeviceAddressKHR_ExpectAndReturn(device, pInfo, cmock_retval) vkGetBufferDeviceAddressKHR_CMockExpectAndReturn(__LINE__, device, pInfo, cmock_retval) +void vkGetBufferDeviceAddressKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkBufferDeviceAddressInfo* pInfo, VkDeviceAddress cmock_to_return); +typedef VkDeviceAddress (* CMOCK_vkGetBufferDeviceAddressKHR_CALLBACK)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo, int cmock_num_calls); +void vkGetBufferDeviceAddressKHR_AddCallback(CMOCK_vkGetBufferDeviceAddressKHR_CALLBACK Callback); +void vkGetBufferDeviceAddressKHR_Stub(CMOCK_vkGetBufferDeviceAddressKHR_CALLBACK Callback); +#define vkGetBufferDeviceAddressKHR_StubWithCallback vkGetBufferDeviceAddressKHR_AddCallback +#define vkGetBufferDeviceAddressKHR_IgnoreArg_device() vkGetBufferDeviceAddressKHR_CMockIgnoreArg_device(__LINE__) +void vkGetBufferDeviceAddressKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetBufferDeviceAddressKHR_IgnoreArg_pInfo() vkGetBufferDeviceAddressKHR_CMockIgnoreArg_pInfo(__LINE__) +void vkGetBufferDeviceAddressKHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetBufferOpaqueCaptureAddressKHR_IgnoreAndReturn(cmock_retval) vkGetBufferOpaqueCaptureAddressKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetBufferOpaqueCaptureAddressKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, uint64_t cmock_to_return); +#define vkGetBufferOpaqueCaptureAddressKHR_StopIgnore() vkGetBufferOpaqueCaptureAddressKHR_CMockStopIgnore() +void vkGetBufferOpaqueCaptureAddressKHR_CMockStopIgnore(void); +#define vkGetBufferOpaqueCaptureAddressKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetBufferOpaqueCaptureAddressKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetBufferOpaqueCaptureAddressKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, uint64_t cmock_to_return); +#define vkGetBufferOpaqueCaptureAddressKHR_ExpectAndReturn(device, pInfo, cmock_retval) vkGetBufferOpaqueCaptureAddressKHR_CMockExpectAndReturn(__LINE__, device, pInfo, cmock_retval) +void vkGetBufferOpaqueCaptureAddressKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkBufferDeviceAddressInfo* pInfo, uint64_t cmock_to_return); +typedef uint64_t (* CMOCK_vkGetBufferOpaqueCaptureAddressKHR_CALLBACK)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo, int cmock_num_calls); +void vkGetBufferOpaqueCaptureAddressKHR_AddCallback(CMOCK_vkGetBufferOpaqueCaptureAddressKHR_CALLBACK Callback); +void vkGetBufferOpaqueCaptureAddressKHR_Stub(CMOCK_vkGetBufferOpaqueCaptureAddressKHR_CALLBACK Callback); +#define vkGetBufferOpaqueCaptureAddressKHR_StubWithCallback vkGetBufferOpaqueCaptureAddressKHR_AddCallback +#define vkGetBufferOpaqueCaptureAddressKHR_IgnoreArg_device() vkGetBufferOpaqueCaptureAddressKHR_CMockIgnoreArg_device(__LINE__) +void vkGetBufferOpaqueCaptureAddressKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetBufferOpaqueCaptureAddressKHR_IgnoreArg_pInfo() vkGetBufferOpaqueCaptureAddressKHR_CMockIgnoreArg_pInfo(__LINE__) +void vkGetBufferOpaqueCaptureAddressKHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceMemoryOpaqueCaptureAddressKHR_IgnoreAndReturn(cmock_retval) vkGetDeviceMemoryOpaqueCaptureAddressKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetDeviceMemoryOpaqueCaptureAddressKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, uint64_t cmock_to_return); +#define vkGetDeviceMemoryOpaqueCaptureAddressKHR_StopIgnore() vkGetDeviceMemoryOpaqueCaptureAddressKHR_CMockStopIgnore() +void vkGetDeviceMemoryOpaqueCaptureAddressKHR_CMockStopIgnore(void); +#define vkGetDeviceMemoryOpaqueCaptureAddressKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetDeviceMemoryOpaqueCaptureAddressKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetDeviceMemoryOpaqueCaptureAddressKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, uint64_t cmock_to_return); +#define vkGetDeviceMemoryOpaqueCaptureAddressKHR_ExpectAndReturn(device, pInfo, cmock_retval) vkGetDeviceMemoryOpaqueCaptureAddressKHR_CMockExpectAndReturn(__LINE__, device, pInfo, cmock_retval) +void vkGetDeviceMemoryOpaqueCaptureAddressKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo, uint64_t cmock_to_return); +typedef uint64_t (* CMOCK_vkGetDeviceMemoryOpaqueCaptureAddressKHR_CALLBACK)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo, int cmock_num_calls); +void vkGetDeviceMemoryOpaqueCaptureAddressKHR_AddCallback(CMOCK_vkGetDeviceMemoryOpaqueCaptureAddressKHR_CALLBACK Callback); +void vkGetDeviceMemoryOpaqueCaptureAddressKHR_Stub(CMOCK_vkGetDeviceMemoryOpaqueCaptureAddressKHR_CALLBACK Callback); +#define vkGetDeviceMemoryOpaqueCaptureAddressKHR_StubWithCallback vkGetDeviceMemoryOpaqueCaptureAddressKHR_AddCallback +#define vkGetDeviceMemoryOpaqueCaptureAddressKHR_IgnoreArg_device() vkGetDeviceMemoryOpaqueCaptureAddressKHR_CMockIgnoreArg_device(__LINE__) +void vkGetDeviceMemoryOpaqueCaptureAddressKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceMemoryOpaqueCaptureAddressKHR_IgnoreArg_pInfo() vkGetDeviceMemoryOpaqueCaptureAddressKHR_CMockIgnoreArg_pInfo(__LINE__) +void vkGetDeviceMemoryOpaqueCaptureAddressKHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateDeferredOperationKHR_IgnoreAndReturn(cmock_retval) vkCreateDeferredOperationKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateDeferredOperationKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateDeferredOperationKHR_StopIgnore() vkCreateDeferredOperationKHR_CMockStopIgnore() +void vkCreateDeferredOperationKHR_CMockStopIgnore(void); +#define vkCreateDeferredOperationKHR_ExpectAnyArgsAndReturn(cmock_retval) vkCreateDeferredOperationKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateDeferredOperationKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateDeferredOperationKHR_ExpectAndReturn(device, pAllocator, pDeferredOperation, cmock_retval) vkCreateDeferredOperationKHR_CMockExpectAndReturn(__LINE__, device, pAllocator, pDeferredOperation, cmock_retval) +void vkCreateDeferredOperationKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateDeferredOperationKHR_CALLBACK)(VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation, int cmock_num_calls); +void vkCreateDeferredOperationKHR_AddCallback(CMOCK_vkCreateDeferredOperationKHR_CALLBACK Callback); +void vkCreateDeferredOperationKHR_Stub(CMOCK_vkCreateDeferredOperationKHR_CALLBACK Callback); +#define vkCreateDeferredOperationKHR_StubWithCallback vkCreateDeferredOperationKHR_AddCallback +#define vkCreateDeferredOperationKHR_ReturnThruPtr_pDeferredOperation(pDeferredOperation) vkCreateDeferredOperationKHR_CMockReturnMemThruPtr_pDeferredOperation(__LINE__, pDeferredOperation, sizeof(VkDeferredOperationKHR)) +#define vkCreateDeferredOperationKHR_ReturnArrayThruPtr_pDeferredOperation(pDeferredOperation, cmock_len) vkCreateDeferredOperationKHR_CMockReturnMemThruPtr_pDeferredOperation(__LINE__, pDeferredOperation, cmock_len * sizeof(*pDeferredOperation)) +#define vkCreateDeferredOperationKHR_ReturnMemThruPtr_pDeferredOperation(pDeferredOperation, cmock_size) vkCreateDeferredOperationKHR_CMockReturnMemThruPtr_pDeferredOperation(__LINE__, pDeferredOperation, cmock_size) +void vkCreateDeferredOperationKHR_CMockReturnMemThruPtr_pDeferredOperation(UNITY_LINE_TYPE cmock_line, VkDeferredOperationKHR const* pDeferredOperation, size_t cmock_size); +#define vkCreateDeferredOperationKHR_IgnoreArg_device() vkCreateDeferredOperationKHR_CMockIgnoreArg_device(__LINE__) +void vkCreateDeferredOperationKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateDeferredOperationKHR_IgnoreArg_pAllocator() vkCreateDeferredOperationKHR_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateDeferredOperationKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateDeferredOperationKHR_IgnoreArg_pDeferredOperation() vkCreateDeferredOperationKHR_CMockIgnoreArg_pDeferredOperation(__LINE__) +void vkCreateDeferredOperationKHR_CMockIgnoreArg_pDeferredOperation(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDeferredOperationKHR_Ignore() vkDestroyDeferredOperationKHR_CMockIgnore() +void vkDestroyDeferredOperationKHR_CMockIgnore(void); +#define vkDestroyDeferredOperationKHR_StopIgnore() vkDestroyDeferredOperationKHR_CMockStopIgnore() +void vkDestroyDeferredOperationKHR_CMockStopIgnore(void); +#define vkDestroyDeferredOperationKHR_ExpectAnyArgs() vkDestroyDeferredOperationKHR_CMockExpectAnyArgs(__LINE__) +void vkDestroyDeferredOperationKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDeferredOperationKHR_Expect(device, operation, pAllocator) vkDestroyDeferredOperationKHR_CMockExpect(__LINE__, device, operation, pAllocator) +void vkDestroyDeferredOperationKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyDeferredOperationKHR_CALLBACK)(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyDeferredOperationKHR_AddCallback(CMOCK_vkDestroyDeferredOperationKHR_CALLBACK Callback); +void vkDestroyDeferredOperationKHR_Stub(CMOCK_vkDestroyDeferredOperationKHR_CALLBACK Callback); +#define vkDestroyDeferredOperationKHR_StubWithCallback vkDestroyDeferredOperationKHR_AddCallback +#define vkDestroyDeferredOperationKHR_IgnoreArg_device() vkDestroyDeferredOperationKHR_CMockIgnoreArg_device(__LINE__) +void vkDestroyDeferredOperationKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDeferredOperationKHR_IgnoreArg_operation() vkDestroyDeferredOperationKHR_CMockIgnoreArg_operation(__LINE__) +void vkDestroyDeferredOperationKHR_CMockIgnoreArg_operation(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDeferredOperationKHR_IgnoreArg_pAllocator() vkDestroyDeferredOperationKHR_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyDeferredOperationKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkGetDeferredOperationMaxConcurrencyKHR_IgnoreAndReturn(cmock_retval) vkGetDeferredOperationMaxConcurrencyKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetDeferredOperationMaxConcurrencyKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, uint32_t cmock_to_return); +#define vkGetDeferredOperationMaxConcurrencyKHR_StopIgnore() vkGetDeferredOperationMaxConcurrencyKHR_CMockStopIgnore() +void vkGetDeferredOperationMaxConcurrencyKHR_CMockStopIgnore(void); +#define vkGetDeferredOperationMaxConcurrencyKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetDeferredOperationMaxConcurrencyKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetDeferredOperationMaxConcurrencyKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, uint32_t cmock_to_return); +#define vkGetDeferredOperationMaxConcurrencyKHR_ExpectAndReturn(device, operation, cmock_retval) vkGetDeferredOperationMaxConcurrencyKHR_CMockExpectAndReturn(__LINE__, device, operation, cmock_retval) +void vkGetDeferredOperationMaxConcurrencyKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeferredOperationKHR operation, uint32_t cmock_to_return); +typedef uint32_t (* CMOCK_vkGetDeferredOperationMaxConcurrencyKHR_CALLBACK)(VkDevice device, VkDeferredOperationKHR operation, int cmock_num_calls); +void vkGetDeferredOperationMaxConcurrencyKHR_AddCallback(CMOCK_vkGetDeferredOperationMaxConcurrencyKHR_CALLBACK Callback); +void vkGetDeferredOperationMaxConcurrencyKHR_Stub(CMOCK_vkGetDeferredOperationMaxConcurrencyKHR_CALLBACK Callback); +#define vkGetDeferredOperationMaxConcurrencyKHR_StubWithCallback vkGetDeferredOperationMaxConcurrencyKHR_AddCallback +#define vkGetDeferredOperationMaxConcurrencyKHR_IgnoreArg_device() vkGetDeferredOperationMaxConcurrencyKHR_CMockIgnoreArg_device(__LINE__) +void vkGetDeferredOperationMaxConcurrencyKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetDeferredOperationMaxConcurrencyKHR_IgnoreArg_operation() vkGetDeferredOperationMaxConcurrencyKHR_CMockIgnoreArg_operation(__LINE__) +void vkGetDeferredOperationMaxConcurrencyKHR_CMockIgnoreArg_operation(UNITY_LINE_TYPE cmock_line); +#define vkGetDeferredOperationResultKHR_IgnoreAndReturn(cmock_retval) vkGetDeferredOperationResultKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetDeferredOperationResultKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetDeferredOperationResultKHR_StopIgnore() vkGetDeferredOperationResultKHR_CMockStopIgnore() +void vkGetDeferredOperationResultKHR_CMockStopIgnore(void); +#define vkGetDeferredOperationResultKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetDeferredOperationResultKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetDeferredOperationResultKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetDeferredOperationResultKHR_ExpectAndReturn(device, operation, cmock_retval) vkGetDeferredOperationResultKHR_CMockExpectAndReturn(__LINE__, device, operation, cmock_retval) +void vkGetDeferredOperationResultKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeferredOperationKHR operation, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetDeferredOperationResultKHR_CALLBACK)(VkDevice device, VkDeferredOperationKHR operation, int cmock_num_calls); +void vkGetDeferredOperationResultKHR_AddCallback(CMOCK_vkGetDeferredOperationResultKHR_CALLBACK Callback); +void vkGetDeferredOperationResultKHR_Stub(CMOCK_vkGetDeferredOperationResultKHR_CALLBACK Callback); +#define vkGetDeferredOperationResultKHR_StubWithCallback vkGetDeferredOperationResultKHR_AddCallback +#define vkGetDeferredOperationResultKHR_IgnoreArg_device() vkGetDeferredOperationResultKHR_CMockIgnoreArg_device(__LINE__) +void vkGetDeferredOperationResultKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetDeferredOperationResultKHR_IgnoreArg_operation() vkGetDeferredOperationResultKHR_CMockIgnoreArg_operation(__LINE__) +void vkGetDeferredOperationResultKHR_CMockIgnoreArg_operation(UNITY_LINE_TYPE cmock_line); +#define vkDeferredOperationJoinKHR_IgnoreAndReturn(cmock_retval) vkDeferredOperationJoinKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkDeferredOperationJoinKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkDeferredOperationJoinKHR_StopIgnore() vkDeferredOperationJoinKHR_CMockStopIgnore() +void vkDeferredOperationJoinKHR_CMockStopIgnore(void); +#define vkDeferredOperationJoinKHR_ExpectAnyArgsAndReturn(cmock_retval) vkDeferredOperationJoinKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkDeferredOperationJoinKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkDeferredOperationJoinKHR_ExpectAndReturn(device, operation, cmock_retval) vkDeferredOperationJoinKHR_CMockExpectAndReturn(__LINE__, device, operation, cmock_retval) +void vkDeferredOperationJoinKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeferredOperationKHR operation, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkDeferredOperationJoinKHR_CALLBACK)(VkDevice device, VkDeferredOperationKHR operation, int cmock_num_calls); +void vkDeferredOperationJoinKHR_AddCallback(CMOCK_vkDeferredOperationJoinKHR_CALLBACK Callback); +void vkDeferredOperationJoinKHR_Stub(CMOCK_vkDeferredOperationJoinKHR_CALLBACK Callback); +#define vkDeferredOperationJoinKHR_StubWithCallback vkDeferredOperationJoinKHR_AddCallback +#define vkDeferredOperationJoinKHR_IgnoreArg_device() vkDeferredOperationJoinKHR_CMockIgnoreArg_device(__LINE__) +void vkDeferredOperationJoinKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDeferredOperationJoinKHR_IgnoreArg_operation() vkDeferredOperationJoinKHR_CMockIgnoreArg_operation(__LINE__) +void vkDeferredOperationJoinKHR_CMockIgnoreArg_operation(UNITY_LINE_TYPE cmock_line); +#define vkGetPipelineExecutablePropertiesKHR_IgnoreAndReturn(cmock_retval) vkGetPipelineExecutablePropertiesKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPipelineExecutablePropertiesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPipelineExecutablePropertiesKHR_StopIgnore() vkGetPipelineExecutablePropertiesKHR_CMockStopIgnore() +void vkGetPipelineExecutablePropertiesKHR_CMockStopIgnore(void); +#define vkGetPipelineExecutablePropertiesKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetPipelineExecutablePropertiesKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPipelineExecutablePropertiesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPipelineExecutablePropertiesKHR_ExpectAndReturn(device, pPipelineInfo, pExecutableCount, pProperties, cmock_retval) vkGetPipelineExecutablePropertiesKHR_CMockExpectAndReturn(__LINE__, device, pPipelineInfo, pExecutableCount, pProperties, cmock_retval) +void vkGetPipelineExecutablePropertiesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPipelineExecutablePropertiesKHR_CALLBACK)(VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties, int cmock_num_calls); +void vkGetPipelineExecutablePropertiesKHR_AddCallback(CMOCK_vkGetPipelineExecutablePropertiesKHR_CALLBACK Callback); +void vkGetPipelineExecutablePropertiesKHR_Stub(CMOCK_vkGetPipelineExecutablePropertiesKHR_CALLBACK Callback); +#define vkGetPipelineExecutablePropertiesKHR_StubWithCallback vkGetPipelineExecutablePropertiesKHR_AddCallback +#define vkGetPipelineExecutablePropertiesKHR_ReturnThruPtr_pExecutableCount(pExecutableCount) vkGetPipelineExecutablePropertiesKHR_CMockReturnMemThruPtr_pExecutableCount(__LINE__, pExecutableCount, sizeof(uint32_t)) +#define vkGetPipelineExecutablePropertiesKHR_ReturnArrayThruPtr_pExecutableCount(pExecutableCount, cmock_len) vkGetPipelineExecutablePropertiesKHR_CMockReturnMemThruPtr_pExecutableCount(__LINE__, pExecutableCount, cmock_len * sizeof(*pExecutableCount)) +#define vkGetPipelineExecutablePropertiesKHR_ReturnMemThruPtr_pExecutableCount(pExecutableCount, cmock_size) vkGetPipelineExecutablePropertiesKHR_CMockReturnMemThruPtr_pExecutableCount(__LINE__, pExecutableCount, cmock_size) +void vkGetPipelineExecutablePropertiesKHR_CMockReturnMemThruPtr_pExecutableCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pExecutableCount, size_t cmock_size); +#define vkGetPipelineExecutablePropertiesKHR_ReturnThruPtr_pProperties(pProperties) vkGetPipelineExecutablePropertiesKHR_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, sizeof(VkPipelineExecutablePropertiesKHR)) +#define vkGetPipelineExecutablePropertiesKHR_ReturnArrayThruPtr_pProperties(pProperties, cmock_len) vkGetPipelineExecutablePropertiesKHR_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_len * sizeof(*pProperties)) +#define vkGetPipelineExecutablePropertiesKHR_ReturnMemThruPtr_pProperties(pProperties, cmock_size) vkGetPipelineExecutablePropertiesKHR_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_size) +void vkGetPipelineExecutablePropertiesKHR_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkPipelineExecutablePropertiesKHR const* pProperties, size_t cmock_size); +#define vkGetPipelineExecutablePropertiesKHR_IgnoreArg_device() vkGetPipelineExecutablePropertiesKHR_CMockIgnoreArg_device(__LINE__) +void vkGetPipelineExecutablePropertiesKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetPipelineExecutablePropertiesKHR_IgnoreArg_pPipelineInfo() vkGetPipelineExecutablePropertiesKHR_CMockIgnoreArg_pPipelineInfo(__LINE__) +void vkGetPipelineExecutablePropertiesKHR_CMockIgnoreArg_pPipelineInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetPipelineExecutablePropertiesKHR_IgnoreArg_pExecutableCount() vkGetPipelineExecutablePropertiesKHR_CMockIgnoreArg_pExecutableCount(__LINE__) +void vkGetPipelineExecutablePropertiesKHR_CMockIgnoreArg_pExecutableCount(UNITY_LINE_TYPE cmock_line); +#define vkGetPipelineExecutablePropertiesKHR_IgnoreArg_pProperties() vkGetPipelineExecutablePropertiesKHR_CMockIgnoreArg_pProperties(__LINE__) +void vkGetPipelineExecutablePropertiesKHR_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetPipelineExecutableStatisticsKHR_IgnoreAndReturn(cmock_retval) vkGetPipelineExecutableStatisticsKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPipelineExecutableStatisticsKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPipelineExecutableStatisticsKHR_StopIgnore() vkGetPipelineExecutableStatisticsKHR_CMockStopIgnore() +void vkGetPipelineExecutableStatisticsKHR_CMockStopIgnore(void); +#define vkGetPipelineExecutableStatisticsKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetPipelineExecutableStatisticsKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPipelineExecutableStatisticsKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPipelineExecutableStatisticsKHR_ExpectAndReturn(device, pExecutableInfo, pStatisticCount, pStatistics, cmock_retval) vkGetPipelineExecutableStatisticsKHR_CMockExpectAndReturn(__LINE__, device, pExecutableInfo, pStatisticCount, pStatistics, cmock_retval) +void vkGetPipelineExecutableStatisticsKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPipelineExecutableStatisticsKHR_CALLBACK)(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics, int cmock_num_calls); +void vkGetPipelineExecutableStatisticsKHR_AddCallback(CMOCK_vkGetPipelineExecutableStatisticsKHR_CALLBACK Callback); +void vkGetPipelineExecutableStatisticsKHR_Stub(CMOCK_vkGetPipelineExecutableStatisticsKHR_CALLBACK Callback); +#define vkGetPipelineExecutableStatisticsKHR_StubWithCallback vkGetPipelineExecutableStatisticsKHR_AddCallback +#define vkGetPipelineExecutableStatisticsKHR_ReturnThruPtr_pStatisticCount(pStatisticCount) vkGetPipelineExecutableStatisticsKHR_CMockReturnMemThruPtr_pStatisticCount(__LINE__, pStatisticCount, sizeof(uint32_t)) +#define vkGetPipelineExecutableStatisticsKHR_ReturnArrayThruPtr_pStatisticCount(pStatisticCount, cmock_len) vkGetPipelineExecutableStatisticsKHR_CMockReturnMemThruPtr_pStatisticCount(__LINE__, pStatisticCount, cmock_len * sizeof(*pStatisticCount)) +#define vkGetPipelineExecutableStatisticsKHR_ReturnMemThruPtr_pStatisticCount(pStatisticCount, cmock_size) vkGetPipelineExecutableStatisticsKHR_CMockReturnMemThruPtr_pStatisticCount(__LINE__, pStatisticCount, cmock_size) +void vkGetPipelineExecutableStatisticsKHR_CMockReturnMemThruPtr_pStatisticCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pStatisticCount, size_t cmock_size); +#define vkGetPipelineExecutableStatisticsKHR_ReturnThruPtr_pStatistics(pStatistics) vkGetPipelineExecutableStatisticsKHR_CMockReturnMemThruPtr_pStatistics(__LINE__, pStatistics, sizeof(VkPipelineExecutableStatisticKHR)) +#define vkGetPipelineExecutableStatisticsKHR_ReturnArrayThruPtr_pStatistics(pStatistics, cmock_len) vkGetPipelineExecutableStatisticsKHR_CMockReturnMemThruPtr_pStatistics(__LINE__, pStatistics, cmock_len * sizeof(*pStatistics)) +#define vkGetPipelineExecutableStatisticsKHR_ReturnMemThruPtr_pStatistics(pStatistics, cmock_size) vkGetPipelineExecutableStatisticsKHR_CMockReturnMemThruPtr_pStatistics(__LINE__, pStatistics, cmock_size) +void vkGetPipelineExecutableStatisticsKHR_CMockReturnMemThruPtr_pStatistics(UNITY_LINE_TYPE cmock_line, VkPipelineExecutableStatisticKHR const* pStatistics, size_t cmock_size); +#define vkGetPipelineExecutableStatisticsKHR_IgnoreArg_device() vkGetPipelineExecutableStatisticsKHR_CMockIgnoreArg_device(__LINE__) +void vkGetPipelineExecutableStatisticsKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetPipelineExecutableStatisticsKHR_IgnoreArg_pExecutableInfo() vkGetPipelineExecutableStatisticsKHR_CMockIgnoreArg_pExecutableInfo(__LINE__) +void vkGetPipelineExecutableStatisticsKHR_CMockIgnoreArg_pExecutableInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetPipelineExecutableStatisticsKHR_IgnoreArg_pStatisticCount() vkGetPipelineExecutableStatisticsKHR_CMockIgnoreArg_pStatisticCount(__LINE__) +void vkGetPipelineExecutableStatisticsKHR_CMockIgnoreArg_pStatisticCount(UNITY_LINE_TYPE cmock_line); +#define vkGetPipelineExecutableStatisticsKHR_IgnoreArg_pStatistics() vkGetPipelineExecutableStatisticsKHR_CMockIgnoreArg_pStatistics(__LINE__) +void vkGetPipelineExecutableStatisticsKHR_CMockIgnoreArg_pStatistics(UNITY_LINE_TYPE cmock_line); +#define vkGetPipelineExecutableInternalRepresentationsKHR_IgnoreAndReturn(cmock_retval) vkGetPipelineExecutableInternalRepresentationsKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPipelineExecutableInternalRepresentationsKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPipelineExecutableInternalRepresentationsKHR_StopIgnore() vkGetPipelineExecutableInternalRepresentationsKHR_CMockStopIgnore() +void vkGetPipelineExecutableInternalRepresentationsKHR_CMockStopIgnore(void); +#define vkGetPipelineExecutableInternalRepresentationsKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetPipelineExecutableInternalRepresentationsKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPipelineExecutableInternalRepresentationsKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPipelineExecutableInternalRepresentationsKHR_ExpectAndReturn(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations, cmock_retval) vkGetPipelineExecutableInternalRepresentationsKHR_CMockExpectAndReturn(__LINE__, device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations, cmock_retval) +void vkGetPipelineExecutableInternalRepresentationsKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALLBACK)(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations, int cmock_num_calls); +void vkGetPipelineExecutableInternalRepresentationsKHR_AddCallback(CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALLBACK Callback); +void vkGetPipelineExecutableInternalRepresentationsKHR_Stub(CMOCK_vkGetPipelineExecutableInternalRepresentationsKHR_CALLBACK Callback); +#define vkGetPipelineExecutableInternalRepresentationsKHR_StubWithCallback vkGetPipelineExecutableInternalRepresentationsKHR_AddCallback +#define vkGetPipelineExecutableInternalRepresentationsKHR_ReturnThruPtr_pInternalRepresentationCount(pInternalRepresentationCount) vkGetPipelineExecutableInternalRepresentationsKHR_CMockReturnMemThruPtr_pInternalRepresentationCount(__LINE__, pInternalRepresentationCount, sizeof(uint32_t)) +#define vkGetPipelineExecutableInternalRepresentationsKHR_ReturnArrayThruPtr_pInternalRepresentationCount(pInternalRepresentationCount, cmock_len) vkGetPipelineExecutableInternalRepresentationsKHR_CMockReturnMemThruPtr_pInternalRepresentationCount(__LINE__, pInternalRepresentationCount, cmock_len * sizeof(*pInternalRepresentationCount)) +#define vkGetPipelineExecutableInternalRepresentationsKHR_ReturnMemThruPtr_pInternalRepresentationCount(pInternalRepresentationCount, cmock_size) vkGetPipelineExecutableInternalRepresentationsKHR_CMockReturnMemThruPtr_pInternalRepresentationCount(__LINE__, pInternalRepresentationCount, cmock_size) +void vkGetPipelineExecutableInternalRepresentationsKHR_CMockReturnMemThruPtr_pInternalRepresentationCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pInternalRepresentationCount, size_t cmock_size); +#define vkGetPipelineExecutableInternalRepresentationsKHR_ReturnThruPtr_pInternalRepresentations(pInternalRepresentations) vkGetPipelineExecutableInternalRepresentationsKHR_CMockReturnMemThruPtr_pInternalRepresentations(__LINE__, pInternalRepresentations, sizeof(VkPipelineExecutableInternalRepresentationKHR)) +#define vkGetPipelineExecutableInternalRepresentationsKHR_ReturnArrayThruPtr_pInternalRepresentations(pInternalRepresentations, cmock_len) vkGetPipelineExecutableInternalRepresentationsKHR_CMockReturnMemThruPtr_pInternalRepresentations(__LINE__, pInternalRepresentations, cmock_len * sizeof(*pInternalRepresentations)) +#define vkGetPipelineExecutableInternalRepresentationsKHR_ReturnMemThruPtr_pInternalRepresentations(pInternalRepresentations, cmock_size) vkGetPipelineExecutableInternalRepresentationsKHR_CMockReturnMemThruPtr_pInternalRepresentations(__LINE__, pInternalRepresentations, cmock_size) +void vkGetPipelineExecutableInternalRepresentationsKHR_CMockReturnMemThruPtr_pInternalRepresentations(UNITY_LINE_TYPE cmock_line, VkPipelineExecutableInternalRepresentationKHR const* pInternalRepresentations, size_t cmock_size); +#define vkGetPipelineExecutableInternalRepresentationsKHR_IgnoreArg_device() vkGetPipelineExecutableInternalRepresentationsKHR_CMockIgnoreArg_device(__LINE__) +void vkGetPipelineExecutableInternalRepresentationsKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetPipelineExecutableInternalRepresentationsKHR_IgnoreArg_pExecutableInfo() vkGetPipelineExecutableInternalRepresentationsKHR_CMockIgnoreArg_pExecutableInfo(__LINE__) +void vkGetPipelineExecutableInternalRepresentationsKHR_CMockIgnoreArg_pExecutableInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetPipelineExecutableInternalRepresentationsKHR_IgnoreArg_pInternalRepresentationCount() vkGetPipelineExecutableInternalRepresentationsKHR_CMockIgnoreArg_pInternalRepresentationCount(__LINE__) +void vkGetPipelineExecutableInternalRepresentationsKHR_CMockIgnoreArg_pInternalRepresentationCount(UNITY_LINE_TYPE cmock_line); +#define vkGetPipelineExecutableInternalRepresentationsKHR_IgnoreArg_pInternalRepresentations() vkGetPipelineExecutableInternalRepresentationsKHR_CMockIgnoreArg_pInternalRepresentations(__LINE__) +void vkGetPipelineExecutableInternalRepresentationsKHR_CMockIgnoreArg_pInternalRepresentations(UNITY_LINE_TYPE cmock_line); +#define vkMapMemory2KHR_IgnoreAndReturn(cmock_retval) vkMapMemory2KHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkMapMemory2KHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkMapMemory2KHR_StopIgnore() vkMapMemory2KHR_CMockStopIgnore() +void vkMapMemory2KHR_CMockStopIgnore(void); +#define vkMapMemory2KHR_ExpectAnyArgsAndReturn(cmock_retval) vkMapMemory2KHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkMapMemory2KHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkMapMemory2KHR_ExpectAndReturn(device, pMemoryMapInfo, ppData, cmock_retval) vkMapMemory2KHR_CMockExpectAndReturn(__LINE__, device, pMemoryMapInfo, ppData, cmock_retval) +void vkMapMemory2KHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkMemoryMapInfoKHR* pMemoryMapInfo, void** ppData, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkMapMemory2KHR_CALLBACK)(VkDevice device, const VkMemoryMapInfoKHR* pMemoryMapInfo, void** ppData, int cmock_num_calls); +void vkMapMemory2KHR_AddCallback(CMOCK_vkMapMemory2KHR_CALLBACK Callback); +void vkMapMemory2KHR_Stub(CMOCK_vkMapMemory2KHR_CALLBACK Callback); +#define vkMapMemory2KHR_StubWithCallback vkMapMemory2KHR_AddCallback +#define vkMapMemory2KHR_ReturnThruPtr_ppData(ppData) vkMapMemory2KHR_CMockReturnMemThruPtr_ppData(__LINE__, ppData, sizeof(void*)) +#define vkMapMemory2KHR_ReturnArrayThruPtr_ppData(ppData, cmock_len) vkMapMemory2KHR_CMockReturnMemThruPtr_ppData(__LINE__, ppData, cmock_len * sizeof(*ppData)) +#define vkMapMemory2KHR_ReturnMemThruPtr_ppData(ppData, cmock_size) vkMapMemory2KHR_CMockReturnMemThruPtr_ppData(__LINE__, ppData, cmock_size) +void vkMapMemory2KHR_CMockReturnMemThruPtr_ppData(UNITY_LINE_TYPE cmock_line, void* const* ppData, size_t cmock_size); +#define vkMapMemory2KHR_IgnoreArg_device() vkMapMemory2KHR_CMockIgnoreArg_device(__LINE__) +void vkMapMemory2KHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkMapMemory2KHR_IgnoreArg_pMemoryMapInfo() vkMapMemory2KHR_CMockIgnoreArg_pMemoryMapInfo(__LINE__) +void vkMapMemory2KHR_CMockIgnoreArg_pMemoryMapInfo(UNITY_LINE_TYPE cmock_line); +#define vkMapMemory2KHR_IgnoreArg_ppData() vkMapMemory2KHR_CMockIgnoreArg_ppData(__LINE__) +void vkMapMemory2KHR_CMockIgnoreArg_ppData(UNITY_LINE_TYPE cmock_line); +#define vkUnmapMemory2KHR_IgnoreAndReturn(cmock_retval) vkUnmapMemory2KHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkUnmapMemory2KHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkUnmapMemory2KHR_StopIgnore() vkUnmapMemory2KHR_CMockStopIgnore() +void vkUnmapMemory2KHR_CMockStopIgnore(void); +#define vkUnmapMemory2KHR_ExpectAnyArgsAndReturn(cmock_retval) vkUnmapMemory2KHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkUnmapMemory2KHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkUnmapMemory2KHR_ExpectAndReturn(device, pMemoryUnmapInfo, cmock_retval) vkUnmapMemory2KHR_CMockExpectAndReturn(__LINE__, device, pMemoryUnmapInfo, cmock_retval) +void vkUnmapMemory2KHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkUnmapMemory2KHR_CALLBACK)(VkDevice device, const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo, int cmock_num_calls); +void vkUnmapMemory2KHR_AddCallback(CMOCK_vkUnmapMemory2KHR_CALLBACK Callback); +void vkUnmapMemory2KHR_Stub(CMOCK_vkUnmapMemory2KHR_CALLBACK Callback); +#define vkUnmapMemory2KHR_StubWithCallback vkUnmapMemory2KHR_AddCallback +#define vkUnmapMemory2KHR_IgnoreArg_device() vkUnmapMemory2KHR_CMockIgnoreArg_device(__LINE__) +void vkUnmapMemory2KHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkUnmapMemory2KHR_IgnoreArg_pMemoryUnmapInfo() vkUnmapMemory2KHR_CMockIgnoreArg_pMemoryUnmapInfo(__LINE__) +void vkUnmapMemory2KHR_CMockIgnoreArg_pMemoryUnmapInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetEvent2KHR_Ignore() vkCmdSetEvent2KHR_CMockIgnore() +void vkCmdSetEvent2KHR_CMockIgnore(void); +#define vkCmdSetEvent2KHR_StopIgnore() vkCmdSetEvent2KHR_CMockStopIgnore() +void vkCmdSetEvent2KHR_CMockStopIgnore(void); +#define vkCmdSetEvent2KHR_ExpectAnyArgs() vkCmdSetEvent2KHR_CMockExpectAnyArgs(__LINE__) +void vkCmdSetEvent2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetEvent2KHR_Expect(commandBuffer, event, pDependencyInfo) vkCmdSetEvent2KHR_CMockExpect(__LINE__, commandBuffer, event, pDependencyInfo) +void vkCmdSetEvent2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo); +typedef void (* CMOCK_vkCmdSetEvent2KHR_CALLBACK)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo, int cmock_num_calls); +void vkCmdSetEvent2KHR_AddCallback(CMOCK_vkCmdSetEvent2KHR_CALLBACK Callback); +void vkCmdSetEvent2KHR_Stub(CMOCK_vkCmdSetEvent2KHR_CALLBACK Callback); +#define vkCmdSetEvent2KHR_StubWithCallback vkCmdSetEvent2KHR_AddCallback +#define vkCmdSetEvent2KHR_IgnoreArg_commandBuffer() vkCmdSetEvent2KHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetEvent2KHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetEvent2KHR_IgnoreArg_event() vkCmdSetEvent2KHR_CMockIgnoreArg_event(__LINE__) +void vkCmdSetEvent2KHR_CMockIgnoreArg_event(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetEvent2KHR_IgnoreArg_pDependencyInfo() vkCmdSetEvent2KHR_CMockIgnoreArg_pDependencyInfo(__LINE__) +void vkCmdSetEvent2KHR_CMockIgnoreArg_pDependencyInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdResetEvent2KHR_Ignore() vkCmdResetEvent2KHR_CMockIgnore() +void vkCmdResetEvent2KHR_CMockIgnore(void); +#define vkCmdResetEvent2KHR_StopIgnore() vkCmdResetEvent2KHR_CMockStopIgnore() +void vkCmdResetEvent2KHR_CMockStopIgnore(void); +#define vkCmdResetEvent2KHR_ExpectAnyArgs() vkCmdResetEvent2KHR_CMockExpectAnyArgs(__LINE__) +void vkCmdResetEvent2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdResetEvent2KHR_Expect(commandBuffer, event, stageMask) vkCmdResetEvent2KHR_CMockExpect(__LINE__, commandBuffer, event, stageMask) +void vkCmdResetEvent2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask); +typedef void (* CMOCK_vkCmdResetEvent2KHR_CALLBACK)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask, int cmock_num_calls); +void vkCmdResetEvent2KHR_AddCallback(CMOCK_vkCmdResetEvent2KHR_CALLBACK Callback); +void vkCmdResetEvent2KHR_Stub(CMOCK_vkCmdResetEvent2KHR_CALLBACK Callback); +#define vkCmdResetEvent2KHR_StubWithCallback vkCmdResetEvent2KHR_AddCallback +#define vkCmdResetEvent2KHR_IgnoreArg_commandBuffer() vkCmdResetEvent2KHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdResetEvent2KHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdResetEvent2KHR_IgnoreArg_event() vkCmdResetEvent2KHR_CMockIgnoreArg_event(__LINE__) +void vkCmdResetEvent2KHR_CMockIgnoreArg_event(UNITY_LINE_TYPE cmock_line); +#define vkCmdResetEvent2KHR_IgnoreArg_stageMask() vkCmdResetEvent2KHR_CMockIgnoreArg_stageMask(__LINE__) +void vkCmdResetEvent2KHR_CMockIgnoreArg_stageMask(UNITY_LINE_TYPE cmock_line); +#define vkCmdWaitEvents2KHR_Ignore() vkCmdWaitEvents2KHR_CMockIgnore() +void vkCmdWaitEvents2KHR_CMockIgnore(void); +#define vkCmdWaitEvents2KHR_StopIgnore() vkCmdWaitEvents2KHR_CMockStopIgnore() +void vkCmdWaitEvents2KHR_CMockStopIgnore(void); +#define vkCmdWaitEvents2KHR_ExpectAnyArgs() vkCmdWaitEvents2KHR_CMockExpectAnyArgs(__LINE__) +void vkCmdWaitEvents2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdWaitEvents2KHR_Expect(commandBuffer, eventCount, pEvents, pDependencyInfos) vkCmdWaitEvents2KHR_CMockExpect(__LINE__, commandBuffer, eventCount, pEvents, pDependencyInfos) +void vkCmdWaitEvents2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos); +typedef void (* CMOCK_vkCmdWaitEvents2KHR_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos, int cmock_num_calls); +void vkCmdWaitEvents2KHR_AddCallback(CMOCK_vkCmdWaitEvents2KHR_CALLBACK Callback); +void vkCmdWaitEvents2KHR_Stub(CMOCK_vkCmdWaitEvents2KHR_CALLBACK Callback); +#define vkCmdWaitEvents2KHR_StubWithCallback vkCmdWaitEvents2KHR_AddCallback +#define vkCmdWaitEvents2KHR_IgnoreArg_commandBuffer() vkCmdWaitEvents2KHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdWaitEvents2KHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdWaitEvents2KHR_IgnoreArg_eventCount() vkCmdWaitEvents2KHR_CMockIgnoreArg_eventCount(__LINE__) +void vkCmdWaitEvents2KHR_CMockIgnoreArg_eventCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdWaitEvents2KHR_IgnoreArg_pEvents() vkCmdWaitEvents2KHR_CMockIgnoreArg_pEvents(__LINE__) +void vkCmdWaitEvents2KHR_CMockIgnoreArg_pEvents(UNITY_LINE_TYPE cmock_line); +#define vkCmdWaitEvents2KHR_IgnoreArg_pDependencyInfos() vkCmdWaitEvents2KHR_CMockIgnoreArg_pDependencyInfos(__LINE__) +void vkCmdWaitEvents2KHR_CMockIgnoreArg_pDependencyInfos(UNITY_LINE_TYPE cmock_line); +#define vkCmdPipelineBarrier2KHR_Ignore() vkCmdPipelineBarrier2KHR_CMockIgnore() +void vkCmdPipelineBarrier2KHR_CMockIgnore(void); +#define vkCmdPipelineBarrier2KHR_StopIgnore() vkCmdPipelineBarrier2KHR_CMockStopIgnore() +void vkCmdPipelineBarrier2KHR_CMockStopIgnore(void); +#define vkCmdPipelineBarrier2KHR_ExpectAnyArgs() vkCmdPipelineBarrier2KHR_CMockExpectAnyArgs(__LINE__) +void vkCmdPipelineBarrier2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdPipelineBarrier2KHR_Expect(commandBuffer, pDependencyInfo) vkCmdPipelineBarrier2KHR_CMockExpect(__LINE__, commandBuffer, pDependencyInfo) +void vkCmdPipelineBarrier2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo); +typedef void (* CMOCK_vkCmdPipelineBarrier2KHR_CALLBACK)(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo, int cmock_num_calls); +void vkCmdPipelineBarrier2KHR_AddCallback(CMOCK_vkCmdPipelineBarrier2KHR_CALLBACK Callback); +void vkCmdPipelineBarrier2KHR_Stub(CMOCK_vkCmdPipelineBarrier2KHR_CALLBACK Callback); +#define vkCmdPipelineBarrier2KHR_StubWithCallback vkCmdPipelineBarrier2KHR_AddCallback +#define vkCmdPipelineBarrier2KHR_IgnoreArg_commandBuffer() vkCmdPipelineBarrier2KHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdPipelineBarrier2KHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdPipelineBarrier2KHR_IgnoreArg_pDependencyInfo() vkCmdPipelineBarrier2KHR_CMockIgnoreArg_pDependencyInfo(__LINE__) +void vkCmdPipelineBarrier2KHR_CMockIgnoreArg_pDependencyInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteTimestamp2KHR_Ignore() vkCmdWriteTimestamp2KHR_CMockIgnore() +void vkCmdWriteTimestamp2KHR_CMockIgnore(void); +#define vkCmdWriteTimestamp2KHR_StopIgnore() vkCmdWriteTimestamp2KHR_CMockStopIgnore() +void vkCmdWriteTimestamp2KHR_CMockStopIgnore(void); +#define vkCmdWriteTimestamp2KHR_ExpectAnyArgs() vkCmdWriteTimestamp2KHR_CMockExpectAnyArgs(__LINE__) +void vkCmdWriteTimestamp2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteTimestamp2KHR_Expect(commandBuffer, stage, queryPool, query) vkCmdWriteTimestamp2KHR_CMockExpect(__LINE__, commandBuffer, stage, queryPool, query) +void vkCmdWriteTimestamp2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query); +typedef void (* CMOCK_vkCmdWriteTimestamp2KHR_CALLBACK)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query, int cmock_num_calls); +void vkCmdWriteTimestamp2KHR_AddCallback(CMOCK_vkCmdWriteTimestamp2KHR_CALLBACK Callback); +void vkCmdWriteTimestamp2KHR_Stub(CMOCK_vkCmdWriteTimestamp2KHR_CALLBACK Callback); +#define vkCmdWriteTimestamp2KHR_StubWithCallback vkCmdWriteTimestamp2KHR_AddCallback +#define vkCmdWriteTimestamp2KHR_IgnoreArg_commandBuffer() vkCmdWriteTimestamp2KHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdWriteTimestamp2KHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteTimestamp2KHR_IgnoreArg_stage() vkCmdWriteTimestamp2KHR_CMockIgnoreArg_stage(__LINE__) +void vkCmdWriteTimestamp2KHR_CMockIgnoreArg_stage(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteTimestamp2KHR_IgnoreArg_queryPool() vkCmdWriteTimestamp2KHR_CMockIgnoreArg_queryPool(__LINE__) +void vkCmdWriteTimestamp2KHR_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteTimestamp2KHR_IgnoreArg_query() vkCmdWriteTimestamp2KHR_CMockIgnoreArg_query(__LINE__) +void vkCmdWriteTimestamp2KHR_CMockIgnoreArg_query(UNITY_LINE_TYPE cmock_line); +#define vkQueueSubmit2KHR_IgnoreAndReturn(cmock_retval) vkQueueSubmit2KHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkQueueSubmit2KHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkQueueSubmit2KHR_StopIgnore() vkQueueSubmit2KHR_CMockStopIgnore() +void vkQueueSubmit2KHR_CMockStopIgnore(void); +#define vkQueueSubmit2KHR_ExpectAnyArgsAndReturn(cmock_retval) vkQueueSubmit2KHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkQueueSubmit2KHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkQueueSubmit2KHR_ExpectAndReturn(queue, submitCount, pSubmits, fence, cmock_retval) vkQueueSubmit2KHR_CMockExpectAndReturn(__LINE__, queue, submitCount, pSubmits, fence, cmock_retval) +void vkQueueSubmit2KHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkQueueSubmit2KHR_CALLBACK)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence, int cmock_num_calls); +void vkQueueSubmit2KHR_AddCallback(CMOCK_vkQueueSubmit2KHR_CALLBACK Callback); +void vkQueueSubmit2KHR_Stub(CMOCK_vkQueueSubmit2KHR_CALLBACK Callback); +#define vkQueueSubmit2KHR_StubWithCallback vkQueueSubmit2KHR_AddCallback +#define vkQueueSubmit2KHR_IgnoreArg_queue() vkQueueSubmit2KHR_CMockIgnoreArg_queue(__LINE__) +void vkQueueSubmit2KHR_CMockIgnoreArg_queue(UNITY_LINE_TYPE cmock_line); +#define vkQueueSubmit2KHR_IgnoreArg_submitCount() vkQueueSubmit2KHR_CMockIgnoreArg_submitCount(__LINE__) +void vkQueueSubmit2KHR_CMockIgnoreArg_submitCount(UNITY_LINE_TYPE cmock_line); +#define vkQueueSubmit2KHR_IgnoreArg_pSubmits() vkQueueSubmit2KHR_CMockIgnoreArg_pSubmits(__LINE__) +void vkQueueSubmit2KHR_CMockIgnoreArg_pSubmits(UNITY_LINE_TYPE cmock_line); +#define vkQueueSubmit2KHR_IgnoreArg_fence() vkQueueSubmit2KHR_CMockIgnoreArg_fence(__LINE__) +void vkQueueSubmit2KHR_CMockIgnoreArg_fence(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteBufferMarker2AMD_Ignore() vkCmdWriteBufferMarker2AMD_CMockIgnore() +void vkCmdWriteBufferMarker2AMD_CMockIgnore(void); +#define vkCmdWriteBufferMarker2AMD_StopIgnore() vkCmdWriteBufferMarker2AMD_CMockStopIgnore() +void vkCmdWriteBufferMarker2AMD_CMockStopIgnore(void); +#define vkCmdWriteBufferMarker2AMD_ExpectAnyArgs() vkCmdWriteBufferMarker2AMD_CMockExpectAnyArgs(__LINE__) +void vkCmdWriteBufferMarker2AMD_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteBufferMarker2AMD_Expect(commandBuffer, stage, dstBuffer, dstOffset, marker) vkCmdWriteBufferMarker2AMD_CMockExpect(__LINE__, commandBuffer, stage, dstBuffer, dstOffset, marker) +void vkCmdWriteBufferMarker2AMD_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker); +typedef void (* CMOCK_vkCmdWriteBufferMarker2AMD_CALLBACK)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker, int cmock_num_calls); +void vkCmdWriteBufferMarker2AMD_AddCallback(CMOCK_vkCmdWriteBufferMarker2AMD_CALLBACK Callback); +void vkCmdWriteBufferMarker2AMD_Stub(CMOCK_vkCmdWriteBufferMarker2AMD_CALLBACK Callback); +#define vkCmdWriteBufferMarker2AMD_StubWithCallback vkCmdWriteBufferMarker2AMD_AddCallback +#define vkCmdWriteBufferMarker2AMD_IgnoreArg_commandBuffer() vkCmdWriteBufferMarker2AMD_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdWriteBufferMarker2AMD_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteBufferMarker2AMD_IgnoreArg_stage() vkCmdWriteBufferMarker2AMD_CMockIgnoreArg_stage(__LINE__) +void vkCmdWriteBufferMarker2AMD_CMockIgnoreArg_stage(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteBufferMarker2AMD_IgnoreArg_dstBuffer() vkCmdWriteBufferMarker2AMD_CMockIgnoreArg_dstBuffer(__LINE__) +void vkCmdWriteBufferMarker2AMD_CMockIgnoreArg_dstBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteBufferMarker2AMD_IgnoreArg_dstOffset() vkCmdWriteBufferMarker2AMD_CMockIgnoreArg_dstOffset(__LINE__) +void vkCmdWriteBufferMarker2AMD_CMockIgnoreArg_dstOffset(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteBufferMarker2AMD_IgnoreArg_marker() vkCmdWriteBufferMarker2AMD_CMockIgnoreArg_marker(__LINE__) +void vkCmdWriteBufferMarker2AMD_CMockIgnoreArg_marker(UNITY_LINE_TYPE cmock_line); +#define vkGetQueueCheckpointData2NV_Ignore() vkGetQueueCheckpointData2NV_CMockIgnore() +void vkGetQueueCheckpointData2NV_CMockIgnore(void); +#define vkGetQueueCheckpointData2NV_StopIgnore() vkGetQueueCheckpointData2NV_CMockStopIgnore() +void vkGetQueueCheckpointData2NV_CMockStopIgnore(void); +#define vkGetQueueCheckpointData2NV_ExpectAnyArgs() vkGetQueueCheckpointData2NV_CMockExpectAnyArgs(__LINE__) +void vkGetQueueCheckpointData2NV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetQueueCheckpointData2NV_Expect(queue, pCheckpointDataCount, pCheckpointData) vkGetQueueCheckpointData2NV_CMockExpect(__LINE__, queue, pCheckpointDataCount, pCheckpointData) +void vkGetQueueCheckpointData2NV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData); +typedef void (* CMOCK_vkGetQueueCheckpointData2NV_CALLBACK)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData, int cmock_num_calls); +void vkGetQueueCheckpointData2NV_AddCallback(CMOCK_vkGetQueueCheckpointData2NV_CALLBACK Callback); +void vkGetQueueCheckpointData2NV_Stub(CMOCK_vkGetQueueCheckpointData2NV_CALLBACK Callback); +#define vkGetQueueCheckpointData2NV_StubWithCallback vkGetQueueCheckpointData2NV_AddCallback +#define vkGetQueueCheckpointData2NV_ReturnThruPtr_pCheckpointDataCount(pCheckpointDataCount) vkGetQueueCheckpointData2NV_CMockReturnMemThruPtr_pCheckpointDataCount(__LINE__, pCheckpointDataCount, sizeof(uint32_t)) +#define vkGetQueueCheckpointData2NV_ReturnArrayThruPtr_pCheckpointDataCount(pCheckpointDataCount, cmock_len) vkGetQueueCheckpointData2NV_CMockReturnMemThruPtr_pCheckpointDataCount(__LINE__, pCheckpointDataCount, cmock_len * sizeof(*pCheckpointDataCount)) +#define vkGetQueueCheckpointData2NV_ReturnMemThruPtr_pCheckpointDataCount(pCheckpointDataCount, cmock_size) vkGetQueueCheckpointData2NV_CMockReturnMemThruPtr_pCheckpointDataCount(__LINE__, pCheckpointDataCount, cmock_size) +void vkGetQueueCheckpointData2NV_CMockReturnMemThruPtr_pCheckpointDataCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pCheckpointDataCount, size_t cmock_size); +#define vkGetQueueCheckpointData2NV_ReturnThruPtr_pCheckpointData(pCheckpointData) vkGetQueueCheckpointData2NV_CMockReturnMemThruPtr_pCheckpointData(__LINE__, pCheckpointData, sizeof(VkCheckpointData2NV)) +#define vkGetQueueCheckpointData2NV_ReturnArrayThruPtr_pCheckpointData(pCheckpointData, cmock_len) vkGetQueueCheckpointData2NV_CMockReturnMemThruPtr_pCheckpointData(__LINE__, pCheckpointData, cmock_len * sizeof(*pCheckpointData)) +#define vkGetQueueCheckpointData2NV_ReturnMemThruPtr_pCheckpointData(pCheckpointData, cmock_size) vkGetQueueCheckpointData2NV_CMockReturnMemThruPtr_pCheckpointData(__LINE__, pCheckpointData, cmock_size) +void vkGetQueueCheckpointData2NV_CMockReturnMemThruPtr_pCheckpointData(UNITY_LINE_TYPE cmock_line, VkCheckpointData2NV const* pCheckpointData, size_t cmock_size); +#define vkGetQueueCheckpointData2NV_IgnoreArg_queue() vkGetQueueCheckpointData2NV_CMockIgnoreArg_queue(__LINE__) +void vkGetQueueCheckpointData2NV_CMockIgnoreArg_queue(UNITY_LINE_TYPE cmock_line); +#define vkGetQueueCheckpointData2NV_IgnoreArg_pCheckpointDataCount() vkGetQueueCheckpointData2NV_CMockIgnoreArg_pCheckpointDataCount(__LINE__) +void vkGetQueueCheckpointData2NV_CMockIgnoreArg_pCheckpointDataCount(UNITY_LINE_TYPE cmock_line); +#define vkGetQueueCheckpointData2NV_IgnoreArg_pCheckpointData() vkGetQueueCheckpointData2NV_CMockIgnoreArg_pCheckpointData(__LINE__) +void vkGetQueueCheckpointData2NV_CMockIgnoreArg_pCheckpointData(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyBuffer2KHR_Ignore() vkCmdCopyBuffer2KHR_CMockIgnore() +void vkCmdCopyBuffer2KHR_CMockIgnore(void); +#define vkCmdCopyBuffer2KHR_StopIgnore() vkCmdCopyBuffer2KHR_CMockStopIgnore() +void vkCmdCopyBuffer2KHR_CMockStopIgnore(void); +#define vkCmdCopyBuffer2KHR_ExpectAnyArgs() vkCmdCopyBuffer2KHR_CMockExpectAnyArgs(__LINE__) +void vkCmdCopyBuffer2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyBuffer2KHR_Expect(commandBuffer, pCopyBufferInfo) vkCmdCopyBuffer2KHR_CMockExpect(__LINE__, commandBuffer, pCopyBufferInfo) +void vkCmdCopyBuffer2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo); +typedef void (* CMOCK_vkCmdCopyBuffer2KHR_CALLBACK)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo, int cmock_num_calls); +void vkCmdCopyBuffer2KHR_AddCallback(CMOCK_vkCmdCopyBuffer2KHR_CALLBACK Callback); +void vkCmdCopyBuffer2KHR_Stub(CMOCK_vkCmdCopyBuffer2KHR_CALLBACK Callback); +#define vkCmdCopyBuffer2KHR_StubWithCallback vkCmdCopyBuffer2KHR_AddCallback +#define vkCmdCopyBuffer2KHR_IgnoreArg_commandBuffer() vkCmdCopyBuffer2KHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdCopyBuffer2KHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyBuffer2KHR_IgnoreArg_pCopyBufferInfo() vkCmdCopyBuffer2KHR_CMockIgnoreArg_pCopyBufferInfo(__LINE__) +void vkCmdCopyBuffer2KHR_CMockIgnoreArg_pCopyBufferInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyImage2KHR_Ignore() vkCmdCopyImage2KHR_CMockIgnore() +void vkCmdCopyImage2KHR_CMockIgnore(void); +#define vkCmdCopyImage2KHR_StopIgnore() vkCmdCopyImage2KHR_CMockStopIgnore() +void vkCmdCopyImage2KHR_CMockStopIgnore(void); +#define vkCmdCopyImage2KHR_ExpectAnyArgs() vkCmdCopyImage2KHR_CMockExpectAnyArgs(__LINE__) +void vkCmdCopyImage2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyImage2KHR_Expect(commandBuffer, pCopyImageInfo) vkCmdCopyImage2KHR_CMockExpect(__LINE__, commandBuffer, pCopyImageInfo) +void vkCmdCopyImage2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo); +typedef void (* CMOCK_vkCmdCopyImage2KHR_CALLBACK)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo, int cmock_num_calls); +void vkCmdCopyImage2KHR_AddCallback(CMOCK_vkCmdCopyImage2KHR_CALLBACK Callback); +void vkCmdCopyImage2KHR_Stub(CMOCK_vkCmdCopyImage2KHR_CALLBACK Callback); +#define vkCmdCopyImage2KHR_StubWithCallback vkCmdCopyImage2KHR_AddCallback +#define vkCmdCopyImage2KHR_IgnoreArg_commandBuffer() vkCmdCopyImage2KHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdCopyImage2KHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyImage2KHR_IgnoreArg_pCopyImageInfo() vkCmdCopyImage2KHR_CMockIgnoreArg_pCopyImageInfo(__LINE__) +void vkCmdCopyImage2KHR_CMockIgnoreArg_pCopyImageInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyBufferToImage2KHR_Ignore() vkCmdCopyBufferToImage2KHR_CMockIgnore() +void vkCmdCopyBufferToImage2KHR_CMockIgnore(void); +#define vkCmdCopyBufferToImage2KHR_StopIgnore() vkCmdCopyBufferToImage2KHR_CMockStopIgnore() +void vkCmdCopyBufferToImage2KHR_CMockStopIgnore(void); +#define vkCmdCopyBufferToImage2KHR_ExpectAnyArgs() vkCmdCopyBufferToImage2KHR_CMockExpectAnyArgs(__LINE__) +void vkCmdCopyBufferToImage2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyBufferToImage2KHR_Expect(commandBuffer, pCopyBufferToImageInfo) vkCmdCopyBufferToImage2KHR_CMockExpect(__LINE__, commandBuffer, pCopyBufferToImageInfo) +void vkCmdCopyBufferToImage2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); +typedef void (* CMOCK_vkCmdCopyBufferToImage2KHR_CALLBACK)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo, int cmock_num_calls); +void vkCmdCopyBufferToImage2KHR_AddCallback(CMOCK_vkCmdCopyBufferToImage2KHR_CALLBACK Callback); +void vkCmdCopyBufferToImage2KHR_Stub(CMOCK_vkCmdCopyBufferToImage2KHR_CALLBACK Callback); +#define vkCmdCopyBufferToImage2KHR_StubWithCallback vkCmdCopyBufferToImage2KHR_AddCallback +#define vkCmdCopyBufferToImage2KHR_IgnoreArg_commandBuffer() vkCmdCopyBufferToImage2KHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdCopyBufferToImage2KHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyBufferToImage2KHR_IgnoreArg_pCopyBufferToImageInfo() vkCmdCopyBufferToImage2KHR_CMockIgnoreArg_pCopyBufferToImageInfo(__LINE__) +void vkCmdCopyBufferToImage2KHR_CMockIgnoreArg_pCopyBufferToImageInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyImageToBuffer2KHR_Ignore() vkCmdCopyImageToBuffer2KHR_CMockIgnore() +void vkCmdCopyImageToBuffer2KHR_CMockIgnore(void); +#define vkCmdCopyImageToBuffer2KHR_StopIgnore() vkCmdCopyImageToBuffer2KHR_CMockStopIgnore() +void vkCmdCopyImageToBuffer2KHR_CMockStopIgnore(void); +#define vkCmdCopyImageToBuffer2KHR_ExpectAnyArgs() vkCmdCopyImageToBuffer2KHR_CMockExpectAnyArgs(__LINE__) +void vkCmdCopyImageToBuffer2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyImageToBuffer2KHR_Expect(commandBuffer, pCopyImageToBufferInfo) vkCmdCopyImageToBuffer2KHR_CMockExpect(__LINE__, commandBuffer, pCopyImageToBufferInfo) +void vkCmdCopyImageToBuffer2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); +typedef void (* CMOCK_vkCmdCopyImageToBuffer2KHR_CALLBACK)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo, int cmock_num_calls); +void vkCmdCopyImageToBuffer2KHR_AddCallback(CMOCK_vkCmdCopyImageToBuffer2KHR_CALLBACK Callback); +void vkCmdCopyImageToBuffer2KHR_Stub(CMOCK_vkCmdCopyImageToBuffer2KHR_CALLBACK Callback); +#define vkCmdCopyImageToBuffer2KHR_StubWithCallback vkCmdCopyImageToBuffer2KHR_AddCallback +#define vkCmdCopyImageToBuffer2KHR_IgnoreArg_commandBuffer() vkCmdCopyImageToBuffer2KHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdCopyImageToBuffer2KHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyImageToBuffer2KHR_IgnoreArg_pCopyImageToBufferInfo() vkCmdCopyImageToBuffer2KHR_CMockIgnoreArg_pCopyImageToBufferInfo(__LINE__) +void vkCmdCopyImageToBuffer2KHR_CMockIgnoreArg_pCopyImageToBufferInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdBlitImage2KHR_Ignore() vkCmdBlitImage2KHR_CMockIgnore() +void vkCmdBlitImage2KHR_CMockIgnore(void); +#define vkCmdBlitImage2KHR_StopIgnore() vkCmdBlitImage2KHR_CMockStopIgnore() +void vkCmdBlitImage2KHR_CMockStopIgnore(void); +#define vkCmdBlitImage2KHR_ExpectAnyArgs() vkCmdBlitImage2KHR_CMockExpectAnyArgs(__LINE__) +void vkCmdBlitImage2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBlitImage2KHR_Expect(commandBuffer, pBlitImageInfo) vkCmdBlitImage2KHR_CMockExpect(__LINE__, commandBuffer, pBlitImageInfo) +void vkCmdBlitImage2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo); +typedef void (* CMOCK_vkCmdBlitImage2KHR_CALLBACK)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo, int cmock_num_calls); +void vkCmdBlitImage2KHR_AddCallback(CMOCK_vkCmdBlitImage2KHR_CALLBACK Callback); +void vkCmdBlitImage2KHR_Stub(CMOCK_vkCmdBlitImage2KHR_CALLBACK Callback); +#define vkCmdBlitImage2KHR_StubWithCallback vkCmdBlitImage2KHR_AddCallback +#define vkCmdBlitImage2KHR_IgnoreArg_commandBuffer() vkCmdBlitImage2KHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBlitImage2KHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBlitImage2KHR_IgnoreArg_pBlitImageInfo() vkCmdBlitImage2KHR_CMockIgnoreArg_pBlitImageInfo(__LINE__) +void vkCmdBlitImage2KHR_CMockIgnoreArg_pBlitImageInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdResolveImage2KHR_Ignore() vkCmdResolveImage2KHR_CMockIgnore() +void vkCmdResolveImage2KHR_CMockIgnore(void); +#define vkCmdResolveImage2KHR_StopIgnore() vkCmdResolveImage2KHR_CMockStopIgnore() +void vkCmdResolveImage2KHR_CMockStopIgnore(void); +#define vkCmdResolveImage2KHR_ExpectAnyArgs() vkCmdResolveImage2KHR_CMockExpectAnyArgs(__LINE__) +void vkCmdResolveImage2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdResolveImage2KHR_Expect(commandBuffer, pResolveImageInfo) vkCmdResolveImage2KHR_CMockExpect(__LINE__, commandBuffer, pResolveImageInfo) +void vkCmdResolveImage2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo); +typedef void (* CMOCK_vkCmdResolveImage2KHR_CALLBACK)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo, int cmock_num_calls); +void vkCmdResolveImage2KHR_AddCallback(CMOCK_vkCmdResolveImage2KHR_CALLBACK Callback); +void vkCmdResolveImage2KHR_Stub(CMOCK_vkCmdResolveImage2KHR_CALLBACK Callback); +#define vkCmdResolveImage2KHR_StubWithCallback vkCmdResolveImage2KHR_AddCallback +#define vkCmdResolveImage2KHR_IgnoreArg_commandBuffer() vkCmdResolveImage2KHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdResolveImage2KHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdResolveImage2KHR_IgnoreArg_pResolveImageInfo() vkCmdResolveImage2KHR_CMockIgnoreArg_pResolveImageInfo(__LINE__) +void vkCmdResolveImage2KHR_CMockIgnoreArg_pResolveImageInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysIndirect2KHR_Ignore() vkCmdTraceRaysIndirect2KHR_CMockIgnore() +void vkCmdTraceRaysIndirect2KHR_CMockIgnore(void); +#define vkCmdTraceRaysIndirect2KHR_StopIgnore() vkCmdTraceRaysIndirect2KHR_CMockStopIgnore() +void vkCmdTraceRaysIndirect2KHR_CMockStopIgnore(void); +#define vkCmdTraceRaysIndirect2KHR_ExpectAnyArgs() vkCmdTraceRaysIndirect2KHR_CMockExpectAnyArgs(__LINE__) +void vkCmdTraceRaysIndirect2KHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysIndirect2KHR_Expect(commandBuffer, indirectDeviceAddress) vkCmdTraceRaysIndirect2KHR_CMockExpect(__LINE__, commandBuffer, indirectDeviceAddress) +void vkCmdTraceRaysIndirect2KHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress); +typedef void (* CMOCK_vkCmdTraceRaysIndirect2KHR_CALLBACK)(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress, int cmock_num_calls); +void vkCmdTraceRaysIndirect2KHR_AddCallback(CMOCK_vkCmdTraceRaysIndirect2KHR_CALLBACK Callback); +void vkCmdTraceRaysIndirect2KHR_Stub(CMOCK_vkCmdTraceRaysIndirect2KHR_CALLBACK Callback); +#define vkCmdTraceRaysIndirect2KHR_StubWithCallback vkCmdTraceRaysIndirect2KHR_AddCallback +#define vkCmdTraceRaysIndirect2KHR_IgnoreArg_commandBuffer() vkCmdTraceRaysIndirect2KHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdTraceRaysIndirect2KHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysIndirect2KHR_IgnoreArg_indirectDeviceAddress() vkCmdTraceRaysIndirect2KHR_CMockIgnoreArg_indirectDeviceAddress(__LINE__) +void vkCmdTraceRaysIndirect2KHR_CMockIgnoreArg_indirectDeviceAddress(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceBufferMemoryRequirementsKHR_Ignore() vkGetDeviceBufferMemoryRequirementsKHR_CMockIgnore() +void vkGetDeviceBufferMemoryRequirementsKHR_CMockIgnore(void); +#define vkGetDeviceBufferMemoryRequirementsKHR_StopIgnore() vkGetDeviceBufferMemoryRequirementsKHR_CMockStopIgnore() +void vkGetDeviceBufferMemoryRequirementsKHR_CMockStopIgnore(void); +#define vkGetDeviceBufferMemoryRequirementsKHR_ExpectAnyArgs() vkGetDeviceBufferMemoryRequirementsKHR_CMockExpectAnyArgs(__LINE__) +void vkGetDeviceBufferMemoryRequirementsKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceBufferMemoryRequirementsKHR_Expect(device, pInfo, pMemoryRequirements) vkGetDeviceBufferMemoryRequirementsKHR_CMockExpect(__LINE__, device, pInfo, pMemoryRequirements) +void vkGetDeviceBufferMemoryRequirementsKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (* CMOCK_vkGetDeviceBufferMemoryRequirementsKHR_CALLBACK)(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements, int cmock_num_calls); +void vkGetDeviceBufferMemoryRequirementsKHR_AddCallback(CMOCK_vkGetDeviceBufferMemoryRequirementsKHR_CALLBACK Callback); +void vkGetDeviceBufferMemoryRequirementsKHR_Stub(CMOCK_vkGetDeviceBufferMemoryRequirementsKHR_CALLBACK Callback); +#define vkGetDeviceBufferMemoryRequirementsKHR_StubWithCallback vkGetDeviceBufferMemoryRequirementsKHR_AddCallback +#define vkGetDeviceBufferMemoryRequirementsKHR_ReturnThruPtr_pMemoryRequirements(pMemoryRequirements) vkGetDeviceBufferMemoryRequirementsKHR_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, sizeof(VkMemoryRequirements2)) +#define vkGetDeviceBufferMemoryRequirementsKHR_ReturnArrayThruPtr_pMemoryRequirements(pMemoryRequirements, cmock_len) vkGetDeviceBufferMemoryRequirementsKHR_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, cmock_len * sizeof(*pMemoryRequirements)) +#define vkGetDeviceBufferMemoryRequirementsKHR_ReturnMemThruPtr_pMemoryRequirements(pMemoryRequirements, cmock_size) vkGetDeviceBufferMemoryRequirementsKHR_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, cmock_size) +void vkGetDeviceBufferMemoryRequirementsKHR_CMockReturnMemThruPtr_pMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkMemoryRequirements2 const* pMemoryRequirements, size_t cmock_size); +#define vkGetDeviceBufferMemoryRequirementsKHR_IgnoreArg_device() vkGetDeviceBufferMemoryRequirementsKHR_CMockIgnoreArg_device(__LINE__) +void vkGetDeviceBufferMemoryRequirementsKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceBufferMemoryRequirementsKHR_IgnoreArg_pInfo() vkGetDeviceBufferMemoryRequirementsKHR_CMockIgnoreArg_pInfo(__LINE__) +void vkGetDeviceBufferMemoryRequirementsKHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceBufferMemoryRequirementsKHR_IgnoreArg_pMemoryRequirements() vkGetDeviceBufferMemoryRequirementsKHR_CMockIgnoreArg_pMemoryRequirements(__LINE__) +void vkGetDeviceBufferMemoryRequirementsKHR_CMockIgnoreArg_pMemoryRequirements(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceImageMemoryRequirementsKHR_Ignore() vkGetDeviceImageMemoryRequirementsKHR_CMockIgnore() +void vkGetDeviceImageMemoryRequirementsKHR_CMockIgnore(void); +#define vkGetDeviceImageMemoryRequirementsKHR_StopIgnore() vkGetDeviceImageMemoryRequirementsKHR_CMockStopIgnore() +void vkGetDeviceImageMemoryRequirementsKHR_CMockStopIgnore(void); +#define vkGetDeviceImageMemoryRequirementsKHR_ExpectAnyArgs() vkGetDeviceImageMemoryRequirementsKHR_CMockExpectAnyArgs(__LINE__) +void vkGetDeviceImageMemoryRequirementsKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceImageMemoryRequirementsKHR_Expect(device, pInfo, pMemoryRequirements) vkGetDeviceImageMemoryRequirementsKHR_CMockExpect(__LINE__, device, pInfo, pMemoryRequirements) +void vkGetDeviceImageMemoryRequirementsKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (* CMOCK_vkGetDeviceImageMemoryRequirementsKHR_CALLBACK)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements, int cmock_num_calls); +void vkGetDeviceImageMemoryRequirementsKHR_AddCallback(CMOCK_vkGetDeviceImageMemoryRequirementsKHR_CALLBACK Callback); +void vkGetDeviceImageMemoryRequirementsKHR_Stub(CMOCK_vkGetDeviceImageMemoryRequirementsKHR_CALLBACK Callback); +#define vkGetDeviceImageMemoryRequirementsKHR_StubWithCallback vkGetDeviceImageMemoryRequirementsKHR_AddCallback +#define vkGetDeviceImageMemoryRequirementsKHR_ReturnThruPtr_pMemoryRequirements(pMemoryRequirements) vkGetDeviceImageMemoryRequirementsKHR_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, sizeof(VkMemoryRequirements2)) +#define vkGetDeviceImageMemoryRequirementsKHR_ReturnArrayThruPtr_pMemoryRequirements(pMemoryRequirements, cmock_len) vkGetDeviceImageMemoryRequirementsKHR_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, cmock_len * sizeof(*pMemoryRequirements)) +#define vkGetDeviceImageMemoryRequirementsKHR_ReturnMemThruPtr_pMemoryRequirements(pMemoryRequirements, cmock_size) vkGetDeviceImageMemoryRequirementsKHR_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, cmock_size) +void vkGetDeviceImageMemoryRequirementsKHR_CMockReturnMemThruPtr_pMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkMemoryRequirements2 const* pMemoryRequirements, size_t cmock_size); +#define vkGetDeviceImageMemoryRequirementsKHR_IgnoreArg_device() vkGetDeviceImageMemoryRequirementsKHR_CMockIgnoreArg_device(__LINE__) +void vkGetDeviceImageMemoryRequirementsKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceImageMemoryRequirementsKHR_IgnoreArg_pInfo() vkGetDeviceImageMemoryRequirementsKHR_CMockIgnoreArg_pInfo(__LINE__) +void vkGetDeviceImageMemoryRequirementsKHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceImageMemoryRequirementsKHR_IgnoreArg_pMemoryRequirements() vkGetDeviceImageMemoryRequirementsKHR_CMockIgnoreArg_pMemoryRequirements(__LINE__) +void vkGetDeviceImageMemoryRequirementsKHR_CMockIgnoreArg_pMemoryRequirements(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceImageSparseMemoryRequirementsKHR_Ignore() vkGetDeviceImageSparseMemoryRequirementsKHR_CMockIgnore() +void vkGetDeviceImageSparseMemoryRequirementsKHR_CMockIgnore(void); +#define vkGetDeviceImageSparseMemoryRequirementsKHR_StopIgnore() vkGetDeviceImageSparseMemoryRequirementsKHR_CMockStopIgnore() +void vkGetDeviceImageSparseMemoryRequirementsKHR_CMockStopIgnore(void); +#define vkGetDeviceImageSparseMemoryRequirementsKHR_ExpectAnyArgs() vkGetDeviceImageSparseMemoryRequirementsKHR_CMockExpectAnyArgs(__LINE__) +void vkGetDeviceImageSparseMemoryRequirementsKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceImageSparseMemoryRequirementsKHR_Expect(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements) vkGetDeviceImageSparseMemoryRequirementsKHR_CMockExpect(__LINE__, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements) +void vkGetDeviceImageSparseMemoryRequirementsKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +typedef void (* CMOCK_vkGetDeviceImageSparseMemoryRequirementsKHR_CALLBACK)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, int cmock_num_calls); +void vkGetDeviceImageSparseMemoryRequirementsKHR_AddCallback(CMOCK_vkGetDeviceImageSparseMemoryRequirementsKHR_CALLBACK Callback); +void vkGetDeviceImageSparseMemoryRequirementsKHR_Stub(CMOCK_vkGetDeviceImageSparseMemoryRequirementsKHR_CALLBACK Callback); +#define vkGetDeviceImageSparseMemoryRequirementsKHR_StubWithCallback vkGetDeviceImageSparseMemoryRequirementsKHR_AddCallback +#define vkGetDeviceImageSparseMemoryRequirementsKHR_ReturnThruPtr_pSparseMemoryRequirementCount(pSparseMemoryRequirementCount) vkGetDeviceImageSparseMemoryRequirementsKHR_CMockReturnMemThruPtr_pSparseMemoryRequirementCount(__LINE__, pSparseMemoryRequirementCount, sizeof(uint32_t)) +#define vkGetDeviceImageSparseMemoryRequirementsKHR_ReturnArrayThruPtr_pSparseMemoryRequirementCount(pSparseMemoryRequirementCount, cmock_len) vkGetDeviceImageSparseMemoryRequirementsKHR_CMockReturnMemThruPtr_pSparseMemoryRequirementCount(__LINE__, pSparseMemoryRequirementCount, cmock_len * sizeof(*pSparseMemoryRequirementCount)) +#define vkGetDeviceImageSparseMemoryRequirementsKHR_ReturnMemThruPtr_pSparseMemoryRequirementCount(pSparseMemoryRequirementCount, cmock_size) vkGetDeviceImageSparseMemoryRequirementsKHR_CMockReturnMemThruPtr_pSparseMemoryRequirementCount(__LINE__, pSparseMemoryRequirementCount, cmock_size) +void vkGetDeviceImageSparseMemoryRequirementsKHR_CMockReturnMemThruPtr_pSparseMemoryRequirementCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pSparseMemoryRequirementCount, size_t cmock_size); +#define vkGetDeviceImageSparseMemoryRequirementsKHR_ReturnThruPtr_pSparseMemoryRequirements(pSparseMemoryRequirements) vkGetDeviceImageSparseMemoryRequirementsKHR_CMockReturnMemThruPtr_pSparseMemoryRequirements(__LINE__, pSparseMemoryRequirements, sizeof(VkSparseImageMemoryRequirements2)) +#define vkGetDeviceImageSparseMemoryRequirementsKHR_ReturnArrayThruPtr_pSparseMemoryRequirements(pSparseMemoryRequirements, cmock_len) vkGetDeviceImageSparseMemoryRequirementsKHR_CMockReturnMemThruPtr_pSparseMemoryRequirements(__LINE__, pSparseMemoryRequirements, cmock_len * sizeof(*pSparseMemoryRequirements)) +#define vkGetDeviceImageSparseMemoryRequirementsKHR_ReturnMemThruPtr_pSparseMemoryRequirements(pSparseMemoryRequirements, cmock_size) vkGetDeviceImageSparseMemoryRequirementsKHR_CMockReturnMemThruPtr_pSparseMemoryRequirements(__LINE__, pSparseMemoryRequirements, cmock_size) +void vkGetDeviceImageSparseMemoryRequirementsKHR_CMockReturnMemThruPtr_pSparseMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkSparseImageMemoryRequirements2 const* pSparseMemoryRequirements, size_t cmock_size); +#define vkGetDeviceImageSparseMemoryRequirementsKHR_IgnoreArg_device() vkGetDeviceImageSparseMemoryRequirementsKHR_CMockIgnoreArg_device(__LINE__) +void vkGetDeviceImageSparseMemoryRequirementsKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceImageSparseMemoryRequirementsKHR_IgnoreArg_pInfo() vkGetDeviceImageSparseMemoryRequirementsKHR_CMockIgnoreArg_pInfo(__LINE__) +void vkGetDeviceImageSparseMemoryRequirementsKHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceImageSparseMemoryRequirementsKHR_IgnoreArg_pSparseMemoryRequirementCount() vkGetDeviceImageSparseMemoryRequirementsKHR_CMockIgnoreArg_pSparseMemoryRequirementCount(__LINE__) +void vkGetDeviceImageSparseMemoryRequirementsKHR_CMockIgnoreArg_pSparseMemoryRequirementCount(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceImageSparseMemoryRequirementsKHR_IgnoreArg_pSparseMemoryRequirements() vkGetDeviceImageSparseMemoryRequirementsKHR_CMockIgnoreArg_pSparseMemoryRequirements(__LINE__) +void vkGetDeviceImageSparseMemoryRequirementsKHR_CMockIgnoreArg_pSparseMemoryRequirements(UNITY_LINE_TYPE cmock_line); +#define vkCreateDebugReportCallbackEXT_IgnoreAndReturn(cmock_retval) vkCreateDebugReportCallbackEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateDebugReportCallbackEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateDebugReportCallbackEXT_StopIgnore() vkCreateDebugReportCallbackEXT_CMockStopIgnore() +void vkCreateDebugReportCallbackEXT_CMockStopIgnore(void); +#define vkCreateDebugReportCallbackEXT_ExpectAnyArgsAndReturn(cmock_retval) vkCreateDebugReportCallbackEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateDebugReportCallbackEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateDebugReportCallbackEXT_ExpectAndReturn(instance, pCreateInfo, pAllocator, pCallback, cmock_retval) vkCreateDebugReportCallbackEXT_CMockExpectAndReturn(__LINE__, instance, pCreateInfo, pAllocator, pCallback, cmock_retval) +void vkCreateDebugReportCallbackEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateDebugReportCallbackEXT_CALLBACK)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback, int cmock_num_calls); +void vkCreateDebugReportCallbackEXT_AddCallback(CMOCK_vkCreateDebugReportCallbackEXT_CALLBACK Callback); +void vkCreateDebugReportCallbackEXT_Stub(CMOCK_vkCreateDebugReportCallbackEXT_CALLBACK Callback); +#define vkCreateDebugReportCallbackEXT_StubWithCallback vkCreateDebugReportCallbackEXT_AddCallback +#define vkCreateDebugReportCallbackEXT_ReturnThruPtr_pCallback(pCallback) vkCreateDebugReportCallbackEXT_CMockReturnMemThruPtr_pCallback(__LINE__, pCallback, sizeof(VkDebugReportCallbackEXT)) +#define vkCreateDebugReportCallbackEXT_ReturnArrayThruPtr_pCallback(pCallback, cmock_len) vkCreateDebugReportCallbackEXT_CMockReturnMemThruPtr_pCallback(__LINE__, pCallback, cmock_len * sizeof(*pCallback)) +#define vkCreateDebugReportCallbackEXT_ReturnMemThruPtr_pCallback(pCallback, cmock_size) vkCreateDebugReportCallbackEXT_CMockReturnMemThruPtr_pCallback(__LINE__, pCallback, cmock_size) +void vkCreateDebugReportCallbackEXT_CMockReturnMemThruPtr_pCallback(UNITY_LINE_TYPE cmock_line, VkDebugReportCallbackEXT const* pCallback, size_t cmock_size); +#define vkCreateDebugReportCallbackEXT_IgnoreArg_instance() vkCreateDebugReportCallbackEXT_CMockIgnoreArg_instance(__LINE__) +void vkCreateDebugReportCallbackEXT_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line); +#define vkCreateDebugReportCallbackEXT_IgnoreArg_pCreateInfo() vkCreateDebugReportCallbackEXT_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateDebugReportCallbackEXT_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateDebugReportCallbackEXT_IgnoreArg_pAllocator() vkCreateDebugReportCallbackEXT_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateDebugReportCallbackEXT_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateDebugReportCallbackEXT_IgnoreArg_pCallback() vkCreateDebugReportCallbackEXT_CMockIgnoreArg_pCallback(__LINE__) +void vkCreateDebugReportCallbackEXT_CMockIgnoreArg_pCallback(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDebugReportCallbackEXT_Ignore() vkDestroyDebugReportCallbackEXT_CMockIgnore() +void vkDestroyDebugReportCallbackEXT_CMockIgnore(void); +#define vkDestroyDebugReportCallbackEXT_StopIgnore() vkDestroyDebugReportCallbackEXT_CMockStopIgnore() +void vkDestroyDebugReportCallbackEXT_CMockStopIgnore(void); +#define vkDestroyDebugReportCallbackEXT_ExpectAnyArgs() vkDestroyDebugReportCallbackEXT_CMockExpectAnyArgs(__LINE__) +void vkDestroyDebugReportCallbackEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDebugReportCallbackEXT_Expect(instance, callback, pAllocator) vkDestroyDebugReportCallbackEXT_CMockExpect(__LINE__, instance, callback, pAllocator) +void vkDestroyDebugReportCallbackEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyDebugReportCallbackEXT_CALLBACK)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyDebugReportCallbackEXT_AddCallback(CMOCK_vkDestroyDebugReportCallbackEXT_CALLBACK Callback); +void vkDestroyDebugReportCallbackEXT_Stub(CMOCK_vkDestroyDebugReportCallbackEXT_CALLBACK Callback); +#define vkDestroyDebugReportCallbackEXT_StubWithCallback vkDestroyDebugReportCallbackEXT_AddCallback +#define vkDestroyDebugReportCallbackEXT_IgnoreArg_instance() vkDestroyDebugReportCallbackEXT_CMockIgnoreArg_instance(__LINE__) +void vkDestroyDebugReportCallbackEXT_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDebugReportCallbackEXT_IgnoreArg_callback() vkDestroyDebugReportCallbackEXT_CMockIgnoreArg_callback(__LINE__) +void vkDestroyDebugReportCallbackEXT_CMockIgnoreArg_callback(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDebugReportCallbackEXT_IgnoreArg_pAllocator() vkDestroyDebugReportCallbackEXT_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyDebugReportCallbackEXT_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkDebugReportMessageEXT_Ignore() vkDebugReportMessageEXT_CMockIgnore() +void vkDebugReportMessageEXT_CMockIgnore(void); +#define vkDebugReportMessageEXT_StopIgnore() vkDebugReportMessageEXT_CMockStopIgnore() +void vkDebugReportMessageEXT_CMockStopIgnore(void); +#define vkDebugReportMessageEXT_ExpectAnyArgs() vkDebugReportMessageEXT_CMockExpectAnyArgs(__LINE__) +void vkDebugReportMessageEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDebugReportMessageEXT_Expect(instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage) vkDebugReportMessageEXT_CMockExpect(__LINE__, instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage) +void vkDebugReportMessageEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage); +typedef void (* CMOCK_vkDebugReportMessageEXT_CALLBACK)(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, int cmock_num_calls); +void vkDebugReportMessageEXT_AddCallback(CMOCK_vkDebugReportMessageEXT_CALLBACK Callback); +void vkDebugReportMessageEXT_Stub(CMOCK_vkDebugReportMessageEXT_CALLBACK Callback); +#define vkDebugReportMessageEXT_StubWithCallback vkDebugReportMessageEXT_AddCallback +#define vkDebugReportMessageEXT_IgnoreArg_instance() vkDebugReportMessageEXT_CMockIgnoreArg_instance(__LINE__) +void vkDebugReportMessageEXT_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line); +#define vkDebugReportMessageEXT_IgnoreArg_flags() vkDebugReportMessageEXT_CMockIgnoreArg_flags(__LINE__) +void vkDebugReportMessageEXT_CMockIgnoreArg_flags(UNITY_LINE_TYPE cmock_line); +#define vkDebugReportMessageEXT_IgnoreArg_objectType() vkDebugReportMessageEXT_CMockIgnoreArg_objectType(__LINE__) +void vkDebugReportMessageEXT_CMockIgnoreArg_objectType(UNITY_LINE_TYPE cmock_line); +#define vkDebugReportMessageEXT_IgnoreArg_object() vkDebugReportMessageEXT_CMockIgnoreArg_object(__LINE__) +void vkDebugReportMessageEXT_CMockIgnoreArg_object(UNITY_LINE_TYPE cmock_line); +#define vkDebugReportMessageEXT_IgnoreArg_location() vkDebugReportMessageEXT_CMockIgnoreArg_location(__LINE__) +void vkDebugReportMessageEXT_CMockIgnoreArg_location(UNITY_LINE_TYPE cmock_line); +#define vkDebugReportMessageEXT_IgnoreArg_messageCode() vkDebugReportMessageEXT_CMockIgnoreArg_messageCode(__LINE__) +void vkDebugReportMessageEXT_CMockIgnoreArg_messageCode(UNITY_LINE_TYPE cmock_line); +#define vkDebugReportMessageEXT_IgnoreArg_pLayerPrefix() vkDebugReportMessageEXT_CMockIgnoreArg_pLayerPrefix(__LINE__) +void vkDebugReportMessageEXT_CMockIgnoreArg_pLayerPrefix(UNITY_LINE_TYPE cmock_line); +#define vkDebugReportMessageEXT_IgnoreArg_pMessage() vkDebugReportMessageEXT_CMockIgnoreArg_pMessage(__LINE__) +void vkDebugReportMessageEXT_CMockIgnoreArg_pMessage(UNITY_LINE_TYPE cmock_line); +#define vkDebugMarkerSetObjectTagEXT_IgnoreAndReturn(cmock_retval) vkDebugMarkerSetObjectTagEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkDebugMarkerSetObjectTagEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkDebugMarkerSetObjectTagEXT_StopIgnore() vkDebugMarkerSetObjectTagEXT_CMockStopIgnore() +void vkDebugMarkerSetObjectTagEXT_CMockStopIgnore(void); +#define vkDebugMarkerSetObjectTagEXT_ExpectAnyArgsAndReturn(cmock_retval) vkDebugMarkerSetObjectTagEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkDebugMarkerSetObjectTagEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkDebugMarkerSetObjectTagEXT_ExpectAndReturn(device, pTagInfo, cmock_retval) vkDebugMarkerSetObjectTagEXT_CMockExpectAndReturn(__LINE__, device, pTagInfo, cmock_retval) +void vkDebugMarkerSetObjectTagEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkDebugMarkerSetObjectTagEXT_CALLBACK)(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo, int cmock_num_calls); +void vkDebugMarkerSetObjectTagEXT_AddCallback(CMOCK_vkDebugMarkerSetObjectTagEXT_CALLBACK Callback); +void vkDebugMarkerSetObjectTagEXT_Stub(CMOCK_vkDebugMarkerSetObjectTagEXT_CALLBACK Callback); +#define vkDebugMarkerSetObjectTagEXT_StubWithCallback vkDebugMarkerSetObjectTagEXT_AddCallback +#define vkDebugMarkerSetObjectTagEXT_IgnoreArg_device() vkDebugMarkerSetObjectTagEXT_CMockIgnoreArg_device(__LINE__) +void vkDebugMarkerSetObjectTagEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDebugMarkerSetObjectTagEXT_IgnoreArg_pTagInfo() vkDebugMarkerSetObjectTagEXT_CMockIgnoreArg_pTagInfo(__LINE__) +void vkDebugMarkerSetObjectTagEXT_CMockIgnoreArg_pTagInfo(UNITY_LINE_TYPE cmock_line); +#define vkDebugMarkerSetObjectNameEXT_IgnoreAndReturn(cmock_retval) vkDebugMarkerSetObjectNameEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkDebugMarkerSetObjectNameEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkDebugMarkerSetObjectNameEXT_StopIgnore() vkDebugMarkerSetObjectNameEXT_CMockStopIgnore() +void vkDebugMarkerSetObjectNameEXT_CMockStopIgnore(void); +#define vkDebugMarkerSetObjectNameEXT_ExpectAnyArgsAndReturn(cmock_retval) vkDebugMarkerSetObjectNameEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkDebugMarkerSetObjectNameEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkDebugMarkerSetObjectNameEXT_ExpectAndReturn(device, pNameInfo, cmock_retval) vkDebugMarkerSetObjectNameEXT_CMockExpectAndReturn(__LINE__, device, pNameInfo, cmock_retval) +void vkDebugMarkerSetObjectNameEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkDebugMarkerSetObjectNameEXT_CALLBACK)(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo, int cmock_num_calls); +void vkDebugMarkerSetObjectNameEXT_AddCallback(CMOCK_vkDebugMarkerSetObjectNameEXT_CALLBACK Callback); +void vkDebugMarkerSetObjectNameEXT_Stub(CMOCK_vkDebugMarkerSetObjectNameEXT_CALLBACK Callback); +#define vkDebugMarkerSetObjectNameEXT_StubWithCallback vkDebugMarkerSetObjectNameEXT_AddCallback +#define vkDebugMarkerSetObjectNameEXT_IgnoreArg_device() vkDebugMarkerSetObjectNameEXT_CMockIgnoreArg_device(__LINE__) +void vkDebugMarkerSetObjectNameEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDebugMarkerSetObjectNameEXT_IgnoreArg_pNameInfo() vkDebugMarkerSetObjectNameEXT_CMockIgnoreArg_pNameInfo(__LINE__) +void vkDebugMarkerSetObjectNameEXT_CMockIgnoreArg_pNameInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdDebugMarkerBeginEXT_Ignore() vkCmdDebugMarkerBeginEXT_CMockIgnore() +void vkCmdDebugMarkerBeginEXT_CMockIgnore(void); +#define vkCmdDebugMarkerBeginEXT_StopIgnore() vkCmdDebugMarkerBeginEXT_CMockStopIgnore() +void vkCmdDebugMarkerBeginEXT_CMockStopIgnore(void); +#define vkCmdDebugMarkerBeginEXT_ExpectAnyArgs() vkCmdDebugMarkerBeginEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdDebugMarkerBeginEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDebugMarkerBeginEXT_Expect(commandBuffer, pMarkerInfo) vkCmdDebugMarkerBeginEXT_CMockExpect(__LINE__, commandBuffer, pMarkerInfo) +void vkCmdDebugMarkerBeginEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); +typedef void (* CMOCK_vkCmdDebugMarkerBeginEXT_CALLBACK)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo, int cmock_num_calls); +void vkCmdDebugMarkerBeginEXT_AddCallback(CMOCK_vkCmdDebugMarkerBeginEXT_CALLBACK Callback); +void vkCmdDebugMarkerBeginEXT_Stub(CMOCK_vkCmdDebugMarkerBeginEXT_CALLBACK Callback); +#define vkCmdDebugMarkerBeginEXT_StubWithCallback vkCmdDebugMarkerBeginEXT_AddCallback +#define vkCmdDebugMarkerBeginEXT_IgnoreArg_commandBuffer() vkCmdDebugMarkerBeginEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDebugMarkerBeginEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDebugMarkerBeginEXT_IgnoreArg_pMarkerInfo() vkCmdDebugMarkerBeginEXT_CMockIgnoreArg_pMarkerInfo(__LINE__) +void vkCmdDebugMarkerBeginEXT_CMockIgnoreArg_pMarkerInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdDebugMarkerEndEXT_Ignore() vkCmdDebugMarkerEndEXT_CMockIgnore() +void vkCmdDebugMarkerEndEXT_CMockIgnore(void); +#define vkCmdDebugMarkerEndEXT_StopIgnore() vkCmdDebugMarkerEndEXT_CMockStopIgnore() +void vkCmdDebugMarkerEndEXT_CMockStopIgnore(void); +#define vkCmdDebugMarkerEndEXT_ExpectAnyArgs() vkCmdDebugMarkerEndEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdDebugMarkerEndEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDebugMarkerEndEXT_Expect(commandBuffer) vkCmdDebugMarkerEndEXT_CMockExpect(__LINE__, commandBuffer) +void vkCmdDebugMarkerEndEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer); +typedef void (* CMOCK_vkCmdDebugMarkerEndEXT_CALLBACK)(VkCommandBuffer commandBuffer, int cmock_num_calls); +void vkCmdDebugMarkerEndEXT_AddCallback(CMOCK_vkCmdDebugMarkerEndEXT_CALLBACK Callback); +void vkCmdDebugMarkerEndEXT_Stub(CMOCK_vkCmdDebugMarkerEndEXT_CALLBACK Callback); +#define vkCmdDebugMarkerEndEXT_StubWithCallback vkCmdDebugMarkerEndEXT_AddCallback +#define vkCmdDebugMarkerEndEXT_IgnoreArg_commandBuffer() vkCmdDebugMarkerEndEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDebugMarkerEndEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDebugMarkerInsertEXT_Ignore() vkCmdDebugMarkerInsertEXT_CMockIgnore() +void vkCmdDebugMarkerInsertEXT_CMockIgnore(void); +#define vkCmdDebugMarkerInsertEXT_StopIgnore() vkCmdDebugMarkerInsertEXT_CMockStopIgnore() +void vkCmdDebugMarkerInsertEXT_CMockStopIgnore(void); +#define vkCmdDebugMarkerInsertEXT_ExpectAnyArgs() vkCmdDebugMarkerInsertEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdDebugMarkerInsertEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDebugMarkerInsertEXT_Expect(commandBuffer, pMarkerInfo) vkCmdDebugMarkerInsertEXT_CMockExpect(__LINE__, commandBuffer, pMarkerInfo) +void vkCmdDebugMarkerInsertEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); +typedef void (* CMOCK_vkCmdDebugMarkerInsertEXT_CALLBACK)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo, int cmock_num_calls); +void vkCmdDebugMarkerInsertEXT_AddCallback(CMOCK_vkCmdDebugMarkerInsertEXT_CALLBACK Callback); +void vkCmdDebugMarkerInsertEXT_Stub(CMOCK_vkCmdDebugMarkerInsertEXT_CALLBACK Callback); +#define vkCmdDebugMarkerInsertEXT_StubWithCallback vkCmdDebugMarkerInsertEXT_AddCallback +#define vkCmdDebugMarkerInsertEXT_IgnoreArg_commandBuffer() vkCmdDebugMarkerInsertEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDebugMarkerInsertEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDebugMarkerInsertEXT_IgnoreArg_pMarkerInfo() vkCmdDebugMarkerInsertEXT_CMockIgnoreArg_pMarkerInfo(__LINE__) +void vkCmdDebugMarkerInsertEXT_CMockIgnoreArg_pMarkerInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindTransformFeedbackBuffersEXT_Ignore() vkCmdBindTransformFeedbackBuffersEXT_CMockIgnore() +void vkCmdBindTransformFeedbackBuffersEXT_CMockIgnore(void); +#define vkCmdBindTransformFeedbackBuffersEXT_StopIgnore() vkCmdBindTransformFeedbackBuffersEXT_CMockStopIgnore() +void vkCmdBindTransformFeedbackBuffersEXT_CMockStopIgnore(void); +#define vkCmdBindTransformFeedbackBuffersEXT_ExpectAnyArgs() vkCmdBindTransformFeedbackBuffersEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdBindTransformFeedbackBuffersEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindTransformFeedbackBuffersEXT_Expect(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes) vkCmdBindTransformFeedbackBuffersEXT_CMockExpect(__LINE__, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes) +void vkCmdBindTransformFeedbackBuffersEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes); +typedef void (* CMOCK_vkCmdBindTransformFeedbackBuffersEXT_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, int cmock_num_calls); +void vkCmdBindTransformFeedbackBuffersEXT_AddCallback(CMOCK_vkCmdBindTransformFeedbackBuffersEXT_CALLBACK Callback); +void vkCmdBindTransformFeedbackBuffersEXT_Stub(CMOCK_vkCmdBindTransformFeedbackBuffersEXT_CALLBACK Callback); +#define vkCmdBindTransformFeedbackBuffersEXT_StubWithCallback vkCmdBindTransformFeedbackBuffersEXT_AddCallback +#define vkCmdBindTransformFeedbackBuffersEXT_IgnoreArg_commandBuffer() vkCmdBindTransformFeedbackBuffersEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBindTransformFeedbackBuffersEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindTransformFeedbackBuffersEXT_IgnoreArg_firstBinding() vkCmdBindTransformFeedbackBuffersEXT_CMockIgnoreArg_firstBinding(__LINE__) +void vkCmdBindTransformFeedbackBuffersEXT_CMockIgnoreArg_firstBinding(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindTransformFeedbackBuffersEXT_IgnoreArg_bindingCount() vkCmdBindTransformFeedbackBuffersEXT_CMockIgnoreArg_bindingCount(__LINE__) +void vkCmdBindTransformFeedbackBuffersEXT_CMockIgnoreArg_bindingCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindTransformFeedbackBuffersEXT_IgnoreArg_pBuffers() vkCmdBindTransformFeedbackBuffersEXT_CMockIgnoreArg_pBuffers(__LINE__) +void vkCmdBindTransformFeedbackBuffersEXT_CMockIgnoreArg_pBuffers(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindTransformFeedbackBuffersEXT_IgnoreArg_pOffsets() vkCmdBindTransformFeedbackBuffersEXT_CMockIgnoreArg_pOffsets(__LINE__) +void vkCmdBindTransformFeedbackBuffersEXT_CMockIgnoreArg_pOffsets(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindTransformFeedbackBuffersEXT_IgnoreArg_pSizes() vkCmdBindTransformFeedbackBuffersEXT_CMockIgnoreArg_pSizes(__LINE__) +void vkCmdBindTransformFeedbackBuffersEXT_CMockIgnoreArg_pSizes(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginTransformFeedbackEXT_Ignore() vkCmdBeginTransformFeedbackEXT_CMockIgnore() +void vkCmdBeginTransformFeedbackEXT_CMockIgnore(void); +#define vkCmdBeginTransformFeedbackEXT_StopIgnore() vkCmdBeginTransformFeedbackEXT_CMockStopIgnore() +void vkCmdBeginTransformFeedbackEXT_CMockStopIgnore(void); +#define vkCmdBeginTransformFeedbackEXT_ExpectAnyArgs() vkCmdBeginTransformFeedbackEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdBeginTransformFeedbackEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginTransformFeedbackEXT_Expect(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets) vkCmdBeginTransformFeedbackEXT_CMockExpect(__LINE__, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets) +void vkCmdBeginTransformFeedbackEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets); +typedef void (* CMOCK_vkCmdBeginTransformFeedbackEXT_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets, int cmock_num_calls); +void vkCmdBeginTransformFeedbackEXT_AddCallback(CMOCK_vkCmdBeginTransformFeedbackEXT_CALLBACK Callback); +void vkCmdBeginTransformFeedbackEXT_Stub(CMOCK_vkCmdBeginTransformFeedbackEXT_CALLBACK Callback); +#define vkCmdBeginTransformFeedbackEXT_StubWithCallback vkCmdBeginTransformFeedbackEXT_AddCallback +#define vkCmdBeginTransformFeedbackEXT_IgnoreArg_commandBuffer() vkCmdBeginTransformFeedbackEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBeginTransformFeedbackEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginTransformFeedbackEXT_IgnoreArg_firstCounterBuffer() vkCmdBeginTransformFeedbackEXT_CMockIgnoreArg_firstCounterBuffer(__LINE__) +void vkCmdBeginTransformFeedbackEXT_CMockIgnoreArg_firstCounterBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginTransformFeedbackEXT_IgnoreArg_counterBufferCount() vkCmdBeginTransformFeedbackEXT_CMockIgnoreArg_counterBufferCount(__LINE__) +void vkCmdBeginTransformFeedbackEXT_CMockIgnoreArg_counterBufferCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginTransformFeedbackEXT_IgnoreArg_pCounterBuffers() vkCmdBeginTransformFeedbackEXT_CMockIgnoreArg_pCounterBuffers(__LINE__) +void vkCmdBeginTransformFeedbackEXT_CMockIgnoreArg_pCounterBuffers(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginTransformFeedbackEXT_IgnoreArg_pCounterBufferOffsets() vkCmdBeginTransformFeedbackEXT_CMockIgnoreArg_pCounterBufferOffsets(__LINE__) +void vkCmdBeginTransformFeedbackEXT_CMockIgnoreArg_pCounterBufferOffsets(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndTransformFeedbackEXT_Ignore() vkCmdEndTransformFeedbackEXT_CMockIgnore() +void vkCmdEndTransformFeedbackEXT_CMockIgnore(void); +#define vkCmdEndTransformFeedbackEXT_StopIgnore() vkCmdEndTransformFeedbackEXT_CMockStopIgnore() +void vkCmdEndTransformFeedbackEXT_CMockStopIgnore(void); +#define vkCmdEndTransformFeedbackEXT_ExpectAnyArgs() vkCmdEndTransformFeedbackEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdEndTransformFeedbackEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndTransformFeedbackEXT_Expect(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets) vkCmdEndTransformFeedbackEXT_CMockExpect(__LINE__, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets) +void vkCmdEndTransformFeedbackEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets); +typedef void (* CMOCK_vkCmdEndTransformFeedbackEXT_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets, int cmock_num_calls); +void vkCmdEndTransformFeedbackEXT_AddCallback(CMOCK_vkCmdEndTransformFeedbackEXT_CALLBACK Callback); +void vkCmdEndTransformFeedbackEXT_Stub(CMOCK_vkCmdEndTransformFeedbackEXT_CALLBACK Callback); +#define vkCmdEndTransformFeedbackEXT_StubWithCallback vkCmdEndTransformFeedbackEXT_AddCallback +#define vkCmdEndTransformFeedbackEXT_IgnoreArg_commandBuffer() vkCmdEndTransformFeedbackEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdEndTransformFeedbackEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndTransformFeedbackEXT_IgnoreArg_firstCounterBuffer() vkCmdEndTransformFeedbackEXT_CMockIgnoreArg_firstCounterBuffer(__LINE__) +void vkCmdEndTransformFeedbackEXT_CMockIgnoreArg_firstCounterBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndTransformFeedbackEXT_IgnoreArg_counterBufferCount() vkCmdEndTransformFeedbackEXT_CMockIgnoreArg_counterBufferCount(__LINE__) +void vkCmdEndTransformFeedbackEXT_CMockIgnoreArg_counterBufferCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndTransformFeedbackEXT_IgnoreArg_pCounterBuffers() vkCmdEndTransformFeedbackEXT_CMockIgnoreArg_pCounterBuffers(__LINE__) +void vkCmdEndTransformFeedbackEXT_CMockIgnoreArg_pCounterBuffers(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndTransformFeedbackEXT_IgnoreArg_pCounterBufferOffsets() vkCmdEndTransformFeedbackEXT_CMockIgnoreArg_pCounterBufferOffsets(__LINE__) +void vkCmdEndTransformFeedbackEXT_CMockIgnoreArg_pCounterBufferOffsets(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginQueryIndexedEXT_Ignore() vkCmdBeginQueryIndexedEXT_CMockIgnore() +void vkCmdBeginQueryIndexedEXT_CMockIgnore(void); +#define vkCmdBeginQueryIndexedEXT_StopIgnore() vkCmdBeginQueryIndexedEXT_CMockStopIgnore() +void vkCmdBeginQueryIndexedEXT_CMockStopIgnore(void); +#define vkCmdBeginQueryIndexedEXT_ExpectAnyArgs() vkCmdBeginQueryIndexedEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdBeginQueryIndexedEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginQueryIndexedEXT_Expect(commandBuffer, queryPool, query, flags, index) vkCmdBeginQueryIndexedEXT_CMockExpect(__LINE__, commandBuffer, queryPool, query, flags, index) +void vkCmdBeginQueryIndexedEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index); +typedef void (* CMOCK_vkCmdBeginQueryIndexedEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index, int cmock_num_calls); +void vkCmdBeginQueryIndexedEXT_AddCallback(CMOCK_vkCmdBeginQueryIndexedEXT_CALLBACK Callback); +void vkCmdBeginQueryIndexedEXT_Stub(CMOCK_vkCmdBeginQueryIndexedEXT_CALLBACK Callback); +#define vkCmdBeginQueryIndexedEXT_StubWithCallback vkCmdBeginQueryIndexedEXT_AddCallback +#define vkCmdBeginQueryIndexedEXT_IgnoreArg_commandBuffer() vkCmdBeginQueryIndexedEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBeginQueryIndexedEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginQueryIndexedEXT_IgnoreArg_queryPool() vkCmdBeginQueryIndexedEXT_CMockIgnoreArg_queryPool(__LINE__) +void vkCmdBeginQueryIndexedEXT_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginQueryIndexedEXT_IgnoreArg_query() vkCmdBeginQueryIndexedEXT_CMockIgnoreArg_query(__LINE__) +void vkCmdBeginQueryIndexedEXT_CMockIgnoreArg_query(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginQueryIndexedEXT_IgnoreArg_flags() vkCmdBeginQueryIndexedEXT_CMockIgnoreArg_flags(__LINE__) +void vkCmdBeginQueryIndexedEXT_CMockIgnoreArg_flags(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginQueryIndexedEXT_IgnoreArg_index() vkCmdBeginQueryIndexedEXT_CMockIgnoreArg_index(__LINE__) +void vkCmdBeginQueryIndexedEXT_CMockIgnoreArg_index(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndQueryIndexedEXT_Ignore() vkCmdEndQueryIndexedEXT_CMockIgnore() +void vkCmdEndQueryIndexedEXT_CMockIgnore(void); +#define vkCmdEndQueryIndexedEXT_StopIgnore() vkCmdEndQueryIndexedEXT_CMockStopIgnore() +void vkCmdEndQueryIndexedEXT_CMockStopIgnore(void); +#define vkCmdEndQueryIndexedEXT_ExpectAnyArgs() vkCmdEndQueryIndexedEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdEndQueryIndexedEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndQueryIndexedEXT_Expect(commandBuffer, queryPool, query, index) vkCmdEndQueryIndexedEXT_CMockExpect(__LINE__, commandBuffer, queryPool, query, index) +void vkCmdEndQueryIndexedEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index); +typedef void (* CMOCK_vkCmdEndQueryIndexedEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index, int cmock_num_calls); +void vkCmdEndQueryIndexedEXT_AddCallback(CMOCK_vkCmdEndQueryIndexedEXT_CALLBACK Callback); +void vkCmdEndQueryIndexedEXT_Stub(CMOCK_vkCmdEndQueryIndexedEXT_CALLBACK Callback); +#define vkCmdEndQueryIndexedEXT_StubWithCallback vkCmdEndQueryIndexedEXT_AddCallback +#define vkCmdEndQueryIndexedEXT_IgnoreArg_commandBuffer() vkCmdEndQueryIndexedEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdEndQueryIndexedEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndQueryIndexedEXT_IgnoreArg_queryPool() vkCmdEndQueryIndexedEXT_CMockIgnoreArg_queryPool(__LINE__) +void vkCmdEndQueryIndexedEXT_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndQueryIndexedEXT_IgnoreArg_query() vkCmdEndQueryIndexedEXT_CMockIgnoreArg_query(__LINE__) +void vkCmdEndQueryIndexedEXT_CMockIgnoreArg_query(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndQueryIndexedEXT_IgnoreArg_index() vkCmdEndQueryIndexedEXT_CMockIgnoreArg_index(__LINE__) +void vkCmdEndQueryIndexedEXT_CMockIgnoreArg_index(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectByteCountEXT_Ignore() vkCmdDrawIndirectByteCountEXT_CMockIgnore() +void vkCmdDrawIndirectByteCountEXT_CMockIgnore(void); +#define vkCmdDrawIndirectByteCountEXT_StopIgnore() vkCmdDrawIndirectByteCountEXT_CMockStopIgnore() +void vkCmdDrawIndirectByteCountEXT_CMockStopIgnore(void); +#define vkCmdDrawIndirectByteCountEXT_ExpectAnyArgs() vkCmdDrawIndirectByteCountEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdDrawIndirectByteCountEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectByteCountEXT_Expect(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride) vkCmdDrawIndirectByteCountEXT_CMockExpect(__LINE__, commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride) +void vkCmdDrawIndirectByteCountEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride); +typedef void (* CMOCK_vkCmdDrawIndirectByteCountEXT_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride, int cmock_num_calls); +void vkCmdDrawIndirectByteCountEXT_AddCallback(CMOCK_vkCmdDrawIndirectByteCountEXT_CALLBACK Callback); +void vkCmdDrawIndirectByteCountEXT_Stub(CMOCK_vkCmdDrawIndirectByteCountEXT_CALLBACK Callback); +#define vkCmdDrawIndirectByteCountEXT_StubWithCallback vkCmdDrawIndirectByteCountEXT_AddCallback +#define vkCmdDrawIndirectByteCountEXT_IgnoreArg_commandBuffer() vkCmdDrawIndirectByteCountEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDrawIndirectByteCountEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectByteCountEXT_IgnoreArg_instanceCount() vkCmdDrawIndirectByteCountEXT_CMockIgnoreArg_instanceCount(__LINE__) +void vkCmdDrawIndirectByteCountEXT_CMockIgnoreArg_instanceCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectByteCountEXT_IgnoreArg_firstInstance() vkCmdDrawIndirectByteCountEXT_CMockIgnoreArg_firstInstance(__LINE__) +void vkCmdDrawIndirectByteCountEXT_CMockIgnoreArg_firstInstance(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectByteCountEXT_IgnoreArg_counterBuffer() vkCmdDrawIndirectByteCountEXT_CMockIgnoreArg_counterBuffer(__LINE__) +void vkCmdDrawIndirectByteCountEXT_CMockIgnoreArg_counterBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectByteCountEXT_IgnoreArg_counterBufferOffset() vkCmdDrawIndirectByteCountEXT_CMockIgnoreArg_counterBufferOffset(__LINE__) +void vkCmdDrawIndirectByteCountEXT_CMockIgnoreArg_counterBufferOffset(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectByteCountEXT_IgnoreArg_counterOffset() vkCmdDrawIndirectByteCountEXT_CMockIgnoreArg_counterOffset(__LINE__) +void vkCmdDrawIndirectByteCountEXT_CMockIgnoreArg_counterOffset(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectByteCountEXT_IgnoreArg_vertexStride() vkCmdDrawIndirectByteCountEXT_CMockIgnoreArg_vertexStride(__LINE__) +void vkCmdDrawIndirectByteCountEXT_CMockIgnoreArg_vertexStride(UNITY_LINE_TYPE cmock_line); +#define vkCreateCuModuleNVX_IgnoreAndReturn(cmock_retval) vkCreateCuModuleNVX_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateCuModuleNVX_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateCuModuleNVX_StopIgnore() vkCreateCuModuleNVX_CMockStopIgnore() +void vkCreateCuModuleNVX_CMockStopIgnore(void); +#define vkCreateCuModuleNVX_ExpectAnyArgsAndReturn(cmock_retval) vkCreateCuModuleNVX_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateCuModuleNVX_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateCuModuleNVX_ExpectAndReturn(device, pCreateInfo, pAllocator, pModule, cmock_retval) vkCreateCuModuleNVX_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pModule, cmock_retval) +void vkCreateCuModuleNVX_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateCuModuleNVX_CALLBACK)(VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule, int cmock_num_calls); +void vkCreateCuModuleNVX_AddCallback(CMOCK_vkCreateCuModuleNVX_CALLBACK Callback); +void vkCreateCuModuleNVX_Stub(CMOCK_vkCreateCuModuleNVX_CALLBACK Callback); +#define vkCreateCuModuleNVX_StubWithCallback vkCreateCuModuleNVX_AddCallback +#define vkCreateCuModuleNVX_ReturnThruPtr_pModule(pModule) vkCreateCuModuleNVX_CMockReturnMemThruPtr_pModule(__LINE__, pModule, sizeof(VkCuModuleNVX)) +#define vkCreateCuModuleNVX_ReturnArrayThruPtr_pModule(pModule, cmock_len) vkCreateCuModuleNVX_CMockReturnMemThruPtr_pModule(__LINE__, pModule, cmock_len * sizeof(*pModule)) +#define vkCreateCuModuleNVX_ReturnMemThruPtr_pModule(pModule, cmock_size) vkCreateCuModuleNVX_CMockReturnMemThruPtr_pModule(__LINE__, pModule, cmock_size) +void vkCreateCuModuleNVX_CMockReturnMemThruPtr_pModule(UNITY_LINE_TYPE cmock_line, VkCuModuleNVX const* pModule, size_t cmock_size); +#define vkCreateCuModuleNVX_IgnoreArg_device() vkCreateCuModuleNVX_CMockIgnoreArg_device(__LINE__) +void vkCreateCuModuleNVX_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateCuModuleNVX_IgnoreArg_pCreateInfo() vkCreateCuModuleNVX_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateCuModuleNVX_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateCuModuleNVX_IgnoreArg_pAllocator() vkCreateCuModuleNVX_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateCuModuleNVX_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateCuModuleNVX_IgnoreArg_pModule() vkCreateCuModuleNVX_CMockIgnoreArg_pModule(__LINE__) +void vkCreateCuModuleNVX_CMockIgnoreArg_pModule(UNITY_LINE_TYPE cmock_line); +#define vkCreateCuFunctionNVX_IgnoreAndReturn(cmock_retval) vkCreateCuFunctionNVX_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateCuFunctionNVX_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateCuFunctionNVX_StopIgnore() vkCreateCuFunctionNVX_CMockStopIgnore() +void vkCreateCuFunctionNVX_CMockStopIgnore(void); +#define vkCreateCuFunctionNVX_ExpectAnyArgsAndReturn(cmock_retval) vkCreateCuFunctionNVX_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateCuFunctionNVX_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateCuFunctionNVX_ExpectAndReturn(device, pCreateInfo, pAllocator, pFunction, cmock_retval) vkCreateCuFunctionNVX_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pFunction, cmock_retval) +void vkCreateCuFunctionNVX_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateCuFunctionNVX_CALLBACK)(VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction, int cmock_num_calls); +void vkCreateCuFunctionNVX_AddCallback(CMOCK_vkCreateCuFunctionNVX_CALLBACK Callback); +void vkCreateCuFunctionNVX_Stub(CMOCK_vkCreateCuFunctionNVX_CALLBACK Callback); +#define vkCreateCuFunctionNVX_StubWithCallback vkCreateCuFunctionNVX_AddCallback +#define vkCreateCuFunctionNVX_ReturnThruPtr_pFunction(pFunction) vkCreateCuFunctionNVX_CMockReturnMemThruPtr_pFunction(__LINE__, pFunction, sizeof(VkCuFunctionNVX)) +#define vkCreateCuFunctionNVX_ReturnArrayThruPtr_pFunction(pFunction, cmock_len) vkCreateCuFunctionNVX_CMockReturnMemThruPtr_pFunction(__LINE__, pFunction, cmock_len * sizeof(*pFunction)) +#define vkCreateCuFunctionNVX_ReturnMemThruPtr_pFunction(pFunction, cmock_size) vkCreateCuFunctionNVX_CMockReturnMemThruPtr_pFunction(__LINE__, pFunction, cmock_size) +void vkCreateCuFunctionNVX_CMockReturnMemThruPtr_pFunction(UNITY_LINE_TYPE cmock_line, VkCuFunctionNVX const* pFunction, size_t cmock_size); +#define vkCreateCuFunctionNVX_IgnoreArg_device() vkCreateCuFunctionNVX_CMockIgnoreArg_device(__LINE__) +void vkCreateCuFunctionNVX_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateCuFunctionNVX_IgnoreArg_pCreateInfo() vkCreateCuFunctionNVX_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateCuFunctionNVX_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateCuFunctionNVX_IgnoreArg_pAllocator() vkCreateCuFunctionNVX_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateCuFunctionNVX_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateCuFunctionNVX_IgnoreArg_pFunction() vkCreateCuFunctionNVX_CMockIgnoreArg_pFunction(__LINE__) +void vkCreateCuFunctionNVX_CMockIgnoreArg_pFunction(UNITY_LINE_TYPE cmock_line); +#define vkDestroyCuModuleNVX_Ignore() vkDestroyCuModuleNVX_CMockIgnore() +void vkDestroyCuModuleNVX_CMockIgnore(void); +#define vkDestroyCuModuleNVX_StopIgnore() vkDestroyCuModuleNVX_CMockStopIgnore() +void vkDestroyCuModuleNVX_CMockStopIgnore(void); +#define vkDestroyCuModuleNVX_ExpectAnyArgs() vkDestroyCuModuleNVX_CMockExpectAnyArgs(__LINE__) +void vkDestroyCuModuleNVX_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyCuModuleNVX_Expect(device, module, pAllocator) vkDestroyCuModuleNVX_CMockExpect(__LINE__, device, module, pAllocator) +void vkDestroyCuModuleNVX_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyCuModuleNVX_CALLBACK)(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyCuModuleNVX_AddCallback(CMOCK_vkDestroyCuModuleNVX_CALLBACK Callback); +void vkDestroyCuModuleNVX_Stub(CMOCK_vkDestroyCuModuleNVX_CALLBACK Callback); +#define vkDestroyCuModuleNVX_StubWithCallback vkDestroyCuModuleNVX_AddCallback +#define vkDestroyCuModuleNVX_IgnoreArg_device() vkDestroyCuModuleNVX_CMockIgnoreArg_device(__LINE__) +void vkDestroyCuModuleNVX_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyCuModuleNVX_IgnoreArg_module() vkDestroyCuModuleNVX_CMockIgnoreArg_module(__LINE__) +void vkDestroyCuModuleNVX_CMockIgnoreArg_module(UNITY_LINE_TYPE cmock_line); +#define vkDestroyCuModuleNVX_IgnoreArg_pAllocator() vkDestroyCuModuleNVX_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyCuModuleNVX_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkDestroyCuFunctionNVX_Ignore() vkDestroyCuFunctionNVX_CMockIgnore() +void vkDestroyCuFunctionNVX_CMockIgnore(void); +#define vkDestroyCuFunctionNVX_StopIgnore() vkDestroyCuFunctionNVX_CMockStopIgnore() +void vkDestroyCuFunctionNVX_CMockStopIgnore(void); +#define vkDestroyCuFunctionNVX_ExpectAnyArgs() vkDestroyCuFunctionNVX_CMockExpectAnyArgs(__LINE__) +void vkDestroyCuFunctionNVX_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyCuFunctionNVX_Expect(device, function, pAllocator) vkDestroyCuFunctionNVX_CMockExpect(__LINE__, device, function, pAllocator) +void vkDestroyCuFunctionNVX_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyCuFunctionNVX_CALLBACK)(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyCuFunctionNVX_AddCallback(CMOCK_vkDestroyCuFunctionNVX_CALLBACK Callback); +void vkDestroyCuFunctionNVX_Stub(CMOCK_vkDestroyCuFunctionNVX_CALLBACK Callback); +#define vkDestroyCuFunctionNVX_StubWithCallback vkDestroyCuFunctionNVX_AddCallback +#define vkDestroyCuFunctionNVX_IgnoreArg_device() vkDestroyCuFunctionNVX_CMockIgnoreArg_device(__LINE__) +void vkDestroyCuFunctionNVX_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyCuFunctionNVX_IgnoreArg_function() vkDestroyCuFunctionNVX_CMockIgnoreArg_function(__LINE__) +void vkDestroyCuFunctionNVX_CMockIgnoreArg_function(UNITY_LINE_TYPE cmock_line); +#define vkDestroyCuFunctionNVX_IgnoreArg_pAllocator() vkDestroyCuFunctionNVX_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyCuFunctionNVX_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCmdCuLaunchKernelNVX_Ignore() vkCmdCuLaunchKernelNVX_CMockIgnore() +void vkCmdCuLaunchKernelNVX_CMockIgnore(void); +#define vkCmdCuLaunchKernelNVX_StopIgnore() vkCmdCuLaunchKernelNVX_CMockStopIgnore() +void vkCmdCuLaunchKernelNVX_CMockStopIgnore(void); +#define vkCmdCuLaunchKernelNVX_ExpectAnyArgs() vkCmdCuLaunchKernelNVX_CMockExpectAnyArgs(__LINE__) +void vkCmdCuLaunchKernelNVX_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdCuLaunchKernelNVX_Expect(commandBuffer, pLaunchInfo) vkCmdCuLaunchKernelNVX_CMockExpect(__LINE__, commandBuffer, pLaunchInfo) +void vkCmdCuLaunchKernelNVX_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo); +typedef void (* CMOCK_vkCmdCuLaunchKernelNVX_CALLBACK)(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo, int cmock_num_calls); +void vkCmdCuLaunchKernelNVX_AddCallback(CMOCK_vkCmdCuLaunchKernelNVX_CALLBACK Callback); +void vkCmdCuLaunchKernelNVX_Stub(CMOCK_vkCmdCuLaunchKernelNVX_CALLBACK Callback); +#define vkCmdCuLaunchKernelNVX_StubWithCallback vkCmdCuLaunchKernelNVX_AddCallback +#define vkCmdCuLaunchKernelNVX_IgnoreArg_commandBuffer() vkCmdCuLaunchKernelNVX_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdCuLaunchKernelNVX_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdCuLaunchKernelNVX_IgnoreArg_pLaunchInfo() vkCmdCuLaunchKernelNVX_CMockIgnoreArg_pLaunchInfo(__LINE__) +void vkCmdCuLaunchKernelNVX_CMockIgnoreArg_pLaunchInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetImageViewHandleNVX_IgnoreAndReturn(cmock_retval) vkGetImageViewHandleNVX_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetImageViewHandleNVX_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, uint32_t cmock_to_return); +#define vkGetImageViewHandleNVX_StopIgnore() vkGetImageViewHandleNVX_CMockStopIgnore() +void vkGetImageViewHandleNVX_CMockStopIgnore(void); +#define vkGetImageViewHandleNVX_ExpectAnyArgsAndReturn(cmock_retval) vkGetImageViewHandleNVX_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetImageViewHandleNVX_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, uint32_t cmock_to_return); +#define vkGetImageViewHandleNVX_ExpectAndReturn(device, pInfo, cmock_retval) vkGetImageViewHandleNVX_CMockExpectAndReturn(__LINE__, device, pInfo, cmock_retval) +void vkGetImageViewHandleNVX_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkImageViewHandleInfoNVX* pInfo, uint32_t cmock_to_return); +typedef uint32_t (* CMOCK_vkGetImageViewHandleNVX_CALLBACK)(VkDevice device, const VkImageViewHandleInfoNVX* pInfo, int cmock_num_calls); +void vkGetImageViewHandleNVX_AddCallback(CMOCK_vkGetImageViewHandleNVX_CALLBACK Callback); +void vkGetImageViewHandleNVX_Stub(CMOCK_vkGetImageViewHandleNVX_CALLBACK Callback); +#define vkGetImageViewHandleNVX_StubWithCallback vkGetImageViewHandleNVX_AddCallback +#define vkGetImageViewHandleNVX_IgnoreArg_device() vkGetImageViewHandleNVX_CMockIgnoreArg_device(__LINE__) +void vkGetImageViewHandleNVX_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetImageViewHandleNVX_IgnoreArg_pInfo() vkGetImageViewHandleNVX_CMockIgnoreArg_pInfo(__LINE__) +void vkGetImageViewHandleNVX_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetImageViewAddressNVX_IgnoreAndReturn(cmock_retval) vkGetImageViewAddressNVX_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetImageViewAddressNVX_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetImageViewAddressNVX_StopIgnore() vkGetImageViewAddressNVX_CMockStopIgnore() +void vkGetImageViewAddressNVX_CMockStopIgnore(void); +#define vkGetImageViewAddressNVX_ExpectAnyArgsAndReturn(cmock_retval) vkGetImageViewAddressNVX_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetImageViewAddressNVX_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetImageViewAddressNVX_ExpectAndReturn(device, imageView, pProperties, cmock_retval) vkGetImageViewAddressNVX_CMockExpectAndReturn(__LINE__, device, imageView, pProperties, cmock_retval) +void vkGetImageViewAddressNVX_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetImageViewAddressNVX_CALLBACK)(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties, int cmock_num_calls); +void vkGetImageViewAddressNVX_AddCallback(CMOCK_vkGetImageViewAddressNVX_CALLBACK Callback); +void vkGetImageViewAddressNVX_Stub(CMOCK_vkGetImageViewAddressNVX_CALLBACK Callback); +#define vkGetImageViewAddressNVX_StubWithCallback vkGetImageViewAddressNVX_AddCallback +#define vkGetImageViewAddressNVX_ReturnThruPtr_pProperties(pProperties) vkGetImageViewAddressNVX_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, sizeof(VkImageViewAddressPropertiesNVX)) +#define vkGetImageViewAddressNVX_ReturnArrayThruPtr_pProperties(pProperties, cmock_len) vkGetImageViewAddressNVX_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_len * sizeof(*pProperties)) +#define vkGetImageViewAddressNVX_ReturnMemThruPtr_pProperties(pProperties, cmock_size) vkGetImageViewAddressNVX_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_size) +void vkGetImageViewAddressNVX_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkImageViewAddressPropertiesNVX const* pProperties, size_t cmock_size); +#define vkGetImageViewAddressNVX_IgnoreArg_device() vkGetImageViewAddressNVX_CMockIgnoreArg_device(__LINE__) +void vkGetImageViewAddressNVX_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetImageViewAddressNVX_IgnoreArg_imageView() vkGetImageViewAddressNVX_CMockIgnoreArg_imageView(__LINE__) +void vkGetImageViewAddressNVX_CMockIgnoreArg_imageView(UNITY_LINE_TYPE cmock_line); +#define vkGetImageViewAddressNVX_IgnoreArg_pProperties() vkGetImageViewAddressNVX_CMockIgnoreArg_pProperties(__LINE__) +void vkGetImageViewAddressNVX_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectCountAMD_Ignore() vkCmdDrawIndirectCountAMD_CMockIgnore() +void vkCmdDrawIndirectCountAMD_CMockIgnore(void); +#define vkCmdDrawIndirectCountAMD_StopIgnore() vkCmdDrawIndirectCountAMD_CMockStopIgnore() +void vkCmdDrawIndirectCountAMD_CMockStopIgnore(void); +#define vkCmdDrawIndirectCountAMD_ExpectAnyArgs() vkCmdDrawIndirectCountAMD_CMockExpectAnyArgs(__LINE__) +void vkCmdDrawIndirectCountAMD_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectCountAMD_Expect(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride) vkCmdDrawIndirectCountAMD_CMockExpect(__LINE__, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride) +void vkCmdDrawIndirectCountAMD_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef void (* CMOCK_vkCmdDrawIndirectCountAMD_CALLBACK)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, int cmock_num_calls); +void vkCmdDrawIndirectCountAMD_AddCallback(CMOCK_vkCmdDrawIndirectCountAMD_CALLBACK Callback); +void vkCmdDrawIndirectCountAMD_Stub(CMOCK_vkCmdDrawIndirectCountAMD_CALLBACK Callback); +#define vkCmdDrawIndirectCountAMD_StubWithCallback vkCmdDrawIndirectCountAMD_AddCallback +#define vkCmdDrawIndirectCountAMD_IgnoreArg_commandBuffer() vkCmdDrawIndirectCountAMD_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDrawIndirectCountAMD_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectCountAMD_IgnoreArg_buffer() vkCmdDrawIndirectCountAMD_CMockIgnoreArg_buffer(__LINE__) +void vkCmdDrawIndirectCountAMD_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectCountAMD_IgnoreArg_offset() vkCmdDrawIndirectCountAMD_CMockIgnoreArg_offset(__LINE__) +void vkCmdDrawIndirectCountAMD_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectCountAMD_IgnoreArg_countBuffer() vkCmdDrawIndirectCountAMD_CMockIgnoreArg_countBuffer(__LINE__) +void vkCmdDrawIndirectCountAMD_CMockIgnoreArg_countBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectCountAMD_IgnoreArg_countBufferOffset() vkCmdDrawIndirectCountAMD_CMockIgnoreArg_countBufferOffset(__LINE__) +void vkCmdDrawIndirectCountAMD_CMockIgnoreArg_countBufferOffset(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectCountAMD_IgnoreArg_maxDrawCount() vkCmdDrawIndirectCountAMD_CMockIgnoreArg_maxDrawCount(__LINE__) +void vkCmdDrawIndirectCountAMD_CMockIgnoreArg_maxDrawCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndirectCountAMD_IgnoreArg_stride() vkCmdDrawIndirectCountAMD_CMockIgnoreArg_stride(__LINE__) +void vkCmdDrawIndirectCountAMD_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexedIndirectCountAMD_Ignore() vkCmdDrawIndexedIndirectCountAMD_CMockIgnore() +void vkCmdDrawIndexedIndirectCountAMD_CMockIgnore(void); +#define vkCmdDrawIndexedIndirectCountAMD_StopIgnore() vkCmdDrawIndexedIndirectCountAMD_CMockStopIgnore() +void vkCmdDrawIndexedIndirectCountAMD_CMockStopIgnore(void); +#define vkCmdDrawIndexedIndirectCountAMD_ExpectAnyArgs() vkCmdDrawIndexedIndirectCountAMD_CMockExpectAnyArgs(__LINE__) +void vkCmdDrawIndexedIndirectCountAMD_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexedIndirectCountAMD_Expect(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride) vkCmdDrawIndexedIndirectCountAMD_CMockExpect(__LINE__, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride) +void vkCmdDrawIndexedIndirectCountAMD_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef void (* CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALLBACK)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, int cmock_num_calls); +void vkCmdDrawIndexedIndirectCountAMD_AddCallback(CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALLBACK Callback); +void vkCmdDrawIndexedIndirectCountAMD_Stub(CMOCK_vkCmdDrawIndexedIndirectCountAMD_CALLBACK Callback); +#define vkCmdDrawIndexedIndirectCountAMD_StubWithCallback vkCmdDrawIndexedIndirectCountAMD_AddCallback +#define vkCmdDrawIndexedIndirectCountAMD_IgnoreArg_commandBuffer() vkCmdDrawIndexedIndirectCountAMD_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDrawIndexedIndirectCountAMD_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexedIndirectCountAMD_IgnoreArg_buffer() vkCmdDrawIndexedIndirectCountAMD_CMockIgnoreArg_buffer(__LINE__) +void vkCmdDrawIndexedIndirectCountAMD_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexedIndirectCountAMD_IgnoreArg_offset() vkCmdDrawIndexedIndirectCountAMD_CMockIgnoreArg_offset(__LINE__) +void vkCmdDrawIndexedIndirectCountAMD_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexedIndirectCountAMD_IgnoreArg_countBuffer() vkCmdDrawIndexedIndirectCountAMD_CMockIgnoreArg_countBuffer(__LINE__) +void vkCmdDrawIndexedIndirectCountAMD_CMockIgnoreArg_countBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexedIndirectCountAMD_IgnoreArg_countBufferOffset() vkCmdDrawIndexedIndirectCountAMD_CMockIgnoreArg_countBufferOffset(__LINE__) +void vkCmdDrawIndexedIndirectCountAMD_CMockIgnoreArg_countBufferOffset(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexedIndirectCountAMD_IgnoreArg_maxDrawCount() vkCmdDrawIndexedIndirectCountAMD_CMockIgnoreArg_maxDrawCount(__LINE__) +void vkCmdDrawIndexedIndirectCountAMD_CMockIgnoreArg_maxDrawCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawIndexedIndirectCountAMD_IgnoreArg_stride() vkCmdDrawIndexedIndirectCountAMD_CMockIgnoreArg_stride(__LINE__) +void vkCmdDrawIndexedIndirectCountAMD_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line); +#define vkGetShaderInfoAMD_IgnoreAndReturn(cmock_retval) vkGetShaderInfoAMD_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetShaderInfoAMD_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetShaderInfoAMD_StopIgnore() vkGetShaderInfoAMD_CMockStopIgnore() +void vkGetShaderInfoAMD_CMockStopIgnore(void); +#define vkGetShaderInfoAMD_ExpectAnyArgsAndReturn(cmock_retval) vkGetShaderInfoAMD_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetShaderInfoAMD_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetShaderInfoAMD_ExpectAndReturn(device, pipeline, shaderStage, infoType, pInfoSize, pInfo, cmock_retval) vkGetShaderInfoAMD_CMockExpectAndReturn(__LINE__, device, pipeline, shaderStage, infoType, pInfoSize, pInfo, cmock_retval) +void vkGetShaderInfoAMD_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetShaderInfoAMD_CALLBACK)(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo, int cmock_num_calls); +void vkGetShaderInfoAMD_AddCallback(CMOCK_vkGetShaderInfoAMD_CALLBACK Callback); +void vkGetShaderInfoAMD_Stub(CMOCK_vkGetShaderInfoAMD_CALLBACK Callback); +#define vkGetShaderInfoAMD_StubWithCallback vkGetShaderInfoAMD_AddCallback +#define vkGetShaderInfoAMD_ReturnThruPtr_pInfoSize(pInfoSize) vkGetShaderInfoAMD_CMockReturnMemThruPtr_pInfoSize(__LINE__, pInfoSize, sizeof(size_t)) +#define vkGetShaderInfoAMD_ReturnArrayThruPtr_pInfoSize(pInfoSize, cmock_len) vkGetShaderInfoAMD_CMockReturnMemThruPtr_pInfoSize(__LINE__, pInfoSize, cmock_len * sizeof(*pInfoSize)) +#define vkGetShaderInfoAMD_ReturnMemThruPtr_pInfoSize(pInfoSize, cmock_size) vkGetShaderInfoAMD_CMockReturnMemThruPtr_pInfoSize(__LINE__, pInfoSize, cmock_size) +void vkGetShaderInfoAMD_CMockReturnMemThruPtr_pInfoSize(UNITY_LINE_TYPE cmock_line, size_t const* pInfoSize, size_t cmock_size); +#define vkGetShaderInfoAMD_ReturnThruPtr_pInfo(pInfo) vkGetShaderInfoAMD_CMockReturnMemThruPtr_pInfo(__LINE__, pInfo, sizeof(*pInfo)) +#define vkGetShaderInfoAMD_ReturnArrayThruPtr_pInfo(pInfo, cmock_len) vkGetShaderInfoAMD_CMockReturnMemThruPtr_pInfo(__LINE__, pInfo, cmock_len * sizeof(*pInfo)) +#define vkGetShaderInfoAMD_ReturnMemThruPtr_pInfo(pInfo, cmock_size) vkGetShaderInfoAMD_CMockReturnMemThruPtr_pInfo(__LINE__, pInfo, cmock_size) +void vkGetShaderInfoAMD_CMockReturnMemThruPtr_pInfo(UNITY_LINE_TYPE cmock_line, void const* pInfo, size_t cmock_size); +#define vkGetShaderInfoAMD_IgnoreArg_device() vkGetShaderInfoAMD_CMockIgnoreArg_device(__LINE__) +void vkGetShaderInfoAMD_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetShaderInfoAMD_IgnoreArg_pipeline() vkGetShaderInfoAMD_CMockIgnoreArg_pipeline(__LINE__) +void vkGetShaderInfoAMD_CMockIgnoreArg_pipeline(UNITY_LINE_TYPE cmock_line); +#define vkGetShaderInfoAMD_IgnoreArg_shaderStage() vkGetShaderInfoAMD_CMockIgnoreArg_shaderStage(__LINE__) +void vkGetShaderInfoAMD_CMockIgnoreArg_shaderStage(UNITY_LINE_TYPE cmock_line); +#define vkGetShaderInfoAMD_IgnoreArg_infoType() vkGetShaderInfoAMD_CMockIgnoreArg_infoType(__LINE__) +void vkGetShaderInfoAMD_CMockIgnoreArg_infoType(UNITY_LINE_TYPE cmock_line); +#define vkGetShaderInfoAMD_IgnoreArg_pInfoSize() vkGetShaderInfoAMD_CMockIgnoreArg_pInfoSize(__LINE__) +void vkGetShaderInfoAMD_CMockIgnoreArg_pInfoSize(UNITY_LINE_TYPE cmock_line); +#define vkGetShaderInfoAMD_IgnoreArg_pInfo() vkGetShaderInfoAMD_CMockIgnoreArg_pInfo(__LINE__) +void vkGetShaderInfoAMD_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalImageFormatPropertiesNV_IgnoreAndReturn(cmock_retval) vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceExternalImageFormatPropertiesNV_StopIgnore() vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockStopIgnore() +void vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockStopIgnore(void); +#define vkGetPhysicalDeviceExternalImageFormatPropertiesNV_ExpectAnyArgsAndReturn(cmock_retval) vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceExternalImageFormatPropertiesNV_ExpectAndReturn(physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties, cmock_retval) vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockExpectAndReturn(__LINE__, physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties, cmock_retval) +void vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALLBACK)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties, int cmock_num_calls); +void vkGetPhysicalDeviceExternalImageFormatPropertiesNV_AddCallback(CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALLBACK Callback); +void vkGetPhysicalDeviceExternalImageFormatPropertiesNV_Stub(CMOCK_vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CALLBACK Callback); +#define vkGetPhysicalDeviceExternalImageFormatPropertiesNV_StubWithCallback vkGetPhysicalDeviceExternalImageFormatPropertiesNV_AddCallback +#define vkGetPhysicalDeviceExternalImageFormatPropertiesNV_ReturnThruPtr_pExternalImageFormatProperties(pExternalImageFormatProperties) vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockReturnMemThruPtr_pExternalImageFormatProperties(__LINE__, pExternalImageFormatProperties, sizeof(VkExternalImageFormatPropertiesNV)) +#define vkGetPhysicalDeviceExternalImageFormatPropertiesNV_ReturnArrayThruPtr_pExternalImageFormatProperties(pExternalImageFormatProperties, cmock_len) vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockReturnMemThruPtr_pExternalImageFormatProperties(__LINE__, pExternalImageFormatProperties, cmock_len * sizeof(*pExternalImageFormatProperties)) +#define vkGetPhysicalDeviceExternalImageFormatPropertiesNV_ReturnMemThruPtr_pExternalImageFormatProperties(pExternalImageFormatProperties, cmock_size) vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockReturnMemThruPtr_pExternalImageFormatProperties(__LINE__, pExternalImageFormatProperties, cmock_size) +void vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockReturnMemThruPtr_pExternalImageFormatProperties(UNITY_LINE_TYPE cmock_line, VkExternalImageFormatPropertiesNV const* pExternalImageFormatProperties, size_t cmock_size); +#define vkGetPhysicalDeviceExternalImageFormatPropertiesNV_IgnoreArg_physicalDevice() vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalImageFormatPropertiesNV_IgnoreArg_format() vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockIgnoreArg_format(__LINE__) +void vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockIgnoreArg_format(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalImageFormatPropertiesNV_IgnoreArg_type() vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockIgnoreArg_type(__LINE__) +void vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockIgnoreArg_type(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalImageFormatPropertiesNV_IgnoreArg_tiling() vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockIgnoreArg_tiling(__LINE__) +void vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockIgnoreArg_tiling(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalImageFormatPropertiesNV_IgnoreArg_usage() vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockIgnoreArg_usage(__LINE__) +void vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockIgnoreArg_usage(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalImageFormatPropertiesNV_IgnoreArg_flags() vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockIgnoreArg_flags(__LINE__) +void vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockIgnoreArg_flags(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalImageFormatPropertiesNV_IgnoreArg_externalHandleType() vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockIgnoreArg_externalHandleType(__LINE__) +void vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockIgnoreArg_externalHandleType(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceExternalImageFormatPropertiesNV_IgnoreArg_pExternalImageFormatProperties() vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockIgnoreArg_pExternalImageFormatProperties(__LINE__) +void vkGetPhysicalDeviceExternalImageFormatPropertiesNV_CMockIgnoreArg_pExternalImageFormatProperties(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginConditionalRenderingEXT_Ignore() vkCmdBeginConditionalRenderingEXT_CMockIgnore() +void vkCmdBeginConditionalRenderingEXT_CMockIgnore(void); +#define vkCmdBeginConditionalRenderingEXT_StopIgnore() vkCmdBeginConditionalRenderingEXT_CMockStopIgnore() +void vkCmdBeginConditionalRenderingEXT_CMockStopIgnore(void); +#define vkCmdBeginConditionalRenderingEXT_ExpectAnyArgs() vkCmdBeginConditionalRenderingEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdBeginConditionalRenderingEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginConditionalRenderingEXT_Expect(commandBuffer, pConditionalRenderingBegin) vkCmdBeginConditionalRenderingEXT_CMockExpect(__LINE__, commandBuffer, pConditionalRenderingBegin) +void vkCmdBeginConditionalRenderingEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin); +typedef void (* CMOCK_vkCmdBeginConditionalRenderingEXT_CALLBACK)(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin, int cmock_num_calls); +void vkCmdBeginConditionalRenderingEXT_AddCallback(CMOCK_vkCmdBeginConditionalRenderingEXT_CALLBACK Callback); +void vkCmdBeginConditionalRenderingEXT_Stub(CMOCK_vkCmdBeginConditionalRenderingEXT_CALLBACK Callback); +#define vkCmdBeginConditionalRenderingEXT_StubWithCallback vkCmdBeginConditionalRenderingEXT_AddCallback +#define vkCmdBeginConditionalRenderingEXT_IgnoreArg_commandBuffer() vkCmdBeginConditionalRenderingEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBeginConditionalRenderingEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginConditionalRenderingEXT_IgnoreArg_pConditionalRenderingBegin() vkCmdBeginConditionalRenderingEXT_CMockIgnoreArg_pConditionalRenderingBegin(__LINE__) +void vkCmdBeginConditionalRenderingEXT_CMockIgnoreArg_pConditionalRenderingBegin(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndConditionalRenderingEXT_Ignore() vkCmdEndConditionalRenderingEXT_CMockIgnore() +void vkCmdEndConditionalRenderingEXT_CMockIgnore(void); +#define vkCmdEndConditionalRenderingEXT_StopIgnore() vkCmdEndConditionalRenderingEXT_CMockStopIgnore() +void vkCmdEndConditionalRenderingEXT_CMockStopIgnore(void); +#define vkCmdEndConditionalRenderingEXT_ExpectAnyArgs() vkCmdEndConditionalRenderingEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdEndConditionalRenderingEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndConditionalRenderingEXT_Expect(commandBuffer) vkCmdEndConditionalRenderingEXT_CMockExpect(__LINE__, commandBuffer) +void vkCmdEndConditionalRenderingEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer); +typedef void (* CMOCK_vkCmdEndConditionalRenderingEXT_CALLBACK)(VkCommandBuffer commandBuffer, int cmock_num_calls); +void vkCmdEndConditionalRenderingEXT_AddCallback(CMOCK_vkCmdEndConditionalRenderingEXT_CALLBACK Callback); +void vkCmdEndConditionalRenderingEXT_Stub(CMOCK_vkCmdEndConditionalRenderingEXT_CALLBACK Callback); +#define vkCmdEndConditionalRenderingEXT_StubWithCallback vkCmdEndConditionalRenderingEXT_AddCallback +#define vkCmdEndConditionalRenderingEXT_IgnoreArg_commandBuffer() vkCmdEndConditionalRenderingEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdEndConditionalRenderingEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewportWScalingNV_Ignore() vkCmdSetViewportWScalingNV_CMockIgnore() +void vkCmdSetViewportWScalingNV_CMockIgnore(void); +#define vkCmdSetViewportWScalingNV_StopIgnore() vkCmdSetViewportWScalingNV_CMockStopIgnore() +void vkCmdSetViewportWScalingNV_CMockStopIgnore(void); +#define vkCmdSetViewportWScalingNV_ExpectAnyArgs() vkCmdSetViewportWScalingNV_CMockExpectAnyArgs(__LINE__) +void vkCmdSetViewportWScalingNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewportWScalingNV_Expect(commandBuffer, firstViewport, viewportCount, pViewportWScalings) vkCmdSetViewportWScalingNV_CMockExpect(__LINE__, commandBuffer, firstViewport, viewportCount, pViewportWScalings) +void vkCmdSetViewportWScalingNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings); +typedef void (* CMOCK_vkCmdSetViewportWScalingNV_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings, int cmock_num_calls); +void vkCmdSetViewportWScalingNV_AddCallback(CMOCK_vkCmdSetViewportWScalingNV_CALLBACK Callback); +void vkCmdSetViewportWScalingNV_Stub(CMOCK_vkCmdSetViewportWScalingNV_CALLBACK Callback); +#define vkCmdSetViewportWScalingNV_StubWithCallback vkCmdSetViewportWScalingNV_AddCallback +#define vkCmdSetViewportWScalingNV_IgnoreArg_commandBuffer() vkCmdSetViewportWScalingNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetViewportWScalingNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewportWScalingNV_IgnoreArg_firstViewport() vkCmdSetViewportWScalingNV_CMockIgnoreArg_firstViewport(__LINE__) +void vkCmdSetViewportWScalingNV_CMockIgnoreArg_firstViewport(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewportWScalingNV_IgnoreArg_viewportCount() vkCmdSetViewportWScalingNV_CMockIgnoreArg_viewportCount(__LINE__) +void vkCmdSetViewportWScalingNV_CMockIgnoreArg_viewportCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewportWScalingNV_IgnoreArg_pViewportWScalings() vkCmdSetViewportWScalingNV_CMockIgnoreArg_pViewportWScalings(__LINE__) +void vkCmdSetViewportWScalingNV_CMockIgnoreArg_pViewportWScalings(UNITY_LINE_TYPE cmock_line); +#define vkReleaseDisplayEXT_IgnoreAndReturn(cmock_retval) vkReleaseDisplayEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkReleaseDisplayEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkReleaseDisplayEXT_StopIgnore() vkReleaseDisplayEXT_CMockStopIgnore() +void vkReleaseDisplayEXT_CMockStopIgnore(void); +#define vkReleaseDisplayEXT_ExpectAnyArgsAndReturn(cmock_retval) vkReleaseDisplayEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkReleaseDisplayEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkReleaseDisplayEXT_ExpectAndReturn(physicalDevice, display, cmock_retval) vkReleaseDisplayEXT_CMockExpectAndReturn(__LINE__, physicalDevice, display, cmock_retval) +void vkReleaseDisplayEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkDisplayKHR display, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkReleaseDisplayEXT_CALLBACK)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, int cmock_num_calls); +void vkReleaseDisplayEXT_AddCallback(CMOCK_vkReleaseDisplayEXT_CALLBACK Callback); +void vkReleaseDisplayEXT_Stub(CMOCK_vkReleaseDisplayEXT_CALLBACK Callback); +#define vkReleaseDisplayEXT_StubWithCallback vkReleaseDisplayEXT_AddCallback +#define vkReleaseDisplayEXT_IgnoreArg_physicalDevice() vkReleaseDisplayEXT_CMockIgnoreArg_physicalDevice(__LINE__) +void vkReleaseDisplayEXT_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkReleaseDisplayEXT_IgnoreArg_display() vkReleaseDisplayEXT_CMockIgnoreArg_display(__LINE__) +void vkReleaseDisplayEXT_CMockIgnoreArg_display(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSurfaceCapabilities2EXT_IgnoreAndReturn(cmock_retval) vkGetPhysicalDeviceSurfaceCapabilities2EXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceSurfaceCapabilities2EXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceSurfaceCapabilities2EXT_StopIgnore() vkGetPhysicalDeviceSurfaceCapabilities2EXT_CMockStopIgnore() +void vkGetPhysicalDeviceSurfaceCapabilities2EXT_CMockStopIgnore(void); +#define vkGetPhysicalDeviceSurfaceCapabilities2EXT_ExpectAnyArgsAndReturn(cmock_retval) vkGetPhysicalDeviceSurfaceCapabilities2EXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceSurfaceCapabilities2EXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceSurfaceCapabilities2EXT_ExpectAndReturn(physicalDevice, surface, pSurfaceCapabilities, cmock_retval) vkGetPhysicalDeviceSurfaceCapabilities2EXT_CMockExpectAndReturn(__LINE__, physicalDevice, surface, pSurfaceCapabilities, cmock_retval) +void vkGetPhysicalDeviceSurfaceCapabilities2EXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2EXT_CALLBACK)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities, int cmock_num_calls); +void vkGetPhysicalDeviceSurfaceCapabilities2EXT_AddCallback(CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2EXT_CALLBACK Callback); +void vkGetPhysicalDeviceSurfaceCapabilities2EXT_Stub(CMOCK_vkGetPhysicalDeviceSurfaceCapabilities2EXT_CALLBACK Callback); +#define vkGetPhysicalDeviceSurfaceCapabilities2EXT_StubWithCallback vkGetPhysicalDeviceSurfaceCapabilities2EXT_AddCallback +#define vkGetPhysicalDeviceSurfaceCapabilities2EXT_ReturnThruPtr_pSurfaceCapabilities(pSurfaceCapabilities) vkGetPhysicalDeviceSurfaceCapabilities2EXT_CMockReturnMemThruPtr_pSurfaceCapabilities(__LINE__, pSurfaceCapabilities, sizeof(VkSurfaceCapabilities2EXT)) +#define vkGetPhysicalDeviceSurfaceCapabilities2EXT_ReturnArrayThruPtr_pSurfaceCapabilities(pSurfaceCapabilities, cmock_len) vkGetPhysicalDeviceSurfaceCapabilities2EXT_CMockReturnMemThruPtr_pSurfaceCapabilities(__LINE__, pSurfaceCapabilities, cmock_len * sizeof(*pSurfaceCapabilities)) +#define vkGetPhysicalDeviceSurfaceCapabilities2EXT_ReturnMemThruPtr_pSurfaceCapabilities(pSurfaceCapabilities, cmock_size) vkGetPhysicalDeviceSurfaceCapabilities2EXT_CMockReturnMemThruPtr_pSurfaceCapabilities(__LINE__, pSurfaceCapabilities, cmock_size) +void vkGetPhysicalDeviceSurfaceCapabilities2EXT_CMockReturnMemThruPtr_pSurfaceCapabilities(UNITY_LINE_TYPE cmock_line, VkSurfaceCapabilities2EXT const* pSurfaceCapabilities, size_t cmock_size); +#define vkGetPhysicalDeviceSurfaceCapabilities2EXT_IgnoreArg_physicalDevice() vkGetPhysicalDeviceSurfaceCapabilities2EXT_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceSurfaceCapabilities2EXT_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSurfaceCapabilities2EXT_IgnoreArg_surface() vkGetPhysicalDeviceSurfaceCapabilities2EXT_CMockIgnoreArg_surface(__LINE__) +void vkGetPhysicalDeviceSurfaceCapabilities2EXT_CMockIgnoreArg_surface(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSurfaceCapabilities2EXT_IgnoreArg_pSurfaceCapabilities() vkGetPhysicalDeviceSurfaceCapabilities2EXT_CMockIgnoreArg_pSurfaceCapabilities(__LINE__) +void vkGetPhysicalDeviceSurfaceCapabilities2EXT_CMockIgnoreArg_pSurfaceCapabilities(UNITY_LINE_TYPE cmock_line); +#define vkDisplayPowerControlEXT_IgnoreAndReturn(cmock_retval) vkDisplayPowerControlEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkDisplayPowerControlEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkDisplayPowerControlEXT_StopIgnore() vkDisplayPowerControlEXT_CMockStopIgnore() +void vkDisplayPowerControlEXT_CMockStopIgnore(void); +#define vkDisplayPowerControlEXT_ExpectAnyArgsAndReturn(cmock_retval) vkDisplayPowerControlEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkDisplayPowerControlEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkDisplayPowerControlEXT_ExpectAndReturn(device, display, pDisplayPowerInfo, cmock_retval) vkDisplayPowerControlEXT_CMockExpectAndReturn(__LINE__, device, display, pDisplayPowerInfo, cmock_retval) +void vkDisplayPowerControlEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkDisplayPowerControlEXT_CALLBACK)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo, int cmock_num_calls); +void vkDisplayPowerControlEXT_AddCallback(CMOCK_vkDisplayPowerControlEXT_CALLBACK Callback); +void vkDisplayPowerControlEXT_Stub(CMOCK_vkDisplayPowerControlEXT_CALLBACK Callback); +#define vkDisplayPowerControlEXT_StubWithCallback vkDisplayPowerControlEXT_AddCallback +#define vkDisplayPowerControlEXT_IgnoreArg_device() vkDisplayPowerControlEXT_CMockIgnoreArg_device(__LINE__) +void vkDisplayPowerControlEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDisplayPowerControlEXT_IgnoreArg_display() vkDisplayPowerControlEXT_CMockIgnoreArg_display(__LINE__) +void vkDisplayPowerControlEXT_CMockIgnoreArg_display(UNITY_LINE_TYPE cmock_line); +#define vkDisplayPowerControlEXT_IgnoreArg_pDisplayPowerInfo() vkDisplayPowerControlEXT_CMockIgnoreArg_pDisplayPowerInfo(__LINE__) +void vkDisplayPowerControlEXT_CMockIgnoreArg_pDisplayPowerInfo(UNITY_LINE_TYPE cmock_line); +#define vkRegisterDeviceEventEXT_IgnoreAndReturn(cmock_retval) vkRegisterDeviceEventEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkRegisterDeviceEventEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkRegisterDeviceEventEXT_StopIgnore() vkRegisterDeviceEventEXT_CMockStopIgnore() +void vkRegisterDeviceEventEXT_CMockStopIgnore(void); +#define vkRegisterDeviceEventEXT_ExpectAnyArgsAndReturn(cmock_retval) vkRegisterDeviceEventEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkRegisterDeviceEventEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkRegisterDeviceEventEXT_ExpectAndReturn(device, pDeviceEventInfo, pAllocator, pFence, cmock_retval) vkRegisterDeviceEventEXT_CMockExpectAndReturn(__LINE__, device, pDeviceEventInfo, pAllocator, pFence, cmock_retval) +void vkRegisterDeviceEventEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkRegisterDeviceEventEXT_CALLBACK)(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence, int cmock_num_calls); +void vkRegisterDeviceEventEXT_AddCallback(CMOCK_vkRegisterDeviceEventEXT_CALLBACK Callback); +void vkRegisterDeviceEventEXT_Stub(CMOCK_vkRegisterDeviceEventEXT_CALLBACK Callback); +#define vkRegisterDeviceEventEXT_StubWithCallback vkRegisterDeviceEventEXT_AddCallback +#define vkRegisterDeviceEventEXT_ReturnThruPtr_pFence(pFence) vkRegisterDeviceEventEXT_CMockReturnMemThruPtr_pFence(__LINE__, pFence, sizeof(VkFence)) +#define vkRegisterDeviceEventEXT_ReturnArrayThruPtr_pFence(pFence, cmock_len) vkRegisterDeviceEventEXT_CMockReturnMemThruPtr_pFence(__LINE__, pFence, cmock_len * sizeof(*pFence)) +#define vkRegisterDeviceEventEXT_ReturnMemThruPtr_pFence(pFence, cmock_size) vkRegisterDeviceEventEXT_CMockReturnMemThruPtr_pFence(__LINE__, pFence, cmock_size) +void vkRegisterDeviceEventEXT_CMockReturnMemThruPtr_pFence(UNITY_LINE_TYPE cmock_line, VkFence const* pFence, size_t cmock_size); +#define vkRegisterDeviceEventEXT_IgnoreArg_device() vkRegisterDeviceEventEXT_CMockIgnoreArg_device(__LINE__) +void vkRegisterDeviceEventEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkRegisterDeviceEventEXT_IgnoreArg_pDeviceEventInfo() vkRegisterDeviceEventEXT_CMockIgnoreArg_pDeviceEventInfo(__LINE__) +void vkRegisterDeviceEventEXT_CMockIgnoreArg_pDeviceEventInfo(UNITY_LINE_TYPE cmock_line); +#define vkRegisterDeviceEventEXT_IgnoreArg_pAllocator() vkRegisterDeviceEventEXT_CMockIgnoreArg_pAllocator(__LINE__) +void vkRegisterDeviceEventEXT_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkRegisterDeviceEventEXT_IgnoreArg_pFence() vkRegisterDeviceEventEXT_CMockIgnoreArg_pFence(__LINE__) +void vkRegisterDeviceEventEXT_CMockIgnoreArg_pFence(UNITY_LINE_TYPE cmock_line); +#define vkRegisterDisplayEventEXT_IgnoreAndReturn(cmock_retval) vkRegisterDisplayEventEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkRegisterDisplayEventEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkRegisterDisplayEventEXT_StopIgnore() vkRegisterDisplayEventEXT_CMockStopIgnore() +void vkRegisterDisplayEventEXT_CMockStopIgnore(void); +#define vkRegisterDisplayEventEXT_ExpectAnyArgsAndReturn(cmock_retval) vkRegisterDisplayEventEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkRegisterDisplayEventEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkRegisterDisplayEventEXT_ExpectAndReturn(device, display, pDisplayEventInfo, pAllocator, pFence, cmock_retval) vkRegisterDisplayEventEXT_CMockExpectAndReturn(__LINE__, device, display, pDisplayEventInfo, pAllocator, pFence, cmock_retval) +void vkRegisterDisplayEventEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkRegisterDisplayEventEXT_CALLBACK)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence, int cmock_num_calls); +void vkRegisterDisplayEventEXT_AddCallback(CMOCK_vkRegisterDisplayEventEXT_CALLBACK Callback); +void vkRegisterDisplayEventEXT_Stub(CMOCK_vkRegisterDisplayEventEXT_CALLBACK Callback); +#define vkRegisterDisplayEventEXT_StubWithCallback vkRegisterDisplayEventEXT_AddCallback +#define vkRegisterDisplayEventEXT_ReturnThruPtr_pFence(pFence) vkRegisterDisplayEventEXT_CMockReturnMemThruPtr_pFence(__LINE__, pFence, sizeof(VkFence)) +#define vkRegisterDisplayEventEXT_ReturnArrayThruPtr_pFence(pFence, cmock_len) vkRegisterDisplayEventEXT_CMockReturnMemThruPtr_pFence(__LINE__, pFence, cmock_len * sizeof(*pFence)) +#define vkRegisterDisplayEventEXT_ReturnMemThruPtr_pFence(pFence, cmock_size) vkRegisterDisplayEventEXT_CMockReturnMemThruPtr_pFence(__LINE__, pFence, cmock_size) +void vkRegisterDisplayEventEXT_CMockReturnMemThruPtr_pFence(UNITY_LINE_TYPE cmock_line, VkFence const* pFence, size_t cmock_size); +#define vkRegisterDisplayEventEXT_IgnoreArg_device() vkRegisterDisplayEventEXT_CMockIgnoreArg_device(__LINE__) +void vkRegisterDisplayEventEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkRegisterDisplayEventEXT_IgnoreArg_display() vkRegisterDisplayEventEXT_CMockIgnoreArg_display(__LINE__) +void vkRegisterDisplayEventEXT_CMockIgnoreArg_display(UNITY_LINE_TYPE cmock_line); +#define vkRegisterDisplayEventEXT_IgnoreArg_pDisplayEventInfo() vkRegisterDisplayEventEXT_CMockIgnoreArg_pDisplayEventInfo(__LINE__) +void vkRegisterDisplayEventEXT_CMockIgnoreArg_pDisplayEventInfo(UNITY_LINE_TYPE cmock_line); +#define vkRegisterDisplayEventEXT_IgnoreArg_pAllocator() vkRegisterDisplayEventEXT_CMockIgnoreArg_pAllocator(__LINE__) +void vkRegisterDisplayEventEXT_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkRegisterDisplayEventEXT_IgnoreArg_pFence() vkRegisterDisplayEventEXT_CMockIgnoreArg_pFence(__LINE__) +void vkRegisterDisplayEventEXT_CMockIgnoreArg_pFence(UNITY_LINE_TYPE cmock_line); +#define vkGetSwapchainCounterEXT_IgnoreAndReturn(cmock_retval) vkGetSwapchainCounterEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetSwapchainCounterEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetSwapchainCounterEXT_StopIgnore() vkGetSwapchainCounterEXT_CMockStopIgnore() +void vkGetSwapchainCounterEXT_CMockStopIgnore(void); +#define vkGetSwapchainCounterEXT_ExpectAnyArgsAndReturn(cmock_retval) vkGetSwapchainCounterEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetSwapchainCounterEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetSwapchainCounterEXT_ExpectAndReturn(device, swapchain, counter, pCounterValue, cmock_retval) vkGetSwapchainCounterEXT_CMockExpectAndReturn(__LINE__, device, swapchain, counter, pCounterValue, cmock_retval) +void vkGetSwapchainCounterEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetSwapchainCounterEXT_CALLBACK)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue, int cmock_num_calls); +void vkGetSwapchainCounterEXT_AddCallback(CMOCK_vkGetSwapchainCounterEXT_CALLBACK Callback); +void vkGetSwapchainCounterEXT_Stub(CMOCK_vkGetSwapchainCounterEXT_CALLBACK Callback); +#define vkGetSwapchainCounterEXT_StubWithCallback vkGetSwapchainCounterEXT_AddCallback +#define vkGetSwapchainCounterEXT_ReturnThruPtr_pCounterValue(pCounterValue) vkGetSwapchainCounterEXT_CMockReturnMemThruPtr_pCounterValue(__LINE__, pCounterValue, sizeof(uint64_t)) +#define vkGetSwapchainCounterEXT_ReturnArrayThruPtr_pCounterValue(pCounterValue, cmock_len) vkGetSwapchainCounterEXT_CMockReturnMemThruPtr_pCounterValue(__LINE__, pCounterValue, cmock_len * sizeof(*pCounterValue)) +#define vkGetSwapchainCounterEXT_ReturnMemThruPtr_pCounterValue(pCounterValue, cmock_size) vkGetSwapchainCounterEXT_CMockReturnMemThruPtr_pCounterValue(__LINE__, pCounterValue, cmock_size) +void vkGetSwapchainCounterEXT_CMockReturnMemThruPtr_pCounterValue(UNITY_LINE_TYPE cmock_line, uint64_t const* pCounterValue, size_t cmock_size); +#define vkGetSwapchainCounterEXT_IgnoreArg_device() vkGetSwapchainCounterEXT_CMockIgnoreArg_device(__LINE__) +void vkGetSwapchainCounterEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetSwapchainCounterEXT_IgnoreArg_swapchain() vkGetSwapchainCounterEXT_CMockIgnoreArg_swapchain(__LINE__) +void vkGetSwapchainCounterEXT_CMockIgnoreArg_swapchain(UNITY_LINE_TYPE cmock_line); +#define vkGetSwapchainCounterEXT_IgnoreArg_counter() vkGetSwapchainCounterEXT_CMockIgnoreArg_counter(__LINE__) +void vkGetSwapchainCounterEXT_CMockIgnoreArg_counter(UNITY_LINE_TYPE cmock_line); +#define vkGetSwapchainCounterEXT_IgnoreArg_pCounterValue() vkGetSwapchainCounterEXT_CMockIgnoreArg_pCounterValue(__LINE__) +void vkGetSwapchainCounterEXT_CMockIgnoreArg_pCounterValue(UNITY_LINE_TYPE cmock_line); +#define vkGetRefreshCycleDurationGOOGLE_IgnoreAndReturn(cmock_retval) vkGetRefreshCycleDurationGOOGLE_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetRefreshCycleDurationGOOGLE_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetRefreshCycleDurationGOOGLE_StopIgnore() vkGetRefreshCycleDurationGOOGLE_CMockStopIgnore() +void vkGetRefreshCycleDurationGOOGLE_CMockStopIgnore(void); +#define vkGetRefreshCycleDurationGOOGLE_ExpectAnyArgsAndReturn(cmock_retval) vkGetRefreshCycleDurationGOOGLE_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetRefreshCycleDurationGOOGLE_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetRefreshCycleDurationGOOGLE_ExpectAndReturn(device, swapchain, pDisplayTimingProperties, cmock_retval) vkGetRefreshCycleDurationGOOGLE_CMockExpectAndReturn(__LINE__, device, swapchain, pDisplayTimingProperties, cmock_retval) +void vkGetRefreshCycleDurationGOOGLE_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetRefreshCycleDurationGOOGLE_CALLBACK)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties, int cmock_num_calls); +void vkGetRefreshCycleDurationGOOGLE_AddCallback(CMOCK_vkGetRefreshCycleDurationGOOGLE_CALLBACK Callback); +void vkGetRefreshCycleDurationGOOGLE_Stub(CMOCK_vkGetRefreshCycleDurationGOOGLE_CALLBACK Callback); +#define vkGetRefreshCycleDurationGOOGLE_StubWithCallback vkGetRefreshCycleDurationGOOGLE_AddCallback +#define vkGetRefreshCycleDurationGOOGLE_ReturnThruPtr_pDisplayTimingProperties(pDisplayTimingProperties) vkGetRefreshCycleDurationGOOGLE_CMockReturnMemThruPtr_pDisplayTimingProperties(__LINE__, pDisplayTimingProperties, sizeof(VkRefreshCycleDurationGOOGLE)) +#define vkGetRefreshCycleDurationGOOGLE_ReturnArrayThruPtr_pDisplayTimingProperties(pDisplayTimingProperties, cmock_len) vkGetRefreshCycleDurationGOOGLE_CMockReturnMemThruPtr_pDisplayTimingProperties(__LINE__, pDisplayTimingProperties, cmock_len * sizeof(*pDisplayTimingProperties)) +#define vkGetRefreshCycleDurationGOOGLE_ReturnMemThruPtr_pDisplayTimingProperties(pDisplayTimingProperties, cmock_size) vkGetRefreshCycleDurationGOOGLE_CMockReturnMemThruPtr_pDisplayTimingProperties(__LINE__, pDisplayTimingProperties, cmock_size) +void vkGetRefreshCycleDurationGOOGLE_CMockReturnMemThruPtr_pDisplayTimingProperties(UNITY_LINE_TYPE cmock_line, VkRefreshCycleDurationGOOGLE const* pDisplayTimingProperties, size_t cmock_size); +#define vkGetRefreshCycleDurationGOOGLE_IgnoreArg_device() vkGetRefreshCycleDurationGOOGLE_CMockIgnoreArg_device(__LINE__) +void vkGetRefreshCycleDurationGOOGLE_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetRefreshCycleDurationGOOGLE_IgnoreArg_swapchain() vkGetRefreshCycleDurationGOOGLE_CMockIgnoreArg_swapchain(__LINE__) +void vkGetRefreshCycleDurationGOOGLE_CMockIgnoreArg_swapchain(UNITY_LINE_TYPE cmock_line); +#define vkGetRefreshCycleDurationGOOGLE_IgnoreArg_pDisplayTimingProperties() vkGetRefreshCycleDurationGOOGLE_CMockIgnoreArg_pDisplayTimingProperties(__LINE__) +void vkGetRefreshCycleDurationGOOGLE_CMockIgnoreArg_pDisplayTimingProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetPastPresentationTimingGOOGLE_IgnoreAndReturn(cmock_retval) vkGetPastPresentationTimingGOOGLE_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPastPresentationTimingGOOGLE_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPastPresentationTimingGOOGLE_StopIgnore() vkGetPastPresentationTimingGOOGLE_CMockStopIgnore() +void vkGetPastPresentationTimingGOOGLE_CMockStopIgnore(void); +#define vkGetPastPresentationTimingGOOGLE_ExpectAnyArgsAndReturn(cmock_retval) vkGetPastPresentationTimingGOOGLE_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPastPresentationTimingGOOGLE_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPastPresentationTimingGOOGLE_ExpectAndReturn(device, swapchain, pPresentationTimingCount, pPresentationTimings, cmock_retval) vkGetPastPresentationTimingGOOGLE_CMockExpectAndReturn(__LINE__, device, swapchain, pPresentationTimingCount, pPresentationTimings, cmock_retval) +void vkGetPastPresentationTimingGOOGLE_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPastPresentationTimingGOOGLE_CALLBACK)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings, int cmock_num_calls); +void vkGetPastPresentationTimingGOOGLE_AddCallback(CMOCK_vkGetPastPresentationTimingGOOGLE_CALLBACK Callback); +void vkGetPastPresentationTimingGOOGLE_Stub(CMOCK_vkGetPastPresentationTimingGOOGLE_CALLBACK Callback); +#define vkGetPastPresentationTimingGOOGLE_StubWithCallback vkGetPastPresentationTimingGOOGLE_AddCallback +#define vkGetPastPresentationTimingGOOGLE_ReturnThruPtr_pPresentationTimingCount(pPresentationTimingCount) vkGetPastPresentationTimingGOOGLE_CMockReturnMemThruPtr_pPresentationTimingCount(__LINE__, pPresentationTimingCount, sizeof(uint32_t)) +#define vkGetPastPresentationTimingGOOGLE_ReturnArrayThruPtr_pPresentationTimingCount(pPresentationTimingCount, cmock_len) vkGetPastPresentationTimingGOOGLE_CMockReturnMemThruPtr_pPresentationTimingCount(__LINE__, pPresentationTimingCount, cmock_len * sizeof(*pPresentationTimingCount)) +#define vkGetPastPresentationTimingGOOGLE_ReturnMemThruPtr_pPresentationTimingCount(pPresentationTimingCount, cmock_size) vkGetPastPresentationTimingGOOGLE_CMockReturnMemThruPtr_pPresentationTimingCount(__LINE__, pPresentationTimingCount, cmock_size) +void vkGetPastPresentationTimingGOOGLE_CMockReturnMemThruPtr_pPresentationTimingCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPresentationTimingCount, size_t cmock_size); +#define vkGetPastPresentationTimingGOOGLE_ReturnThruPtr_pPresentationTimings(pPresentationTimings) vkGetPastPresentationTimingGOOGLE_CMockReturnMemThruPtr_pPresentationTimings(__LINE__, pPresentationTimings, sizeof(VkPastPresentationTimingGOOGLE)) +#define vkGetPastPresentationTimingGOOGLE_ReturnArrayThruPtr_pPresentationTimings(pPresentationTimings, cmock_len) vkGetPastPresentationTimingGOOGLE_CMockReturnMemThruPtr_pPresentationTimings(__LINE__, pPresentationTimings, cmock_len * sizeof(*pPresentationTimings)) +#define vkGetPastPresentationTimingGOOGLE_ReturnMemThruPtr_pPresentationTimings(pPresentationTimings, cmock_size) vkGetPastPresentationTimingGOOGLE_CMockReturnMemThruPtr_pPresentationTimings(__LINE__, pPresentationTimings, cmock_size) +void vkGetPastPresentationTimingGOOGLE_CMockReturnMemThruPtr_pPresentationTimings(UNITY_LINE_TYPE cmock_line, VkPastPresentationTimingGOOGLE const* pPresentationTimings, size_t cmock_size); +#define vkGetPastPresentationTimingGOOGLE_IgnoreArg_device() vkGetPastPresentationTimingGOOGLE_CMockIgnoreArg_device(__LINE__) +void vkGetPastPresentationTimingGOOGLE_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetPastPresentationTimingGOOGLE_IgnoreArg_swapchain() vkGetPastPresentationTimingGOOGLE_CMockIgnoreArg_swapchain(__LINE__) +void vkGetPastPresentationTimingGOOGLE_CMockIgnoreArg_swapchain(UNITY_LINE_TYPE cmock_line); +#define vkGetPastPresentationTimingGOOGLE_IgnoreArg_pPresentationTimingCount() vkGetPastPresentationTimingGOOGLE_CMockIgnoreArg_pPresentationTimingCount(__LINE__) +void vkGetPastPresentationTimingGOOGLE_CMockIgnoreArg_pPresentationTimingCount(UNITY_LINE_TYPE cmock_line); +#define vkGetPastPresentationTimingGOOGLE_IgnoreArg_pPresentationTimings() vkGetPastPresentationTimingGOOGLE_CMockIgnoreArg_pPresentationTimings(__LINE__) +void vkGetPastPresentationTimingGOOGLE_CMockIgnoreArg_pPresentationTimings(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDiscardRectangleEXT_Ignore() vkCmdSetDiscardRectangleEXT_CMockIgnore() +void vkCmdSetDiscardRectangleEXT_CMockIgnore(void); +#define vkCmdSetDiscardRectangleEXT_StopIgnore() vkCmdSetDiscardRectangleEXT_CMockStopIgnore() +void vkCmdSetDiscardRectangleEXT_CMockStopIgnore(void); +#define vkCmdSetDiscardRectangleEXT_ExpectAnyArgs() vkCmdSetDiscardRectangleEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetDiscardRectangleEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDiscardRectangleEXT_Expect(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles) vkCmdSetDiscardRectangleEXT_CMockExpect(__LINE__, commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles) +void vkCmdSetDiscardRectangleEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles); +typedef void (* CMOCK_vkCmdSetDiscardRectangleEXT_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles, int cmock_num_calls); +void vkCmdSetDiscardRectangleEXT_AddCallback(CMOCK_vkCmdSetDiscardRectangleEXT_CALLBACK Callback); +void vkCmdSetDiscardRectangleEXT_Stub(CMOCK_vkCmdSetDiscardRectangleEXT_CALLBACK Callback); +#define vkCmdSetDiscardRectangleEXT_StubWithCallback vkCmdSetDiscardRectangleEXT_AddCallback +#define vkCmdSetDiscardRectangleEXT_IgnoreArg_commandBuffer() vkCmdSetDiscardRectangleEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetDiscardRectangleEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDiscardRectangleEXT_IgnoreArg_firstDiscardRectangle() vkCmdSetDiscardRectangleEXT_CMockIgnoreArg_firstDiscardRectangle(__LINE__) +void vkCmdSetDiscardRectangleEXT_CMockIgnoreArg_firstDiscardRectangle(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDiscardRectangleEXT_IgnoreArg_discardRectangleCount() vkCmdSetDiscardRectangleEXT_CMockIgnoreArg_discardRectangleCount(__LINE__) +void vkCmdSetDiscardRectangleEXT_CMockIgnoreArg_discardRectangleCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDiscardRectangleEXT_IgnoreArg_pDiscardRectangles() vkCmdSetDiscardRectangleEXT_CMockIgnoreArg_pDiscardRectangles(__LINE__) +void vkCmdSetDiscardRectangleEXT_CMockIgnoreArg_pDiscardRectangles(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDiscardRectangleEnableEXT_Ignore() vkCmdSetDiscardRectangleEnableEXT_CMockIgnore() +void vkCmdSetDiscardRectangleEnableEXT_CMockIgnore(void); +#define vkCmdSetDiscardRectangleEnableEXT_StopIgnore() vkCmdSetDiscardRectangleEnableEXT_CMockStopIgnore() +void vkCmdSetDiscardRectangleEnableEXT_CMockStopIgnore(void); +#define vkCmdSetDiscardRectangleEnableEXT_ExpectAnyArgs() vkCmdSetDiscardRectangleEnableEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetDiscardRectangleEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDiscardRectangleEnableEXT_Expect(commandBuffer, discardRectangleEnable) vkCmdSetDiscardRectangleEnableEXT_CMockExpect(__LINE__, commandBuffer, discardRectangleEnable) +void vkCmdSetDiscardRectangleEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable); +typedef void (* CMOCK_vkCmdSetDiscardRectangleEnableEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable, int cmock_num_calls); +void vkCmdSetDiscardRectangleEnableEXT_AddCallback(CMOCK_vkCmdSetDiscardRectangleEnableEXT_CALLBACK Callback); +void vkCmdSetDiscardRectangleEnableEXT_Stub(CMOCK_vkCmdSetDiscardRectangleEnableEXT_CALLBACK Callback); +#define vkCmdSetDiscardRectangleEnableEXT_StubWithCallback vkCmdSetDiscardRectangleEnableEXT_AddCallback +#define vkCmdSetDiscardRectangleEnableEXT_IgnoreArg_commandBuffer() vkCmdSetDiscardRectangleEnableEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetDiscardRectangleEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDiscardRectangleEnableEXT_IgnoreArg_discardRectangleEnable() vkCmdSetDiscardRectangleEnableEXT_CMockIgnoreArg_discardRectangleEnable(__LINE__) +void vkCmdSetDiscardRectangleEnableEXT_CMockIgnoreArg_discardRectangleEnable(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDiscardRectangleModeEXT_Ignore() vkCmdSetDiscardRectangleModeEXT_CMockIgnore() +void vkCmdSetDiscardRectangleModeEXT_CMockIgnore(void); +#define vkCmdSetDiscardRectangleModeEXT_StopIgnore() vkCmdSetDiscardRectangleModeEXT_CMockStopIgnore() +void vkCmdSetDiscardRectangleModeEXT_CMockStopIgnore(void); +#define vkCmdSetDiscardRectangleModeEXT_ExpectAnyArgs() vkCmdSetDiscardRectangleModeEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetDiscardRectangleModeEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDiscardRectangleModeEXT_Expect(commandBuffer, discardRectangleMode) vkCmdSetDiscardRectangleModeEXT_CMockExpect(__LINE__, commandBuffer, discardRectangleMode) +void vkCmdSetDiscardRectangleModeEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode); +typedef void (* CMOCK_vkCmdSetDiscardRectangleModeEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode, int cmock_num_calls); +void vkCmdSetDiscardRectangleModeEXT_AddCallback(CMOCK_vkCmdSetDiscardRectangleModeEXT_CALLBACK Callback); +void vkCmdSetDiscardRectangleModeEXT_Stub(CMOCK_vkCmdSetDiscardRectangleModeEXT_CALLBACK Callback); +#define vkCmdSetDiscardRectangleModeEXT_StubWithCallback vkCmdSetDiscardRectangleModeEXT_AddCallback +#define vkCmdSetDiscardRectangleModeEXT_IgnoreArg_commandBuffer() vkCmdSetDiscardRectangleModeEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetDiscardRectangleModeEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDiscardRectangleModeEXT_IgnoreArg_discardRectangleMode() vkCmdSetDiscardRectangleModeEXT_CMockIgnoreArg_discardRectangleMode(__LINE__) +void vkCmdSetDiscardRectangleModeEXT_CMockIgnoreArg_discardRectangleMode(UNITY_LINE_TYPE cmock_line); +#define vkSetHdrMetadataEXT_Ignore() vkSetHdrMetadataEXT_CMockIgnore() +void vkSetHdrMetadataEXT_CMockIgnore(void); +#define vkSetHdrMetadataEXT_StopIgnore() vkSetHdrMetadataEXT_CMockStopIgnore() +void vkSetHdrMetadataEXT_CMockStopIgnore(void); +#define vkSetHdrMetadataEXT_ExpectAnyArgs() vkSetHdrMetadataEXT_CMockExpectAnyArgs(__LINE__) +void vkSetHdrMetadataEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkSetHdrMetadataEXT_Expect(device, swapchainCount, pSwapchains, pMetadata) vkSetHdrMetadataEXT_CMockExpect(__LINE__, device, swapchainCount, pSwapchains, pMetadata) +void vkSetHdrMetadataEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata); +typedef void (* CMOCK_vkSetHdrMetadataEXT_CALLBACK)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata, int cmock_num_calls); +void vkSetHdrMetadataEXT_AddCallback(CMOCK_vkSetHdrMetadataEXT_CALLBACK Callback); +void vkSetHdrMetadataEXT_Stub(CMOCK_vkSetHdrMetadataEXT_CALLBACK Callback); +#define vkSetHdrMetadataEXT_StubWithCallback vkSetHdrMetadataEXT_AddCallback +#define vkSetHdrMetadataEXT_IgnoreArg_device() vkSetHdrMetadataEXT_CMockIgnoreArg_device(__LINE__) +void vkSetHdrMetadataEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkSetHdrMetadataEXT_IgnoreArg_swapchainCount() vkSetHdrMetadataEXT_CMockIgnoreArg_swapchainCount(__LINE__) +void vkSetHdrMetadataEXT_CMockIgnoreArg_swapchainCount(UNITY_LINE_TYPE cmock_line); +#define vkSetHdrMetadataEXT_IgnoreArg_pSwapchains() vkSetHdrMetadataEXT_CMockIgnoreArg_pSwapchains(__LINE__) +void vkSetHdrMetadataEXT_CMockIgnoreArg_pSwapchains(UNITY_LINE_TYPE cmock_line); +#define vkSetHdrMetadataEXT_IgnoreArg_pMetadata() vkSetHdrMetadataEXT_CMockIgnoreArg_pMetadata(__LINE__) +void vkSetHdrMetadataEXT_CMockIgnoreArg_pMetadata(UNITY_LINE_TYPE cmock_line); +#define vkSetDebugUtilsObjectNameEXT_IgnoreAndReturn(cmock_retval) vkSetDebugUtilsObjectNameEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkSetDebugUtilsObjectNameEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkSetDebugUtilsObjectNameEXT_StopIgnore() vkSetDebugUtilsObjectNameEXT_CMockStopIgnore() +void vkSetDebugUtilsObjectNameEXT_CMockStopIgnore(void); +#define vkSetDebugUtilsObjectNameEXT_ExpectAnyArgsAndReturn(cmock_retval) vkSetDebugUtilsObjectNameEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkSetDebugUtilsObjectNameEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkSetDebugUtilsObjectNameEXT_ExpectAndReturn(device, pNameInfo, cmock_retval) vkSetDebugUtilsObjectNameEXT_CMockExpectAndReturn(__LINE__, device, pNameInfo, cmock_retval) +void vkSetDebugUtilsObjectNameEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkSetDebugUtilsObjectNameEXT_CALLBACK)(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo, int cmock_num_calls); +void vkSetDebugUtilsObjectNameEXT_AddCallback(CMOCK_vkSetDebugUtilsObjectNameEXT_CALLBACK Callback); +void vkSetDebugUtilsObjectNameEXT_Stub(CMOCK_vkSetDebugUtilsObjectNameEXT_CALLBACK Callback); +#define vkSetDebugUtilsObjectNameEXT_StubWithCallback vkSetDebugUtilsObjectNameEXT_AddCallback +#define vkSetDebugUtilsObjectNameEXT_IgnoreArg_device() vkSetDebugUtilsObjectNameEXT_CMockIgnoreArg_device(__LINE__) +void vkSetDebugUtilsObjectNameEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkSetDebugUtilsObjectNameEXT_IgnoreArg_pNameInfo() vkSetDebugUtilsObjectNameEXT_CMockIgnoreArg_pNameInfo(__LINE__) +void vkSetDebugUtilsObjectNameEXT_CMockIgnoreArg_pNameInfo(UNITY_LINE_TYPE cmock_line); +#define vkSetDebugUtilsObjectTagEXT_IgnoreAndReturn(cmock_retval) vkSetDebugUtilsObjectTagEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkSetDebugUtilsObjectTagEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkSetDebugUtilsObjectTagEXT_StopIgnore() vkSetDebugUtilsObjectTagEXT_CMockStopIgnore() +void vkSetDebugUtilsObjectTagEXT_CMockStopIgnore(void); +#define vkSetDebugUtilsObjectTagEXT_ExpectAnyArgsAndReturn(cmock_retval) vkSetDebugUtilsObjectTagEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkSetDebugUtilsObjectTagEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkSetDebugUtilsObjectTagEXT_ExpectAndReturn(device, pTagInfo, cmock_retval) vkSetDebugUtilsObjectTagEXT_CMockExpectAndReturn(__LINE__, device, pTagInfo, cmock_retval) +void vkSetDebugUtilsObjectTagEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkSetDebugUtilsObjectTagEXT_CALLBACK)(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo, int cmock_num_calls); +void vkSetDebugUtilsObjectTagEXT_AddCallback(CMOCK_vkSetDebugUtilsObjectTagEXT_CALLBACK Callback); +void vkSetDebugUtilsObjectTagEXT_Stub(CMOCK_vkSetDebugUtilsObjectTagEXT_CALLBACK Callback); +#define vkSetDebugUtilsObjectTagEXT_StubWithCallback vkSetDebugUtilsObjectTagEXT_AddCallback +#define vkSetDebugUtilsObjectTagEXT_IgnoreArg_device() vkSetDebugUtilsObjectTagEXT_CMockIgnoreArg_device(__LINE__) +void vkSetDebugUtilsObjectTagEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkSetDebugUtilsObjectTagEXT_IgnoreArg_pTagInfo() vkSetDebugUtilsObjectTagEXT_CMockIgnoreArg_pTagInfo(__LINE__) +void vkSetDebugUtilsObjectTagEXT_CMockIgnoreArg_pTagInfo(UNITY_LINE_TYPE cmock_line); +#define vkQueueBeginDebugUtilsLabelEXT_Ignore() vkQueueBeginDebugUtilsLabelEXT_CMockIgnore() +void vkQueueBeginDebugUtilsLabelEXT_CMockIgnore(void); +#define vkQueueBeginDebugUtilsLabelEXT_StopIgnore() vkQueueBeginDebugUtilsLabelEXT_CMockStopIgnore() +void vkQueueBeginDebugUtilsLabelEXT_CMockStopIgnore(void); +#define vkQueueBeginDebugUtilsLabelEXT_ExpectAnyArgs() vkQueueBeginDebugUtilsLabelEXT_CMockExpectAnyArgs(__LINE__) +void vkQueueBeginDebugUtilsLabelEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkQueueBeginDebugUtilsLabelEXT_Expect(queue, pLabelInfo) vkQueueBeginDebugUtilsLabelEXT_CMockExpect(__LINE__, queue, pLabelInfo) +void vkQueueBeginDebugUtilsLabelEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); +typedef void (* CMOCK_vkQueueBeginDebugUtilsLabelEXT_CALLBACK)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo, int cmock_num_calls); +void vkQueueBeginDebugUtilsLabelEXT_AddCallback(CMOCK_vkQueueBeginDebugUtilsLabelEXT_CALLBACK Callback); +void vkQueueBeginDebugUtilsLabelEXT_Stub(CMOCK_vkQueueBeginDebugUtilsLabelEXT_CALLBACK Callback); +#define vkQueueBeginDebugUtilsLabelEXT_StubWithCallback vkQueueBeginDebugUtilsLabelEXT_AddCallback +#define vkQueueBeginDebugUtilsLabelEXT_IgnoreArg_queue() vkQueueBeginDebugUtilsLabelEXT_CMockIgnoreArg_queue(__LINE__) +void vkQueueBeginDebugUtilsLabelEXT_CMockIgnoreArg_queue(UNITY_LINE_TYPE cmock_line); +#define vkQueueBeginDebugUtilsLabelEXT_IgnoreArg_pLabelInfo() vkQueueBeginDebugUtilsLabelEXT_CMockIgnoreArg_pLabelInfo(__LINE__) +void vkQueueBeginDebugUtilsLabelEXT_CMockIgnoreArg_pLabelInfo(UNITY_LINE_TYPE cmock_line); +#define vkQueueEndDebugUtilsLabelEXT_Ignore() vkQueueEndDebugUtilsLabelEXT_CMockIgnore() +void vkQueueEndDebugUtilsLabelEXT_CMockIgnore(void); +#define vkQueueEndDebugUtilsLabelEXT_StopIgnore() vkQueueEndDebugUtilsLabelEXT_CMockStopIgnore() +void vkQueueEndDebugUtilsLabelEXT_CMockStopIgnore(void); +#define vkQueueEndDebugUtilsLabelEXT_ExpectAnyArgs() vkQueueEndDebugUtilsLabelEXT_CMockExpectAnyArgs(__LINE__) +void vkQueueEndDebugUtilsLabelEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkQueueEndDebugUtilsLabelEXT_Expect(queue) vkQueueEndDebugUtilsLabelEXT_CMockExpect(__LINE__, queue) +void vkQueueEndDebugUtilsLabelEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkQueue queue); +typedef void (* CMOCK_vkQueueEndDebugUtilsLabelEXT_CALLBACK)(VkQueue queue, int cmock_num_calls); +void vkQueueEndDebugUtilsLabelEXT_AddCallback(CMOCK_vkQueueEndDebugUtilsLabelEXT_CALLBACK Callback); +void vkQueueEndDebugUtilsLabelEXT_Stub(CMOCK_vkQueueEndDebugUtilsLabelEXT_CALLBACK Callback); +#define vkQueueEndDebugUtilsLabelEXT_StubWithCallback vkQueueEndDebugUtilsLabelEXT_AddCallback +#define vkQueueEndDebugUtilsLabelEXT_IgnoreArg_queue() vkQueueEndDebugUtilsLabelEXT_CMockIgnoreArg_queue(__LINE__) +void vkQueueEndDebugUtilsLabelEXT_CMockIgnoreArg_queue(UNITY_LINE_TYPE cmock_line); +#define vkQueueInsertDebugUtilsLabelEXT_Ignore() vkQueueInsertDebugUtilsLabelEXT_CMockIgnore() +void vkQueueInsertDebugUtilsLabelEXT_CMockIgnore(void); +#define vkQueueInsertDebugUtilsLabelEXT_StopIgnore() vkQueueInsertDebugUtilsLabelEXT_CMockStopIgnore() +void vkQueueInsertDebugUtilsLabelEXT_CMockStopIgnore(void); +#define vkQueueInsertDebugUtilsLabelEXT_ExpectAnyArgs() vkQueueInsertDebugUtilsLabelEXT_CMockExpectAnyArgs(__LINE__) +void vkQueueInsertDebugUtilsLabelEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkQueueInsertDebugUtilsLabelEXT_Expect(queue, pLabelInfo) vkQueueInsertDebugUtilsLabelEXT_CMockExpect(__LINE__, queue, pLabelInfo) +void vkQueueInsertDebugUtilsLabelEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); +typedef void (* CMOCK_vkQueueInsertDebugUtilsLabelEXT_CALLBACK)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo, int cmock_num_calls); +void vkQueueInsertDebugUtilsLabelEXT_AddCallback(CMOCK_vkQueueInsertDebugUtilsLabelEXT_CALLBACK Callback); +void vkQueueInsertDebugUtilsLabelEXT_Stub(CMOCK_vkQueueInsertDebugUtilsLabelEXT_CALLBACK Callback); +#define vkQueueInsertDebugUtilsLabelEXT_StubWithCallback vkQueueInsertDebugUtilsLabelEXT_AddCallback +#define vkQueueInsertDebugUtilsLabelEXT_IgnoreArg_queue() vkQueueInsertDebugUtilsLabelEXT_CMockIgnoreArg_queue(__LINE__) +void vkQueueInsertDebugUtilsLabelEXT_CMockIgnoreArg_queue(UNITY_LINE_TYPE cmock_line); +#define vkQueueInsertDebugUtilsLabelEXT_IgnoreArg_pLabelInfo() vkQueueInsertDebugUtilsLabelEXT_CMockIgnoreArg_pLabelInfo(__LINE__) +void vkQueueInsertDebugUtilsLabelEXT_CMockIgnoreArg_pLabelInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginDebugUtilsLabelEXT_Ignore() vkCmdBeginDebugUtilsLabelEXT_CMockIgnore() +void vkCmdBeginDebugUtilsLabelEXT_CMockIgnore(void); +#define vkCmdBeginDebugUtilsLabelEXT_StopIgnore() vkCmdBeginDebugUtilsLabelEXT_CMockStopIgnore() +void vkCmdBeginDebugUtilsLabelEXT_CMockStopIgnore(void); +#define vkCmdBeginDebugUtilsLabelEXT_ExpectAnyArgs() vkCmdBeginDebugUtilsLabelEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdBeginDebugUtilsLabelEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginDebugUtilsLabelEXT_Expect(commandBuffer, pLabelInfo) vkCmdBeginDebugUtilsLabelEXT_CMockExpect(__LINE__, commandBuffer, pLabelInfo) +void vkCmdBeginDebugUtilsLabelEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); +typedef void (* CMOCK_vkCmdBeginDebugUtilsLabelEXT_CALLBACK)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo, int cmock_num_calls); +void vkCmdBeginDebugUtilsLabelEXT_AddCallback(CMOCK_vkCmdBeginDebugUtilsLabelEXT_CALLBACK Callback); +void vkCmdBeginDebugUtilsLabelEXT_Stub(CMOCK_vkCmdBeginDebugUtilsLabelEXT_CALLBACK Callback); +#define vkCmdBeginDebugUtilsLabelEXT_StubWithCallback vkCmdBeginDebugUtilsLabelEXT_AddCallback +#define vkCmdBeginDebugUtilsLabelEXT_IgnoreArg_commandBuffer() vkCmdBeginDebugUtilsLabelEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBeginDebugUtilsLabelEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBeginDebugUtilsLabelEXT_IgnoreArg_pLabelInfo() vkCmdBeginDebugUtilsLabelEXT_CMockIgnoreArg_pLabelInfo(__LINE__) +void vkCmdBeginDebugUtilsLabelEXT_CMockIgnoreArg_pLabelInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndDebugUtilsLabelEXT_Ignore() vkCmdEndDebugUtilsLabelEXT_CMockIgnore() +void vkCmdEndDebugUtilsLabelEXT_CMockIgnore(void); +#define vkCmdEndDebugUtilsLabelEXT_StopIgnore() vkCmdEndDebugUtilsLabelEXT_CMockStopIgnore() +void vkCmdEndDebugUtilsLabelEXT_CMockStopIgnore(void); +#define vkCmdEndDebugUtilsLabelEXT_ExpectAnyArgs() vkCmdEndDebugUtilsLabelEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdEndDebugUtilsLabelEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdEndDebugUtilsLabelEXT_Expect(commandBuffer) vkCmdEndDebugUtilsLabelEXT_CMockExpect(__LINE__, commandBuffer) +void vkCmdEndDebugUtilsLabelEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer); +typedef void (* CMOCK_vkCmdEndDebugUtilsLabelEXT_CALLBACK)(VkCommandBuffer commandBuffer, int cmock_num_calls); +void vkCmdEndDebugUtilsLabelEXT_AddCallback(CMOCK_vkCmdEndDebugUtilsLabelEXT_CALLBACK Callback); +void vkCmdEndDebugUtilsLabelEXT_Stub(CMOCK_vkCmdEndDebugUtilsLabelEXT_CALLBACK Callback); +#define vkCmdEndDebugUtilsLabelEXT_StubWithCallback vkCmdEndDebugUtilsLabelEXT_AddCallback +#define vkCmdEndDebugUtilsLabelEXT_IgnoreArg_commandBuffer() vkCmdEndDebugUtilsLabelEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdEndDebugUtilsLabelEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdInsertDebugUtilsLabelEXT_Ignore() vkCmdInsertDebugUtilsLabelEXT_CMockIgnore() +void vkCmdInsertDebugUtilsLabelEXT_CMockIgnore(void); +#define vkCmdInsertDebugUtilsLabelEXT_StopIgnore() vkCmdInsertDebugUtilsLabelEXT_CMockStopIgnore() +void vkCmdInsertDebugUtilsLabelEXT_CMockStopIgnore(void); +#define vkCmdInsertDebugUtilsLabelEXT_ExpectAnyArgs() vkCmdInsertDebugUtilsLabelEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdInsertDebugUtilsLabelEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdInsertDebugUtilsLabelEXT_Expect(commandBuffer, pLabelInfo) vkCmdInsertDebugUtilsLabelEXT_CMockExpect(__LINE__, commandBuffer, pLabelInfo) +void vkCmdInsertDebugUtilsLabelEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); +typedef void (* CMOCK_vkCmdInsertDebugUtilsLabelEXT_CALLBACK)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo, int cmock_num_calls); +void vkCmdInsertDebugUtilsLabelEXT_AddCallback(CMOCK_vkCmdInsertDebugUtilsLabelEXT_CALLBACK Callback); +void vkCmdInsertDebugUtilsLabelEXT_Stub(CMOCK_vkCmdInsertDebugUtilsLabelEXT_CALLBACK Callback); +#define vkCmdInsertDebugUtilsLabelEXT_StubWithCallback vkCmdInsertDebugUtilsLabelEXT_AddCallback +#define vkCmdInsertDebugUtilsLabelEXT_IgnoreArg_commandBuffer() vkCmdInsertDebugUtilsLabelEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdInsertDebugUtilsLabelEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdInsertDebugUtilsLabelEXT_IgnoreArg_pLabelInfo() vkCmdInsertDebugUtilsLabelEXT_CMockIgnoreArg_pLabelInfo(__LINE__) +void vkCmdInsertDebugUtilsLabelEXT_CMockIgnoreArg_pLabelInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateDebugUtilsMessengerEXT_IgnoreAndReturn(cmock_retval) vkCreateDebugUtilsMessengerEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateDebugUtilsMessengerEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateDebugUtilsMessengerEXT_StopIgnore() vkCreateDebugUtilsMessengerEXT_CMockStopIgnore() +void vkCreateDebugUtilsMessengerEXT_CMockStopIgnore(void); +#define vkCreateDebugUtilsMessengerEXT_ExpectAnyArgsAndReturn(cmock_retval) vkCreateDebugUtilsMessengerEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateDebugUtilsMessengerEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateDebugUtilsMessengerEXT_ExpectAndReturn(instance, pCreateInfo, pAllocator, pMessenger, cmock_retval) vkCreateDebugUtilsMessengerEXT_CMockExpectAndReturn(__LINE__, instance, pCreateInfo, pAllocator, pMessenger, cmock_retval) +void vkCreateDebugUtilsMessengerEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateDebugUtilsMessengerEXT_CALLBACK)(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger, int cmock_num_calls); +void vkCreateDebugUtilsMessengerEXT_AddCallback(CMOCK_vkCreateDebugUtilsMessengerEXT_CALLBACK Callback); +void vkCreateDebugUtilsMessengerEXT_Stub(CMOCK_vkCreateDebugUtilsMessengerEXT_CALLBACK Callback); +#define vkCreateDebugUtilsMessengerEXT_StubWithCallback vkCreateDebugUtilsMessengerEXT_AddCallback +#define vkCreateDebugUtilsMessengerEXT_ReturnThruPtr_pMessenger(pMessenger) vkCreateDebugUtilsMessengerEXT_CMockReturnMemThruPtr_pMessenger(__LINE__, pMessenger, sizeof(VkDebugUtilsMessengerEXT)) +#define vkCreateDebugUtilsMessengerEXT_ReturnArrayThruPtr_pMessenger(pMessenger, cmock_len) vkCreateDebugUtilsMessengerEXT_CMockReturnMemThruPtr_pMessenger(__LINE__, pMessenger, cmock_len * sizeof(*pMessenger)) +#define vkCreateDebugUtilsMessengerEXT_ReturnMemThruPtr_pMessenger(pMessenger, cmock_size) vkCreateDebugUtilsMessengerEXT_CMockReturnMemThruPtr_pMessenger(__LINE__, pMessenger, cmock_size) +void vkCreateDebugUtilsMessengerEXT_CMockReturnMemThruPtr_pMessenger(UNITY_LINE_TYPE cmock_line, VkDebugUtilsMessengerEXT const* pMessenger, size_t cmock_size); +#define vkCreateDebugUtilsMessengerEXT_IgnoreArg_instance() vkCreateDebugUtilsMessengerEXT_CMockIgnoreArg_instance(__LINE__) +void vkCreateDebugUtilsMessengerEXT_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line); +#define vkCreateDebugUtilsMessengerEXT_IgnoreArg_pCreateInfo() vkCreateDebugUtilsMessengerEXT_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateDebugUtilsMessengerEXT_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateDebugUtilsMessengerEXT_IgnoreArg_pAllocator() vkCreateDebugUtilsMessengerEXT_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateDebugUtilsMessengerEXT_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateDebugUtilsMessengerEXT_IgnoreArg_pMessenger() vkCreateDebugUtilsMessengerEXT_CMockIgnoreArg_pMessenger(__LINE__) +void vkCreateDebugUtilsMessengerEXT_CMockIgnoreArg_pMessenger(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDebugUtilsMessengerEXT_Ignore() vkDestroyDebugUtilsMessengerEXT_CMockIgnore() +void vkDestroyDebugUtilsMessengerEXT_CMockIgnore(void); +#define vkDestroyDebugUtilsMessengerEXT_StopIgnore() vkDestroyDebugUtilsMessengerEXT_CMockStopIgnore() +void vkDestroyDebugUtilsMessengerEXT_CMockStopIgnore(void); +#define vkDestroyDebugUtilsMessengerEXT_ExpectAnyArgs() vkDestroyDebugUtilsMessengerEXT_CMockExpectAnyArgs(__LINE__) +void vkDestroyDebugUtilsMessengerEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDebugUtilsMessengerEXT_Expect(instance, messenger, pAllocator) vkDestroyDebugUtilsMessengerEXT_CMockExpect(__LINE__, instance, messenger, pAllocator) +void vkDestroyDebugUtilsMessengerEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyDebugUtilsMessengerEXT_CALLBACK)(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyDebugUtilsMessengerEXT_AddCallback(CMOCK_vkDestroyDebugUtilsMessengerEXT_CALLBACK Callback); +void vkDestroyDebugUtilsMessengerEXT_Stub(CMOCK_vkDestroyDebugUtilsMessengerEXT_CALLBACK Callback); +#define vkDestroyDebugUtilsMessengerEXT_StubWithCallback vkDestroyDebugUtilsMessengerEXT_AddCallback +#define vkDestroyDebugUtilsMessengerEXT_IgnoreArg_instance() vkDestroyDebugUtilsMessengerEXT_CMockIgnoreArg_instance(__LINE__) +void vkDestroyDebugUtilsMessengerEXT_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDebugUtilsMessengerEXT_IgnoreArg_messenger() vkDestroyDebugUtilsMessengerEXT_CMockIgnoreArg_messenger(__LINE__) +void vkDestroyDebugUtilsMessengerEXT_CMockIgnoreArg_messenger(UNITY_LINE_TYPE cmock_line); +#define vkDestroyDebugUtilsMessengerEXT_IgnoreArg_pAllocator() vkDestroyDebugUtilsMessengerEXT_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyDebugUtilsMessengerEXT_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkSubmitDebugUtilsMessageEXT_Ignore() vkSubmitDebugUtilsMessageEXT_CMockIgnore() +void vkSubmitDebugUtilsMessageEXT_CMockIgnore(void); +#define vkSubmitDebugUtilsMessageEXT_StopIgnore() vkSubmitDebugUtilsMessageEXT_CMockStopIgnore() +void vkSubmitDebugUtilsMessageEXT_CMockStopIgnore(void); +#define vkSubmitDebugUtilsMessageEXT_ExpectAnyArgs() vkSubmitDebugUtilsMessageEXT_CMockExpectAnyArgs(__LINE__) +void vkSubmitDebugUtilsMessageEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkSubmitDebugUtilsMessageEXT_Expect(instance, messageSeverity, messageTypes, pCallbackData) vkSubmitDebugUtilsMessageEXT_CMockExpect(__LINE__, instance, messageSeverity, messageTypes, pCallbackData) +void vkSubmitDebugUtilsMessageEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); +typedef void (* CMOCK_vkSubmitDebugUtilsMessageEXT_CALLBACK)(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, int cmock_num_calls); +void vkSubmitDebugUtilsMessageEXT_AddCallback(CMOCK_vkSubmitDebugUtilsMessageEXT_CALLBACK Callback); +void vkSubmitDebugUtilsMessageEXT_Stub(CMOCK_vkSubmitDebugUtilsMessageEXT_CALLBACK Callback); +#define vkSubmitDebugUtilsMessageEXT_StubWithCallback vkSubmitDebugUtilsMessageEXT_AddCallback +#define vkSubmitDebugUtilsMessageEXT_IgnoreArg_instance() vkSubmitDebugUtilsMessageEXT_CMockIgnoreArg_instance(__LINE__) +void vkSubmitDebugUtilsMessageEXT_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line); +#define vkSubmitDebugUtilsMessageEXT_IgnoreArg_messageSeverity() vkSubmitDebugUtilsMessageEXT_CMockIgnoreArg_messageSeverity(__LINE__) +void vkSubmitDebugUtilsMessageEXT_CMockIgnoreArg_messageSeverity(UNITY_LINE_TYPE cmock_line); +#define vkSubmitDebugUtilsMessageEXT_IgnoreArg_messageTypes() vkSubmitDebugUtilsMessageEXT_CMockIgnoreArg_messageTypes(__LINE__) +void vkSubmitDebugUtilsMessageEXT_CMockIgnoreArg_messageTypes(UNITY_LINE_TYPE cmock_line); +#define vkSubmitDebugUtilsMessageEXT_IgnoreArg_pCallbackData() vkSubmitDebugUtilsMessageEXT_CMockIgnoreArg_pCallbackData(__LINE__) +void vkSubmitDebugUtilsMessageEXT_CMockIgnoreArg_pCallbackData(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetSampleLocationsEXT_Ignore() vkCmdSetSampleLocationsEXT_CMockIgnore() +void vkCmdSetSampleLocationsEXT_CMockIgnore(void); +#define vkCmdSetSampleLocationsEXT_StopIgnore() vkCmdSetSampleLocationsEXT_CMockStopIgnore() +void vkCmdSetSampleLocationsEXT_CMockStopIgnore(void); +#define vkCmdSetSampleLocationsEXT_ExpectAnyArgs() vkCmdSetSampleLocationsEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetSampleLocationsEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetSampleLocationsEXT_Expect(commandBuffer, pSampleLocationsInfo) vkCmdSetSampleLocationsEXT_CMockExpect(__LINE__, commandBuffer, pSampleLocationsInfo) +void vkCmdSetSampleLocationsEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo); +typedef void (* CMOCK_vkCmdSetSampleLocationsEXT_CALLBACK)(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo, int cmock_num_calls); +void vkCmdSetSampleLocationsEXT_AddCallback(CMOCK_vkCmdSetSampleLocationsEXT_CALLBACK Callback); +void vkCmdSetSampleLocationsEXT_Stub(CMOCK_vkCmdSetSampleLocationsEXT_CALLBACK Callback); +#define vkCmdSetSampleLocationsEXT_StubWithCallback vkCmdSetSampleLocationsEXT_AddCallback +#define vkCmdSetSampleLocationsEXT_IgnoreArg_commandBuffer() vkCmdSetSampleLocationsEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetSampleLocationsEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetSampleLocationsEXT_IgnoreArg_pSampleLocationsInfo() vkCmdSetSampleLocationsEXT_CMockIgnoreArg_pSampleLocationsInfo(__LINE__) +void vkCmdSetSampleLocationsEXT_CMockIgnoreArg_pSampleLocationsInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceMultisamplePropertiesEXT_Ignore() vkGetPhysicalDeviceMultisamplePropertiesEXT_CMockIgnore() +void vkGetPhysicalDeviceMultisamplePropertiesEXT_CMockIgnore(void); +#define vkGetPhysicalDeviceMultisamplePropertiesEXT_StopIgnore() vkGetPhysicalDeviceMultisamplePropertiesEXT_CMockStopIgnore() +void vkGetPhysicalDeviceMultisamplePropertiesEXT_CMockStopIgnore(void); +#define vkGetPhysicalDeviceMultisamplePropertiesEXT_ExpectAnyArgs() vkGetPhysicalDeviceMultisamplePropertiesEXT_CMockExpectAnyArgs(__LINE__) +void vkGetPhysicalDeviceMultisamplePropertiesEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceMultisamplePropertiesEXT_Expect(physicalDevice, samples, pMultisampleProperties) vkGetPhysicalDeviceMultisamplePropertiesEXT_CMockExpect(__LINE__, physicalDevice, samples, pMultisampleProperties) +void vkGetPhysicalDeviceMultisamplePropertiesEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties); +typedef void (* CMOCK_vkGetPhysicalDeviceMultisamplePropertiesEXT_CALLBACK)(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties, int cmock_num_calls); +void vkGetPhysicalDeviceMultisamplePropertiesEXT_AddCallback(CMOCK_vkGetPhysicalDeviceMultisamplePropertiesEXT_CALLBACK Callback); +void vkGetPhysicalDeviceMultisamplePropertiesEXT_Stub(CMOCK_vkGetPhysicalDeviceMultisamplePropertiesEXT_CALLBACK Callback); +#define vkGetPhysicalDeviceMultisamplePropertiesEXT_StubWithCallback vkGetPhysicalDeviceMultisamplePropertiesEXT_AddCallback +#define vkGetPhysicalDeviceMultisamplePropertiesEXT_ReturnThruPtr_pMultisampleProperties(pMultisampleProperties) vkGetPhysicalDeviceMultisamplePropertiesEXT_CMockReturnMemThruPtr_pMultisampleProperties(__LINE__, pMultisampleProperties, sizeof(VkMultisamplePropertiesEXT)) +#define vkGetPhysicalDeviceMultisamplePropertiesEXT_ReturnArrayThruPtr_pMultisampleProperties(pMultisampleProperties, cmock_len) vkGetPhysicalDeviceMultisamplePropertiesEXT_CMockReturnMemThruPtr_pMultisampleProperties(__LINE__, pMultisampleProperties, cmock_len * sizeof(*pMultisampleProperties)) +#define vkGetPhysicalDeviceMultisamplePropertiesEXT_ReturnMemThruPtr_pMultisampleProperties(pMultisampleProperties, cmock_size) vkGetPhysicalDeviceMultisamplePropertiesEXT_CMockReturnMemThruPtr_pMultisampleProperties(__LINE__, pMultisampleProperties, cmock_size) +void vkGetPhysicalDeviceMultisamplePropertiesEXT_CMockReturnMemThruPtr_pMultisampleProperties(UNITY_LINE_TYPE cmock_line, VkMultisamplePropertiesEXT const* pMultisampleProperties, size_t cmock_size); +#define vkGetPhysicalDeviceMultisamplePropertiesEXT_IgnoreArg_physicalDevice() vkGetPhysicalDeviceMultisamplePropertiesEXT_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceMultisamplePropertiesEXT_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceMultisamplePropertiesEXT_IgnoreArg_samples() vkGetPhysicalDeviceMultisamplePropertiesEXT_CMockIgnoreArg_samples(__LINE__) +void vkGetPhysicalDeviceMultisamplePropertiesEXT_CMockIgnoreArg_samples(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceMultisamplePropertiesEXT_IgnoreArg_pMultisampleProperties() vkGetPhysicalDeviceMultisamplePropertiesEXT_CMockIgnoreArg_pMultisampleProperties(__LINE__) +void vkGetPhysicalDeviceMultisamplePropertiesEXT_CMockIgnoreArg_pMultisampleProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetImageDrmFormatModifierPropertiesEXT_IgnoreAndReturn(cmock_retval) vkGetImageDrmFormatModifierPropertiesEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetImageDrmFormatModifierPropertiesEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetImageDrmFormatModifierPropertiesEXT_StopIgnore() vkGetImageDrmFormatModifierPropertiesEXT_CMockStopIgnore() +void vkGetImageDrmFormatModifierPropertiesEXT_CMockStopIgnore(void); +#define vkGetImageDrmFormatModifierPropertiesEXT_ExpectAnyArgsAndReturn(cmock_retval) vkGetImageDrmFormatModifierPropertiesEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetImageDrmFormatModifierPropertiesEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetImageDrmFormatModifierPropertiesEXT_ExpectAndReturn(device, image, pProperties, cmock_retval) vkGetImageDrmFormatModifierPropertiesEXT_CMockExpectAndReturn(__LINE__, device, image, pProperties, cmock_retval) +void vkGetImageDrmFormatModifierPropertiesEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetImageDrmFormatModifierPropertiesEXT_CALLBACK)(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties, int cmock_num_calls); +void vkGetImageDrmFormatModifierPropertiesEXT_AddCallback(CMOCK_vkGetImageDrmFormatModifierPropertiesEXT_CALLBACK Callback); +void vkGetImageDrmFormatModifierPropertiesEXT_Stub(CMOCK_vkGetImageDrmFormatModifierPropertiesEXT_CALLBACK Callback); +#define vkGetImageDrmFormatModifierPropertiesEXT_StubWithCallback vkGetImageDrmFormatModifierPropertiesEXT_AddCallback +#define vkGetImageDrmFormatModifierPropertiesEXT_ReturnThruPtr_pProperties(pProperties) vkGetImageDrmFormatModifierPropertiesEXT_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, sizeof(VkImageDrmFormatModifierPropertiesEXT)) +#define vkGetImageDrmFormatModifierPropertiesEXT_ReturnArrayThruPtr_pProperties(pProperties, cmock_len) vkGetImageDrmFormatModifierPropertiesEXT_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_len * sizeof(*pProperties)) +#define vkGetImageDrmFormatModifierPropertiesEXT_ReturnMemThruPtr_pProperties(pProperties, cmock_size) vkGetImageDrmFormatModifierPropertiesEXT_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_size) +void vkGetImageDrmFormatModifierPropertiesEXT_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkImageDrmFormatModifierPropertiesEXT const* pProperties, size_t cmock_size); +#define vkGetImageDrmFormatModifierPropertiesEXT_IgnoreArg_device() vkGetImageDrmFormatModifierPropertiesEXT_CMockIgnoreArg_device(__LINE__) +void vkGetImageDrmFormatModifierPropertiesEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetImageDrmFormatModifierPropertiesEXT_IgnoreArg_image() vkGetImageDrmFormatModifierPropertiesEXT_CMockIgnoreArg_image(__LINE__) +void vkGetImageDrmFormatModifierPropertiesEXT_CMockIgnoreArg_image(UNITY_LINE_TYPE cmock_line); +#define vkGetImageDrmFormatModifierPropertiesEXT_IgnoreArg_pProperties() vkGetImageDrmFormatModifierPropertiesEXT_CMockIgnoreArg_pProperties(__LINE__) +void vkGetImageDrmFormatModifierPropertiesEXT_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line); +#define vkCreateValidationCacheEXT_IgnoreAndReturn(cmock_retval) vkCreateValidationCacheEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateValidationCacheEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateValidationCacheEXT_StopIgnore() vkCreateValidationCacheEXT_CMockStopIgnore() +void vkCreateValidationCacheEXT_CMockStopIgnore(void); +#define vkCreateValidationCacheEXT_ExpectAnyArgsAndReturn(cmock_retval) vkCreateValidationCacheEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateValidationCacheEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateValidationCacheEXT_ExpectAndReturn(device, pCreateInfo, pAllocator, pValidationCache, cmock_retval) vkCreateValidationCacheEXT_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pValidationCache, cmock_retval) +void vkCreateValidationCacheEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateValidationCacheEXT_CALLBACK)(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache, int cmock_num_calls); +void vkCreateValidationCacheEXT_AddCallback(CMOCK_vkCreateValidationCacheEXT_CALLBACK Callback); +void vkCreateValidationCacheEXT_Stub(CMOCK_vkCreateValidationCacheEXT_CALLBACK Callback); +#define vkCreateValidationCacheEXT_StubWithCallback vkCreateValidationCacheEXT_AddCallback +#define vkCreateValidationCacheEXT_ReturnThruPtr_pValidationCache(pValidationCache) vkCreateValidationCacheEXT_CMockReturnMemThruPtr_pValidationCache(__LINE__, pValidationCache, sizeof(VkValidationCacheEXT)) +#define vkCreateValidationCacheEXT_ReturnArrayThruPtr_pValidationCache(pValidationCache, cmock_len) vkCreateValidationCacheEXT_CMockReturnMemThruPtr_pValidationCache(__LINE__, pValidationCache, cmock_len * sizeof(*pValidationCache)) +#define vkCreateValidationCacheEXT_ReturnMemThruPtr_pValidationCache(pValidationCache, cmock_size) vkCreateValidationCacheEXT_CMockReturnMemThruPtr_pValidationCache(__LINE__, pValidationCache, cmock_size) +void vkCreateValidationCacheEXT_CMockReturnMemThruPtr_pValidationCache(UNITY_LINE_TYPE cmock_line, VkValidationCacheEXT const* pValidationCache, size_t cmock_size); +#define vkCreateValidationCacheEXT_IgnoreArg_device() vkCreateValidationCacheEXT_CMockIgnoreArg_device(__LINE__) +void vkCreateValidationCacheEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateValidationCacheEXT_IgnoreArg_pCreateInfo() vkCreateValidationCacheEXT_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateValidationCacheEXT_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateValidationCacheEXT_IgnoreArg_pAllocator() vkCreateValidationCacheEXT_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateValidationCacheEXT_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateValidationCacheEXT_IgnoreArg_pValidationCache() vkCreateValidationCacheEXT_CMockIgnoreArg_pValidationCache(__LINE__) +void vkCreateValidationCacheEXT_CMockIgnoreArg_pValidationCache(UNITY_LINE_TYPE cmock_line); +#define vkDestroyValidationCacheEXT_Ignore() vkDestroyValidationCacheEXT_CMockIgnore() +void vkDestroyValidationCacheEXT_CMockIgnore(void); +#define vkDestroyValidationCacheEXT_StopIgnore() vkDestroyValidationCacheEXT_CMockStopIgnore() +void vkDestroyValidationCacheEXT_CMockStopIgnore(void); +#define vkDestroyValidationCacheEXT_ExpectAnyArgs() vkDestroyValidationCacheEXT_CMockExpectAnyArgs(__LINE__) +void vkDestroyValidationCacheEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyValidationCacheEXT_Expect(device, validationCache, pAllocator) vkDestroyValidationCacheEXT_CMockExpect(__LINE__, device, validationCache, pAllocator) +void vkDestroyValidationCacheEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyValidationCacheEXT_CALLBACK)(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyValidationCacheEXT_AddCallback(CMOCK_vkDestroyValidationCacheEXT_CALLBACK Callback); +void vkDestroyValidationCacheEXT_Stub(CMOCK_vkDestroyValidationCacheEXT_CALLBACK Callback); +#define vkDestroyValidationCacheEXT_StubWithCallback vkDestroyValidationCacheEXT_AddCallback +#define vkDestroyValidationCacheEXT_IgnoreArg_device() vkDestroyValidationCacheEXT_CMockIgnoreArg_device(__LINE__) +void vkDestroyValidationCacheEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyValidationCacheEXT_IgnoreArg_validationCache() vkDestroyValidationCacheEXT_CMockIgnoreArg_validationCache(__LINE__) +void vkDestroyValidationCacheEXT_CMockIgnoreArg_validationCache(UNITY_LINE_TYPE cmock_line); +#define vkDestroyValidationCacheEXT_IgnoreArg_pAllocator() vkDestroyValidationCacheEXT_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyValidationCacheEXT_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkMergeValidationCachesEXT_IgnoreAndReturn(cmock_retval) vkMergeValidationCachesEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkMergeValidationCachesEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkMergeValidationCachesEXT_StopIgnore() vkMergeValidationCachesEXT_CMockStopIgnore() +void vkMergeValidationCachesEXT_CMockStopIgnore(void); +#define vkMergeValidationCachesEXT_ExpectAnyArgsAndReturn(cmock_retval) vkMergeValidationCachesEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkMergeValidationCachesEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkMergeValidationCachesEXT_ExpectAndReturn(device, dstCache, srcCacheCount, pSrcCaches, cmock_retval) vkMergeValidationCachesEXT_CMockExpectAndReturn(__LINE__, device, dstCache, srcCacheCount, pSrcCaches, cmock_retval) +void vkMergeValidationCachesEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkMergeValidationCachesEXT_CALLBACK)(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches, int cmock_num_calls); +void vkMergeValidationCachesEXT_AddCallback(CMOCK_vkMergeValidationCachesEXT_CALLBACK Callback); +void vkMergeValidationCachesEXT_Stub(CMOCK_vkMergeValidationCachesEXT_CALLBACK Callback); +#define vkMergeValidationCachesEXT_StubWithCallback vkMergeValidationCachesEXT_AddCallback +#define vkMergeValidationCachesEXT_IgnoreArg_device() vkMergeValidationCachesEXT_CMockIgnoreArg_device(__LINE__) +void vkMergeValidationCachesEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkMergeValidationCachesEXT_IgnoreArg_dstCache() vkMergeValidationCachesEXT_CMockIgnoreArg_dstCache(__LINE__) +void vkMergeValidationCachesEXT_CMockIgnoreArg_dstCache(UNITY_LINE_TYPE cmock_line); +#define vkMergeValidationCachesEXT_IgnoreArg_srcCacheCount() vkMergeValidationCachesEXT_CMockIgnoreArg_srcCacheCount(__LINE__) +void vkMergeValidationCachesEXT_CMockIgnoreArg_srcCacheCount(UNITY_LINE_TYPE cmock_line); +#define vkMergeValidationCachesEXT_IgnoreArg_pSrcCaches() vkMergeValidationCachesEXT_CMockIgnoreArg_pSrcCaches(__LINE__) +void vkMergeValidationCachesEXT_CMockIgnoreArg_pSrcCaches(UNITY_LINE_TYPE cmock_line); +#define vkGetValidationCacheDataEXT_IgnoreAndReturn(cmock_retval) vkGetValidationCacheDataEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetValidationCacheDataEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetValidationCacheDataEXT_StopIgnore() vkGetValidationCacheDataEXT_CMockStopIgnore() +void vkGetValidationCacheDataEXT_CMockStopIgnore(void); +#define vkGetValidationCacheDataEXT_ExpectAnyArgsAndReturn(cmock_retval) vkGetValidationCacheDataEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetValidationCacheDataEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetValidationCacheDataEXT_ExpectAndReturn(device, validationCache, pDataSize, pData, cmock_retval) vkGetValidationCacheDataEXT_CMockExpectAndReturn(__LINE__, device, validationCache, pDataSize, pData, cmock_retval) +void vkGetValidationCacheDataEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetValidationCacheDataEXT_CALLBACK)(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData, int cmock_num_calls); +void vkGetValidationCacheDataEXT_AddCallback(CMOCK_vkGetValidationCacheDataEXT_CALLBACK Callback); +void vkGetValidationCacheDataEXT_Stub(CMOCK_vkGetValidationCacheDataEXT_CALLBACK Callback); +#define vkGetValidationCacheDataEXT_StubWithCallback vkGetValidationCacheDataEXT_AddCallback +#define vkGetValidationCacheDataEXT_ReturnThruPtr_pDataSize(pDataSize) vkGetValidationCacheDataEXT_CMockReturnMemThruPtr_pDataSize(__LINE__, pDataSize, sizeof(size_t)) +#define vkGetValidationCacheDataEXT_ReturnArrayThruPtr_pDataSize(pDataSize, cmock_len) vkGetValidationCacheDataEXT_CMockReturnMemThruPtr_pDataSize(__LINE__, pDataSize, cmock_len * sizeof(*pDataSize)) +#define vkGetValidationCacheDataEXT_ReturnMemThruPtr_pDataSize(pDataSize, cmock_size) vkGetValidationCacheDataEXT_CMockReturnMemThruPtr_pDataSize(__LINE__, pDataSize, cmock_size) +void vkGetValidationCacheDataEXT_CMockReturnMemThruPtr_pDataSize(UNITY_LINE_TYPE cmock_line, size_t const* pDataSize, size_t cmock_size); +#define vkGetValidationCacheDataEXT_ReturnThruPtr_pData(pData) vkGetValidationCacheDataEXT_CMockReturnMemThruPtr_pData(__LINE__, pData, sizeof(*pData)) +#define vkGetValidationCacheDataEXT_ReturnArrayThruPtr_pData(pData, cmock_len) vkGetValidationCacheDataEXT_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_len * sizeof(*pData)) +#define vkGetValidationCacheDataEXT_ReturnMemThruPtr_pData(pData, cmock_size) vkGetValidationCacheDataEXT_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_size) +void vkGetValidationCacheDataEXT_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, void const* pData, size_t cmock_size); +#define vkGetValidationCacheDataEXT_IgnoreArg_device() vkGetValidationCacheDataEXT_CMockIgnoreArg_device(__LINE__) +void vkGetValidationCacheDataEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetValidationCacheDataEXT_IgnoreArg_validationCache() vkGetValidationCacheDataEXT_CMockIgnoreArg_validationCache(__LINE__) +void vkGetValidationCacheDataEXT_CMockIgnoreArg_validationCache(UNITY_LINE_TYPE cmock_line); +#define vkGetValidationCacheDataEXT_IgnoreArg_pDataSize() vkGetValidationCacheDataEXT_CMockIgnoreArg_pDataSize(__LINE__) +void vkGetValidationCacheDataEXT_CMockIgnoreArg_pDataSize(UNITY_LINE_TYPE cmock_line); +#define vkGetValidationCacheDataEXT_IgnoreArg_pData() vkGetValidationCacheDataEXT_CMockIgnoreArg_pData(__LINE__) +void vkGetValidationCacheDataEXT_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindShadingRateImageNV_Ignore() vkCmdBindShadingRateImageNV_CMockIgnore() +void vkCmdBindShadingRateImageNV_CMockIgnore(void); +#define vkCmdBindShadingRateImageNV_StopIgnore() vkCmdBindShadingRateImageNV_CMockStopIgnore() +void vkCmdBindShadingRateImageNV_CMockStopIgnore(void); +#define vkCmdBindShadingRateImageNV_ExpectAnyArgs() vkCmdBindShadingRateImageNV_CMockExpectAnyArgs(__LINE__) +void vkCmdBindShadingRateImageNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindShadingRateImageNV_Expect(commandBuffer, imageView, imageLayout) vkCmdBindShadingRateImageNV_CMockExpect(__LINE__, commandBuffer, imageView, imageLayout) +void vkCmdBindShadingRateImageNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout); +typedef void (* CMOCK_vkCmdBindShadingRateImageNV_CALLBACK)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout, int cmock_num_calls); +void vkCmdBindShadingRateImageNV_AddCallback(CMOCK_vkCmdBindShadingRateImageNV_CALLBACK Callback); +void vkCmdBindShadingRateImageNV_Stub(CMOCK_vkCmdBindShadingRateImageNV_CALLBACK Callback); +#define vkCmdBindShadingRateImageNV_StubWithCallback vkCmdBindShadingRateImageNV_AddCallback +#define vkCmdBindShadingRateImageNV_IgnoreArg_commandBuffer() vkCmdBindShadingRateImageNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBindShadingRateImageNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindShadingRateImageNV_IgnoreArg_imageView() vkCmdBindShadingRateImageNV_CMockIgnoreArg_imageView(__LINE__) +void vkCmdBindShadingRateImageNV_CMockIgnoreArg_imageView(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindShadingRateImageNV_IgnoreArg_imageLayout() vkCmdBindShadingRateImageNV_CMockIgnoreArg_imageLayout(__LINE__) +void vkCmdBindShadingRateImageNV_CMockIgnoreArg_imageLayout(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewportShadingRatePaletteNV_Ignore() vkCmdSetViewportShadingRatePaletteNV_CMockIgnore() +void vkCmdSetViewportShadingRatePaletteNV_CMockIgnore(void); +#define vkCmdSetViewportShadingRatePaletteNV_StopIgnore() vkCmdSetViewportShadingRatePaletteNV_CMockStopIgnore() +void vkCmdSetViewportShadingRatePaletteNV_CMockStopIgnore(void); +#define vkCmdSetViewportShadingRatePaletteNV_ExpectAnyArgs() vkCmdSetViewportShadingRatePaletteNV_CMockExpectAnyArgs(__LINE__) +void vkCmdSetViewportShadingRatePaletteNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewportShadingRatePaletteNV_Expect(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes) vkCmdSetViewportShadingRatePaletteNV_CMockExpect(__LINE__, commandBuffer, firstViewport, viewportCount, pShadingRatePalettes) +void vkCmdSetViewportShadingRatePaletteNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes); +typedef void (* CMOCK_vkCmdSetViewportShadingRatePaletteNV_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes, int cmock_num_calls); +void vkCmdSetViewportShadingRatePaletteNV_AddCallback(CMOCK_vkCmdSetViewportShadingRatePaletteNV_CALLBACK Callback); +void vkCmdSetViewportShadingRatePaletteNV_Stub(CMOCK_vkCmdSetViewportShadingRatePaletteNV_CALLBACK Callback); +#define vkCmdSetViewportShadingRatePaletteNV_StubWithCallback vkCmdSetViewportShadingRatePaletteNV_AddCallback +#define vkCmdSetViewportShadingRatePaletteNV_IgnoreArg_commandBuffer() vkCmdSetViewportShadingRatePaletteNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetViewportShadingRatePaletteNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewportShadingRatePaletteNV_IgnoreArg_firstViewport() vkCmdSetViewportShadingRatePaletteNV_CMockIgnoreArg_firstViewport(__LINE__) +void vkCmdSetViewportShadingRatePaletteNV_CMockIgnoreArg_firstViewport(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewportShadingRatePaletteNV_IgnoreArg_viewportCount() vkCmdSetViewportShadingRatePaletteNV_CMockIgnoreArg_viewportCount(__LINE__) +void vkCmdSetViewportShadingRatePaletteNV_CMockIgnoreArg_viewportCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewportShadingRatePaletteNV_IgnoreArg_pShadingRatePalettes() vkCmdSetViewportShadingRatePaletteNV_CMockIgnoreArg_pShadingRatePalettes(__LINE__) +void vkCmdSetViewportShadingRatePaletteNV_CMockIgnoreArg_pShadingRatePalettes(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCoarseSampleOrderNV_Ignore() vkCmdSetCoarseSampleOrderNV_CMockIgnore() +void vkCmdSetCoarseSampleOrderNV_CMockIgnore(void); +#define vkCmdSetCoarseSampleOrderNV_StopIgnore() vkCmdSetCoarseSampleOrderNV_CMockStopIgnore() +void vkCmdSetCoarseSampleOrderNV_CMockStopIgnore(void); +#define vkCmdSetCoarseSampleOrderNV_ExpectAnyArgs() vkCmdSetCoarseSampleOrderNV_CMockExpectAnyArgs(__LINE__) +void vkCmdSetCoarseSampleOrderNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCoarseSampleOrderNV_Expect(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders) vkCmdSetCoarseSampleOrderNV_CMockExpect(__LINE__, commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders) +void vkCmdSetCoarseSampleOrderNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders); +typedef void (* CMOCK_vkCmdSetCoarseSampleOrderNV_CALLBACK)(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders, int cmock_num_calls); +void vkCmdSetCoarseSampleOrderNV_AddCallback(CMOCK_vkCmdSetCoarseSampleOrderNV_CALLBACK Callback); +void vkCmdSetCoarseSampleOrderNV_Stub(CMOCK_vkCmdSetCoarseSampleOrderNV_CALLBACK Callback); +#define vkCmdSetCoarseSampleOrderNV_StubWithCallback vkCmdSetCoarseSampleOrderNV_AddCallback +#define vkCmdSetCoarseSampleOrderNV_IgnoreArg_commandBuffer() vkCmdSetCoarseSampleOrderNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetCoarseSampleOrderNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCoarseSampleOrderNV_IgnoreArg_sampleOrderType() vkCmdSetCoarseSampleOrderNV_CMockIgnoreArg_sampleOrderType(__LINE__) +void vkCmdSetCoarseSampleOrderNV_CMockIgnoreArg_sampleOrderType(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCoarseSampleOrderNV_IgnoreArg_customSampleOrderCount() vkCmdSetCoarseSampleOrderNV_CMockIgnoreArg_customSampleOrderCount(__LINE__) +void vkCmdSetCoarseSampleOrderNV_CMockIgnoreArg_customSampleOrderCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCoarseSampleOrderNV_IgnoreArg_pCustomSampleOrders() vkCmdSetCoarseSampleOrderNV_CMockIgnoreArg_pCustomSampleOrders(__LINE__) +void vkCmdSetCoarseSampleOrderNV_CMockIgnoreArg_pCustomSampleOrders(UNITY_LINE_TYPE cmock_line); +#define vkCreateAccelerationStructureNV_IgnoreAndReturn(cmock_retval) vkCreateAccelerationStructureNV_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateAccelerationStructureNV_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateAccelerationStructureNV_StopIgnore() vkCreateAccelerationStructureNV_CMockStopIgnore() +void vkCreateAccelerationStructureNV_CMockStopIgnore(void); +#define vkCreateAccelerationStructureNV_ExpectAnyArgsAndReturn(cmock_retval) vkCreateAccelerationStructureNV_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateAccelerationStructureNV_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateAccelerationStructureNV_ExpectAndReturn(device, pCreateInfo, pAllocator, pAccelerationStructure, cmock_retval) vkCreateAccelerationStructureNV_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pAccelerationStructure, cmock_retval) +void vkCreateAccelerationStructureNV_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateAccelerationStructureNV_CALLBACK)(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure, int cmock_num_calls); +void vkCreateAccelerationStructureNV_AddCallback(CMOCK_vkCreateAccelerationStructureNV_CALLBACK Callback); +void vkCreateAccelerationStructureNV_Stub(CMOCK_vkCreateAccelerationStructureNV_CALLBACK Callback); +#define vkCreateAccelerationStructureNV_StubWithCallback vkCreateAccelerationStructureNV_AddCallback +#define vkCreateAccelerationStructureNV_ReturnThruPtr_pAccelerationStructure(pAccelerationStructure) vkCreateAccelerationStructureNV_CMockReturnMemThruPtr_pAccelerationStructure(__LINE__, pAccelerationStructure, sizeof(VkAccelerationStructureNV)) +#define vkCreateAccelerationStructureNV_ReturnArrayThruPtr_pAccelerationStructure(pAccelerationStructure, cmock_len) vkCreateAccelerationStructureNV_CMockReturnMemThruPtr_pAccelerationStructure(__LINE__, pAccelerationStructure, cmock_len * sizeof(*pAccelerationStructure)) +#define vkCreateAccelerationStructureNV_ReturnMemThruPtr_pAccelerationStructure(pAccelerationStructure, cmock_size) vkCreateAccelerationStructureNV_CMockReturnMemThruPtr_pAccelerationStructure(__LINE__, pAccelerationStructure, cmock_size) +void vkCreateAccelerationStructureNV_CMockReturnMemThruPtr_pAccelerationStructure(UNITY_LINE_TYPE cmock_line, VkAccelerationStructureNV const* pAccelerationStructure, size_t cmock_size); +#define vkCreateAccelerationStructureNV_IgnoreArg_device() vkCreateAccelerationStructureNV_CMockIgnoreArg_device(__LINE__) +void vkCreateAccelerationStructureNV_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateAccelerationStructureNV_IgnoreArg_pCreateInfo() vkCreateAccelerationStructureNV_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateAccelerationStructureNV_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateAccelerationStructureNV_IgnoreArg_pAllocator() vkCreateAccelerationStructureNV_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateAccelerationStructureNV_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateAccelerationStructureNV_IgnoreArg_pAccelerationStructure() vkCreateAccelerationStructureNV_CMockIgnoreArg_pAccelerationStructure(__LINE__) +void vkCreateAccelerationStructureNV_CMockIgnoreArg_pAccelerationStructure(UNITY_LINE_TYPE cmock_line); +#define vkDestroyAccelerationStructureNV_Ignore() vkDestroyAccelerationStructureNV_CMockIgnore() +void vkDestroyAccelerationStructureNV_CMockIgnore(void); +#define vkDestroyAccelerationStructureNV_StopIgnore() vkDestroyAccelerationStructureNV_CMockStopIgnore() +void vkDestroyAccelerationStructureNV_CMockStopIgnore(void); +#define vkDestroyAccelerationStructureNV_ExpectAnyArgs() vkDestroyAccelerationStructureNV_CMockExpectAnyArgs(__LINE__) +void vkDestroyAccelerationStructureNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyAccelerationStructureNV_Expect(device, accelerationStructure, pAllocator) vkDestroyAccelerationStructureNV_CMockExpect(__LINE__, device, accelerationStructure, pAllocator) +void vkDestroyAccelerationStructureNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyAccelerationStructureNV_CALLBACK)(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyAccelerationStructureNV_AddCallback(CMOCK_vkDestroyAccelerationStructureNV_CALLBACK Callback); +void vkDestroyAccelerationStructureNV_Stub(CMOCK_vkDestroyAccelerationStructureNV_CALLBACK Callback); +#define vkDestroyAccelerationStructureNV_StubWithCallback vkDestroyAccelerationStructureNV_AddCallback +#define vkDestroyAccelerationStructureNV_IgnoreArg_device() vkDestroyAccelerationStructureNV_CMockIgnoreArg_device(__LINE__) +void vkDestroyAccelerationStructureNV_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyAccelerationStructureNV_IgnoreArg_accelerationStructure() vkDestroyAccelerationStructureNV_CMockIgnoreArg_accelerationStructure(__LINE__) +void vkDestroyAccelerationStructureNV_CMockIgnoreArg_accelerationStructure(UNITY_LINE_TYPE cmock_line); +#define vkDestroyAccelerationStructureNV_IgnoreArg_pAllocator() vkDestroyAccelerationStructureNV_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyAccelerationStructureNV_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkGetAccelerationStructureMemoryRequirementsNV_Ignore() vkGetAccelerationStructureMemoryRequirementsNV_CMockIgnore() +void vkGetAccelerationStructureMemoryRequirementsNV_CMockIgnore(void); +#define vkGetAccelerationStructureMemoryRequirementsNV_StopIgnore() vkGetAccelerationStructureMemoryRequirementsNV_CMockStopIgnore() +void vkGetAccelerationStructureMemoryRequirementsNV_CMockStopIgnore(void); +#define vkGetAccelerationStructureMemoryRequirementsNV_ExpectAnyArgs() vkGetAccelerationStructureMemoryRequirementsNV_CMockExpectAnyArgs(__LINE__) +void vkGetAccelerationStructureMemoryRequirementsNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetAccelerationStructureMemoryRequirementsNV_Expect(device, pInfo, pMemoryRequirements) vkGetAccelerationStructureMemoryRequirementsNV_CMockExpect(__LINE__, device, pInfo, pMemoryRequirements) +void vkGetAccelerationStructureMemoryRequirementsNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements); +typedef void (* CMOCK_vkGetAccelerationStructureMemoryRequirementsNV_CALLBACK)(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements, int cmock_num_calls); +void vkGetAccelerationStructureMemoryRequirementsNV_AddCallback(CMOCK_vkGetAccelerationStructureMemoryRequirementsNV_CALLBACK Callback); +void vkGetAccelerationStructureMemoryRequirementsNV_Stub(CMOCK_vkGetAccelerationStructureMemoryRequirementsNV_CALLBACK Callback); +#define vkGetAccelerationStructureMemoryRequirementsNV_StubWithCallback vkGetAccelerationStructureMemoryRequirementsNV_AddCallback +#define vkGetAccelerationStructureMemoryRequirementsNV_ReturnThruPtr_pMemoryRequirements(pMemoryRequirements) vkGetAccelerationStructureMemoryRequirementsNV_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, sizeof(VkMemoryRequirements2KHR)) +#define vkGetAccelerationStructureMemoryRequirementsNV_ReturnArrayThruPtr_pMemoryRequirements(pMemoryRequirements, cmock_len) vkGetAccelerationStructureMemoryRequirementsNV_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, cmock_len * sizeof(*pMemoryRequirements)) +#define vkGetAccelerationStructureMemoryRequirementsNV_ReturnMemThruPtr_pMemoryRequirements(pMemoryRequirements, cmock_size) vkGetAccelerationStructureMemoryRequirementsNV_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, cmock_size) +void vkGetAccelerationStructureMemoryRequirementsNV_CMockReturnMemThruPtr_pMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkMemoryRequirements2KHR const* pMemoryRequirements, size_t cmock_size); +#define vkGetAccelerationStructureMemoryRequirementsNV_IgnoreArg_device() vkGetAccelerationStructureMemoryRequirementsNV_CMockIgnoreArg_device(__LINE__) +void vkGetAccelerationStructureMemoryRequirementsNV_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetAccelerationStructureMemoryRequirementsNV_IgnoreArg_pInfo() vkGetAccelerationStructureMemoryRequirementsNV_CMockIgnoreArg_pInfo(__LINE__) +void vkGetAccelerationStructureMemoryRequirementsNV_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetAccelerationStructureMemoryRequirementsNV_IgnoreArg_pMemoryRequirements() vkGetAccelerationStructureMemoryRequirementsNV_CMockIgnoreArg_pMemoryRequirements(__LINE__) +void vkGetAccelerationStructureMemoryRequirementsNV_CMockIgnoreArg_pMemoryRequirements(UNITY_LINE_TYPE cmock_line); +#define vkBindAccelerationStructureMemoryNV_IgnoreAndReturn(cmock_retval) vkBindAccelerationStructureMemoryNV_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkBindAccelerationStructureMemoryNV_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkBindAccelerationStructureMemoryNV_StopIgnore() vkBindAccelerationStructureMemoryNV_CMockStopIgnore() +void vkBindAccelerationStructureMemoryNV_CMockStopIgnore(void); +#define vkBindAccelerationStructureMemoryNV_ExpectAnyArgsAndReturn(cmock_retval) vkBindAccelerationStructureMemoryNV_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkBindAccelerationStructureMemoryNV_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkBindAccelerationStructureMemoryNV_ExpectAndReturn(device, bindInfoCount, pBindInfos, cmock_retval) vkBindAccelerationStructureMemoryNV_CMockExpectAndReturn(__LINE__, device, bindInfoCount, pBindInfos, cmock_retval) +void vkBindAccelerationStructureMemoryNV_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkBindAccelerationStructureMemoryNV_CALLBACK)(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos, int cmock_num_calls); +void vkBindAccelerationStructureMemoryNV_AddCallback(CMOCK_vkBindAccelerationStructureMemoryNV_CALLBACK Callback); +void vkBindAccelerationStructureMemoryNV_Stub(CMOCK_vkBindAccelerationStructureMemoryNV_CALLBACK Callback); +#define vkBindAccelerationStructureMemoryNV_StubWithCallback vkBindAccelerationStructureMemoryNV_AddCallback +#define vkBindAccelerationStructureMemoryNV_IgnoreArg_device() vkBindAccelerationStructureMemoryNV_CMockIgnoreArg_device(__LINE__) +void vkBindAccelerationStructureMemoryNV_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkBindAccelerationStructureMemoryNV_IgnoreArg_bindInfoCount() vkBindAccelerationStructureMemoryNV_CMockIgnoreArg_bindInfoCount(__LINE__) +void vkBindAccelerationStructureMemoryNV_CMockIgnoreArg_bindInfoCount(UNITY_LINE_TYPE cmock_line); +#define vkBindAccelerationStructureMemoryNV_IgnoreArg_pBindInfos() vkBindAccelerationStructureMemoryNV_CMockIgnoreArg_pBindInfos(__LINE__) +void vkBindAccelerationStructureMemoryNV_CMockIgnoreArg_pBindInfos(UNITY_LINE_TYPE cmock_line); +#define vkCmdBuildAccelerationStructureNV_Ignore() vkCmdBuildAccelerationStructureNV_CMockIgnore() +void vkCmdBuildAccelerationStructureNV_CMockIgnore(void); +#define vkCmdBuildAccelerationStructureNV_StopIgnore() vkCmdBuildAccelerationStructureNV_CMockStopIgnore() +void vkCmdBuildAccelerationStructureNV_CMockStopIgnore(void); +#define vkCmdBuildAccelerationStructureNV_ExpectAnyArgs() vkCmdBuildAccelerationStructureNV_CMockExpectAnyArgs(__LINE__) +void vkCmdBuildAccelerationStructureNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBuildAccelerationStructureNV_Expect(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset) vkCmdBuildAccelerationStructureNV_CMockExpect(__LINE__, commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset) +void vkCmdBuildAccelerationStructureNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset); +typedef void (* CMOCK_vkCmdBuildAccelerationStructureNV_CALLBACK)(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset, int cmock_num_calls); +void vkCmdBuildAccelerationStructureNV_AddCallback(CMOCK_vkCmdBuildAccelerationStructureNV_CALLBACK Callback); +void vkCmdBuildAccelerationStructureNV_Stub(CMOCK_vkCmdBuildAccelerationStructureNV_CALLBACK Callback); +#define vkCmdBuildAccelerationStructureNV_StubWithCallback vkCmdBuildAccelerationStructureNV_AddCallback +#define vkCmdBuildAccelerationStructureNV_IgnoreArg_commandBuffer() vkCmdBuildAccelerationStructureNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBuildAccelerationStructureNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBuildAccelerationStructureNV_IgnoreArg_pInfo() vkCmdBuildAccelerationStructureNV_CMockIgnoreArg_pInfo(__LINE__) +void vkCmdBuildAccelerationStructureNV_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdBuildAccelerationStructureNV_IgnoreArg_instanceData() vkCmdBuildAccelerationStructureNV_CMockIgnoreArg_instanceData(__LINE__) +void vkCmdBuildAccelerationStructureNV_CMockIgnoreArg_instanceData(UNITY_LINE_TYPE cmock_line); +#define vkCmdBuildAccelerationStructureNV_IgnoreArg_instanceOffset() vkCmdBuildAccelerationStructureNV_CMockIgnoreArg_instanceOffset(__LINE__) +void vkCmdBuildAccelerationStructureNV_CMockIgnoreArg_instanceOffset(UNITY_LINE_TYPE cmock_line); +#define vkCmdBuildAccelerationStructureNV_IgnoreArg_update() vkCmdBuildAccelerationStructureNV_CMockIgnoreArg_update(__LINE__) +void vkCmdBuildAccelerationStructureNV_CMockIgnoreArg_update(UNITY_LINE_TYPE cmock_line); +#define vkCmdBuildAccelerationStructureNV_IgnoreArg_dst() vkCmdBuildAccelerationStructureNV_CMockIgnoreArg_dst(__LINE__) +void vkCmdBuildAccelerationStructureNV_CMockIgnoreArg_dst(UNITY_LINE_TYPE cmock_line); +#define vkCmdBuildAccelerationStructureNV_IgnoreArg_src() vkCmdBuildAccelerationStructureNV_CMockIgnoreArg_src(__LINE__) +void vkCmdBuildAccelerationStructureNV_CMockIgnoreArg_src(UNITY_LINE_TYPE cmock_line); +#define vkCmdBuildAccelerationStructureNV_IgnoreArg_scratch() vkCmdBuildAccelerationStructureNV_CMockIgnoreArg_scratch(__LINE__) +void vkCmdBuildAccelerationStructureNV_CMockIgnoreArg_scratch(UNITY_LINE_TYPE cmock_line); +#define vkCmdBuildAccelerationStructureNV_IgnoreArg_scratchOffset() vkCmdBuildAccelerationStructureNV_CMockIgnoreArg_scratchOffset(__LINE__) +void vkCmdBuildAccelerationStructureNV_CMockIgnoreArg_scratchOffset(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyAccelerationStructureNV_Ignore() vkCmdCopyAccelerationStructureNV_CMockIgnore() +void vkCmdCopyAccelerationStructureNV_CMockIgnore(void); +#define vkCmdCopyAccelerationStructureNV_StopIgnore() vkCmdCopyAccelerationStructureNV_CMockStopIgnore() +void vkCmdCopyAccelerationStructureNV_CMockStopIgnore(void); +#define vkCmdCopyAccelerationStructureNV_ExpectAnyArgs() vkCmdCopyAccelerationStructureNV_CMockExpectAnyArgs(__LINE__) +void vkCmdCopyAccelerationStructureNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyAccelerationStructureNV_Expect(commandBuffer, dst, src, mode) vkCmdCopyAccelerationStructureNV_CMockExpect(__LINE__, commandBuffer, dst, src, mode) +void vkCmdCopyAccelerationStructureNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode); +typedef void (* CMOCK_vkCmdCopyAccelerationStructureNV_CALLBACK)(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode, int cmock_num_calls); +void vkCmdCopyAccelerationStructureNV_AddCallback(CMOCK_vkCmdCopyAccelerationStructureNV_CALLBACK Callback); +void vkCmdCopyAccelerationStructureNV_Stub(CMOCK_vkCmdCopyAccelerationStructureNV_CALLBACK Callback); +#define vkCmdCopyAccelerationStructureNV_StubWithCallback vkCmdCopyAccelerationStructureNV_AddCallback +#define vkCmdCopyAccelerationStructureNV_IgnoreArg_commandBuffer() vkCmdCopyAccelerationStructureNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdCopyAccelerationStructureNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyAccelerationStructureNV_IgnoreArg_dst() vkCmdCopyAccelerationStructureNV_CMockIgnoreArg_dst(__LINE__) +void vkCmdCopyAccelerationStructureNV_CMockIgnoreArg_dst(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyAccelerationStructureNV_IgnoreArg_src() vkCmdCopyAccelerationStructureNV_CMockIgnoreArg_src(__LINE__) +void vkCmdCopyAccelerationStructureNV_CMockIgnoreArg_src(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyAccelerationStructureNV_IgnoreArg_mode() vkCmdCopyAccelerationStructureNV_CMockIgnoreArg_mode(__LINE__) +void vkCmdCopyAccelerationStructureNV_CMockIgnoreArg_mode(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysNV_Ignore() vkCmdTraceRaysNV_CMockIgnore() +void vkCmdTraceRaysNV_CMockIgnore(void); +#define vkCmdTraceRaysNV_StopIgnore() vkCmdTraceRaysNV_CMockStopIgnore() +void vkCmdTraceRaysNV_CMockStopIgnore(void); +#define vkCmdTraceRaysNV_ExpectAnyArgs() vkCmdTraceRaysNV_CMockExpectAnyArgs(__LINE__) +void vkCmdTraceRaysNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysNV_Expect(commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth) vkCmdTraceRaysNV_CMockExpect(__LINE__, commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth) +void vkCmdTraceRaysNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth); +typedef void (* CMOCK_vkCmdTraceRaysNV_CALLBACK)(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth, int cmock_num_calls); +void vkCmdTraceRaysNV_AddCallback(CMOCK_vkCmdTraceRaysNV_CALLBACK Callback); +void vkCmdTraceRaysNV_Stub(CMOCK_vkCmdTraceRaysNV_CALLBACK Callback); +#define vkCmdTraceRaysNV_StubWithCallback vkCmdTraceRaysNV_AddCallback +#define vkCmdTraceRaysNV_IgnoreArg_commandBuffer() vkCmdTraceRaysNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdTraceRaysNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysNV_IgnoreArg_raygenShaderBindingTableBuffer() vkCmdTraceRaysNV_CMockIgnoreArg_raygenShaderBindingTableBuffer(__LINE__) +void vkCmdTraceRaysNV_CMockIgnoreArg_raygenShaderBindingTableBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysNV_IgnoreArg_raygenShaderBindingOffset() vkCmdTraceRaysNV_CMockIgnoreArg_raygenShaderBindingOffset(__LINE__) +void vkCmdTraceRaysNV_CMockIgnoreArg_raygenShaderBindingOffset(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysNV_IgnoreArg_missShaderBindingTableBuffer() vkCmdTraceRaysNV_CMockIgnoreArg_missShaderBindingTableBuffer(__LINE__) +void vkCmdTraceRaysNV_CMockIgnoreArg_missShaderBindingTableBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysNV_IgnoreArg_missShaderBindingOffset() vkCmdTraceRaysNV_CMockIgnoreArg_missShaderBindingOffset(__LINE__) +void vkCmdTraceRaysNV_CMockIgnoreArg_missShaderBindingOffset(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysNV_IgnoreArg_missShaderBindingStride() vkCmdTraceRaysNV_CMockIgnoreArg_missShaderBindingStride(__LINE__) +void vkCmdTraceRaysNV_CMockIgnoreArg_missShaderBindingStride(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysNV_IgnoreArg_hitShaderBindingTableBuffer() vkCmdTraceRaysNV_CMockIgnoreArg_hitShaderBindingTableBuffer(__LINE__) +void vkCmdTraceRaysNV_CMockIgnoreArg_hitShaderBindingTableBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysNV_IgnoreArg_hitShaderBindingOffset() vkCmdTraceRaysNV_CMockIgnoreArg_hitShaderBindingOffset(__LINE__) +void vkCmdTraceRaysNV_CMockIgnoreArg_hitShaderBindingOffset(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysNV_IgnoreArg_hitShaderBindingStride() vkCmdTraceRaysNV_CMockIgnoreArg_hitShaderBindingStride(__LINE__) +void vkCmdTraceRaysNV_CMockIgnoreArg_hitShaderBindingStride(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysNV_IgnoreArg_callableShaderBindingTableBuffer() vkCmdTraceRaysNV_CMockIgnoreArg_callableShaderBindingTableBuffer(__LINE__) +void vkCmdTraceRaysNV_CMockIgnoreArg_callableShaderBindingTableBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysNV_IgnoreArg_callableShaderBindingOffset() vkCmdTraceRaysNV_CMockIgnoreArg_callableShaderBindingOffset(__LINE__) +void vkCmdTraceRaysNV_CMockIgnoreArg_callableShaderBindingOffset(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysNV_IgnoreArg_callableShaderBindingStride() vkCmdTraceRaysNV_CMockIgnoreArg_callableShaderBindingStride(__LINE__) +void vkCmdTraceRaysNV_CMockIgnoreArg_callableShaderBindingStride(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysNV_IgnoreArg_width() vkCmdTraceRaysNV_CMockIgnoreArg_width(__LINE__) +void vkCmdTraceRaysNV_CMockIgnoreArg_width(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysNV_IgnoreArg_height() vkCmdTraceRaysNV_CMockIgnoreArg_height(__LINE__) +void vkCmdTraceRaysNV_CMockIgnoreArg_height(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysNV_IgnoreArg_depth() vkCmdTraceRaysNV_CMockIgnoreArg_depth(__LINE__) +void vkCmdTraceRaysNV_CMockIgnoreArg_depth(UNITY_LINE_TYPE cmock_line); +#define vkCreateRayTracingPipelinesNV_IgnoreAndReturn(cmock_retval) vkCreateRayTracingPipelinesNV_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateRayTracingPipelinesNV_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateRayTracingPipelinesNV_StopIgnore() vkCreateRayTracingPipelinesNV_CMockStopIgnore() +void vkCreateRayTracingPipelinesNV_CMockStopIgnore(void); +#define vkCreateRayTracingPipelinesNV_ExpectAnyArgsAndReturn(cmock_retval) vkCreateRayTracingPipelinesNV_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateRayTracingPipelinesNV_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateRayTracingPipelinesNV_ExpectAndReturn(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, cmock_retval) vkCreateRayTracingPipelinesNV_CMockExpectAndReturn(__LINE__, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, cmock_retval) +void vkCreateRayTracingPipelinesNV_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateRayTracingPipelinesNV_CALLBACK)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, int cmock_num_calls); +void vkCreateRayTracingPipelinesNV_AddCallback(CMOCK_vkCreateRayTracingPipelinesNV_CALLBACK Callback); +void vkCreateRayTracingPipelinesNV_Stub(CMOCK_vkCreateRayTracingPipelinesNV_CALLBACK Callback); +#define vkCreateRayTracingPipelinesNV_StubWithCallback vkCreateRayTracingPipelinesNV_AddCallback +#define vkCreateRayTracingPipelinesNV_ReturnThruPtr_pPipelines(pPipelines) vkCreateRayTracingPipelinesNV_CMockReturnMemThruPtr_pPipelines(__LINE__, pPipelines, sizeof(VkPipeline)) +#define vkCreateRayTracingPipelinesNV_ReturnArrayThruPtr_pPipelines(pPipelines, cmock_len) vkCreateRayTracingPipelinesNV_CMockReturnMemThruPtr_pPipelines(__LINE__, pPipelines, cmock_len * sizeof(*pPipelines)) +#define vkCreateRayTracingPipelinesNV_ReturnMemThruPtr_pPipelines(pPipelines, cmock_size) vkCreateRayTracingPipelinesNV_CMockReturnMemThruPtr_pPipelines(__LINE__, pPipelines, cmock_size) +void vkCreateRayTracingPipelinesNV_CMockReturnMemThruPtr_pPipelines(UNITY_LINE_TYPE cmock_line, VkPipeline const* pPipelines, size_t cmock_size); +#define vkCreateRayTracingPipelinesNV_IgnoreArg_device() vkCreateRayTracingPipelinesNV_CMockIgnoreArg_device(__LINE__) +void vkCreateRayTracingPipelinesNV_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateRayTracingPipelinesNV_IgnoreArg_pipelineCache() vkCreateRayTracingPipelinesNV_CMockIgnoreArg_pipelineCache(__LINE__) +void vkCreateRayTracingPipelinesNV_CMockIgnoreArg_pipelineCache(UNITY_LINE_TYPE cmock_line); +#define vkCreateRayTracingPipelinesNV_IgnoreArg_createInfoCount() vkCreateRayTracingPipelinesNV_CMockIgnoreArg_createInfoCount(__LINE__) +void vkCreateRayTracingPipelinesNV_CMockIgnoreArg_createInfoCount(UNITY_LINE_TYPE cmock_line); +#define vkCreateRayTracingPipelinesNV_IgnoreArg_pCreateInfos() vkCreateRayTracingPipelinesNV_CMockIgnoreArg_pCreateInfos(__LINE__) +void vkCreateRayTracingPipelinesNV_CMockIgnoreArg_pCreateInfos(UNITY_LINE_TYPE cmock_line); +#define vkCreateRayTracingPipelinesNV_IgnoreArg_pAllocator() vkCreateRayTracingPipelinesNV_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateRayTracingPipelinesNV_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateRayTracingPipelinesNV_IgnoreArg_pPipelines() vkCreateRayTracingPipelinesNV_CMockIgnoreArg_pPipelines(__LINE__) +void vkCreateRayTracingPipelinesNV_CMockIgnoreArg_pPipelines(UNITY_LINE_TYPE cmock_line); +#define vkGetRayTracingShaderGroupHandlesKHR_IgnoreAndReturn(cmock_retval) vkGetRayTracingShaderGroupHandlesKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetRayTracingShaderGroupHandlesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetRayTracingShaderGroupHandlesKHR_StopIgnore() vkGetRayTracingShaderGroupHandlesKHR_CMockStopIgnore() +void vkGetRayTracingShaderGroupHandlesKHR_CMockStopIgnore(void); +#define vkGetRayTracingShaderGroupHandlesKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetRayTracingShaderGroupHandlesKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetRayTracingShaderGroupHandlesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetRayTracingShaderGroupHandlesKHR_ExpectAndReturn(device, pipeline, firstGroup, groupCount, dataSize, pData, cmock_retval) vkGetRayTracingShaderGroupHandlesKHR_CMockExpectAndReturn(__LINE__, device, pipeline, firstGroup, groupCount, dataSize, pData, cmock_retval) +void vkGetRayTracingShaderGroupHandlesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALLBACK)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, int cmock_num_calls); +void vkGetRayTracingShaderGroupHandlesKHR_AddCallback(CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALLBACK Callback); +void vkGetRayTracingShaderGroupHandlesKHR_Stub(CMOCK_vkGetRayTracingShaderGroupHandlesKHR_CALLBACK Callback); +#define vkGetRayTracingShaderGroupHandlesKHR_StubWithCallback vkGetRayTracingShaderGroupHandlesKHR_AddCallback +#define vkGetRayTracingShaderGroupHandlesKHR_ReturnThruPtr_pData(pData) vkGetRayTracingShaderGroupHandlesKHR_CMockReturnMemThruPtr_pData(__LINE__, pData, sizeof(*pData)) +#define vkGetRayTracingShaderGroupHandlesKHR_ReturnArrayThruPtr_pData(pData, cmock_len) vkGetRayTracingShaderGroupHandlesKHR_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_len * sizeof(*pData)) +#define vkGetRayTracingShaderGroupHandlesKHR_ReturnMemThruPtr_pData(pData, cmock_size) vkGetRayTracingShaderGroupHandlesKHR_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_size) +void vkGetRayTracingShaderGroupHandlesKHR_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, void const* pData, size_t cmock_size); +#define vkGetRayTracingShaderGroupHandlesKHR_IgnoreArg_device() vkGetRayTracingShaderGroupHandlesKHR_CMockIgnoreArg_device(__LINE__) +void vkGetRayTracingShaderGroupHandlesKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetRayTracingShaderGroupHandlesKHR_IgnoreArg_pipeline() vkGetRayTracingShaderGroupHandlesKHR_CMockIgnoreArg_pipeline(__LINE__) +void vkGetRayTracingShaderGroupHandlesKHR_CMockIgnoreArg_pipeline(UNITY_LINE_TYPE cmock_line); +#define vkGetRayTracingShaderGroupHandlesKHR_IgnoreArg_firstGroup() vkGetRayTracingShaderGroupHandlesKHR_CMockIgnoreArg_firstGroup(__LINE__) +void vkGetRayTracingShaderGroupHandlesKHR_CMockIgnoreArg_firstGroup(UNITY_LINE_TYPE cmock_line); +#define vkGetRayTracingShaderGroupHandlesKHR_IgnoreArg_groupCount() vkGetRayTracingShaderGroupHandlesKHR_CMockIgnoreArg_groupCount(__LINE__) +void vkGetRayTracingShaderGroupHandlesKHR_CMockIgnoreArg_groupCount(UNITY_LINE_TYPE cmock_line); +#define vkGetRayTracingShaderGroupHandlesKHR_IgnoreArg_dataSize() vkGetRayTracingShaderGroupHandlesKHR_CMockIgnoreArg_dataSize(__LINE__) +void vkGetRayTracingShaderGroupHandlesKHR_CMockIgnoreArg_dataSize(UNITY_LINE_TYPE cmock_line); +#define vkGetRayTracingShaderGroupHandlesKHR_IgnoreArg_pData() vkGetRayTracingShaderGroupHandlesKHR_CMockIgnoreArg_pData(__LINE__) +void vkGetRayTracingShaderGroupHandlesKHR_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line); +#define vkGetRayTracingShaderGroupHandlesNV_IgnoreAndReturn(cmock_retval) vkGetRayTracingShaderGroupHandlesNV_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetRayTracingShaderGroupHandlesNV_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetRayTracingShaderGroupHandlesNV_StopIgnore() vkGetRayTracingShaderGroupHandlesNV_CMockStopIgnore() +void vkGetRayTracingShaderGroupHandlesNV_CMockStopIgnore(void); +#define vkGetRayTracingShaderGroupHandlesNV_ExpectAnyArgsAndReturn(cmock_retval) vkGetRayTracingShaderGroupHandlesNV_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetRayTracingShaderGroupHandlesNV_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetRayTracingShaderGroupHandlesNV_ExpectAndReturn(device, pipeline, firstGroup, groupCount, dataSize, pData, cmock_retval) vkGetRayTracingShaderGroupHandlesNV_CMockExpectAndReturn(__LINE__, device, pipeline, firstGroup, groupCount, dataSize, pData, cmock_retval) +void vkGetRayTracingShaderGroupHandlesNV_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALLBACK)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, int cmock_num_calls); +void vkGetRayTracingShaderGroupHandlesNV_AddCallback(CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALLBACK Callback); +void vkGetRayTracingShaderGroupHandlesNV_Stub(CMOCK_vkGetRayTracingShaderGroupHandlesNV_CALLBACK Callback); +#define vkGetRayTracingShaderGroupHandlesNV_StubWithCallback vkGetRayTracingShaderGroupHandlesNV_AddCallback +#define vkGetRayTracingShaderGroupHandlesNV_ReturnThruPtr_pData(pData) vkGetRayTracingShaderGroupHandlesNV_CMockReturnMemThruPtr_pData(__LINE__, pData, sizeof(*pData)) +#define vkGetRayTracingShaderGroupHandlesNV_ReturnArrayThruPtr_pData(pData, cmock_len) vkGetRayTracingShaderGroupHandlesNV_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_len * sizeof(*pData)) +#define vkGetRayTracingShaderGroupHandlesNV_ReturnMemThruPtr_pData(pData, cmock_size) vkGetRayTracingShaderGroupHandlesNV_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_size) +void vkGetRayTracingShaderGroupHandlesNV_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, void const* pData, size_t cmock_size); +#define vkGetRayTracingShaderGroupHandlesNV_IgnoreArg_device() vkGetRayTracingShaderGroupHandlesNV_CMockIgnoreArg_device(__LINE__) +void vkGetRayTracingShaderGroupHandlesNV_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetRayTracingShaderGroupHandlesNV_IgnoreArg_pipeline() vkGetRayTracingShaderGroupHandlesNV_CMockIgnoreArg_pipeline(__LINE__) +void vkGetRayTracingShaderGroupHandlesNV_CMockIgnoreArg_pipeline(UNITY_LINE_TYPE cmock_line); +#define vkGetRayTracingShaderGroupHandlesNV_IgnoreArg_firstGroup() vkGetRayTracingShaderGroupHandlesNV_CMockIgnoreArg_firstGroup(__LINE__) +void vkGetRayTracingShaderGroupHandlesNV_CMockIgnoreArg_firstGroup(UNITY_LINE_TYPE cmock_line); +#define vkGetRayTracingShaderGroupHandlesNV_IgnoreArg_groupCount() vkGetRayTracingShaderGroupHandlesNV_CMockIgnoreArg_groupCount(__LINE__) +void vkGetRayTracingShaderGroupHandlesNV_CMockIgnoreArg_groupCount(UNITY_LINE_TYPE cmock_line); +#define vkGetRayTracingShaderGroupHandlesNV_IgnoreArg_dataSize() vkGetRayTracingShaderGroupHandlesNV_CMockIgnoreArg_dataSize(__LINE__) +void vkGetRayTracingShaderGroupHandlesNV_CMockIgnoreArg_dataSize(UNITY_LINE_TYPE cmock_line); +#define vkGetRayTracingShaderGroupHandlesNV_IgnoreArg_pData() vkGetRayTracingShaderGroupHandlesNV_CMockIgnoreArg_pData(__LINE__) +void vkGetRayTracingShaderGroupHandlesNV_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line); +#define vkGetAccelerationStructureHandleNV_IgnoreAndReturn(cmock_retval) vkGetAccelerationStructureHandleNV_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetAccelerationStructureHandleNV_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetAccelerationStructureHandleNV_StopIgnore() vkGetAccelerationStructureHandleNV_CMockStopIgnore() +void vkGetAccelerationStructureHandleNV_CMockStopIgnore(void); +#define vkGetAccelerationStructureHandleNV_ExpectAnyArgsAndReturn(cmock_retval) vkGetAccelerationStructureHandleNV_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetAccelerationStructureHandleNV_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetAccelerationStructureHandleNV_ExpectAndReturn(device, accelerationStructure, dataSize, pData, cmock_retval) vkGetAccelerationStructureHandleNV_CMockExpectAndReturn(__LINE__, device, accelerationStructure, dataSize, pData, cmock_retval) +void vkGetAccelerationStructureHandleNV_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetAccelerationStructureHandleNV_CALLBACK)(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData, int cmock_num_calls); +void vkGetAccelerationStructureHandleNV_AddCallback(CMOCK_vkGetAccelerationStructureHandleNV_CALLBACK Callback); +void vkGetAccelerationStructureHandleNV_Stub(CMOCK_vkGetAccelerationStructureHandleNV_CALLBACK Callback); +#define vkGetAccelerationStructureHandleNV_StubWithCallback vkGetAccelerationStructureHandleNV_AddCallback +#define vkGetAccelerationStructureHandleNV_ReturnThruPtr_pData(pData) vkGetAccelerationStructureHandleNV_CMockReturnMemThruPtr_pData(__LINE__, pData, sizeof(*pData)) +#define vkGetAccelerationStructureHandleNV_ReturnArrayThruPtr_pData(pData, cmock_len) vkGetAccelerationStructureHandleNV_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_len * sizeof(*pData)) +#define vkGetAccelerationStructureHandleNV_ReturnMemThruPtr_pData(pData, cmock_size) vkGetAccelerationStructureHandleNV_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_size) +void vkGetAccelerationStructureHandleNV_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, void const* pData, size_t cmock_size); +#define vkGetAccelerationStructureHandleNV_IgnoreArg_device() vkGetAccelerationStructureHandleNV_CMockIgnoreArg_device(__LINE__) +void vkGetAccelerationStructureHandleNV_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetAccelerationStructureHandleNV_IgnoreArg_accelerationStructure() vkGetAccelerationStructureHandleNV_CMockIgnoreArg_accelerationStructure(__LINE__) +void vkGetAccelerationStructureHandleNV_CMockIgnoreArg_accelerationStructure(UNITY_LINE_TYPE cmock_line); +#define vkGetAccelerationStructureHandleNV_IgnoreArg_dataSize() vkGetAccelerationStructureHandleNV_CMockIgnoreArg_dataSize(__LINE__) +void vkGetAccelerationStructureHandleNV_CMockIgnoreArg_dataSize(UNITY_LINE_TYPE cmock_line); +#define vkGetAccelerationStructureHandleNV_IgnoreArg_pData() vkGetAccelerationStructureHandleNV_CMockIgnoreArg_pData(__LINE__) +void vkGetAccelerationStructureHandleNV_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteAccelerationStructuresPropertiesNV_Ignore() vkCmdWriteAccelerationStructuresPropertiesNV_CMockIgnore() +void vkCmdWriteAccelerationStructuresPropertiesNV_CMockIgnore(void); +#define vkCmdWriteAccelerationStructuresPropertiesNV_StopIgnore() vkCmdWriteAccelerationStructuresPropertiesNV_CMockStopIgnore() +void vkCmdWriteAccelerationStructuresPropertiesNV_CMockStopIgnore(void); +#define vkCmdWriteAccelerationStructuresPropertiesNV_ExpectAnyArgs() vkCmdWriteAccelerationStructuresPropertiesNV_CMockExpectAnyArgs(__LINE__) +void vkCmdWriteAccelerationStructuresPropertiesNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteAccelerationStructuresPropertiesNV_Expect(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery) vkCmdWriteAccelerationStructuresPropertiesNV_CMockExpect(__LINE__, commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery) +void vkCmdWriteAccelerationStructuresPropertiesNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); +typedef void (* CMOCK_vkCmdWriteAccelerationStructuresPropertiesNV_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery, int cmock_num_calls); +void vkCmdWriteAccelerationStructuresPropertiesNV_AddCallback(CMOCK_vkCmdWriteAccelerationStructuresPropertiesNV_CALLBACK Callback); +void vkCmdWriteAccelerationStructuresPropertiesNV_Stub(CMOCK_vkCmdWriteAccelerationStructuresPropertiesNV_CALLBACK Callback); +#define vkCmdWriteAccelerationStructuresPropertiesNV_StubWithCallback vkCmdWriteAccelerationStructuresPropertiesNV_AddCallback +#define vkCmdWriteAccelerationStructuresPropertiesNV_IgnoreArg_commandBuffer() vkCmdWriteAccelerationStructuresPropertiesNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdWriteAccelerationStructuresPropertiesNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteAccelerationStructuresPropertiesNV_IgnoreArg_accelerationStructureCount() vkCmdWriteAccelerationStructuresPropertiesNV_CMockIgnoreArg_accelerationStructureCount(__LINE__) +void vkCmdWriteAccelerationStructuresPropertiesNV_CMockIgnoreArg_accelerationStructureCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteAccelerationStructuresPropertiesNV_IgnoreArg_pAccelerationStructures() vkCmdWriteAccelerationStructuresPropertiesNV_CMockIgnoreArg_pAccelerationStructures(__LINE__) +void vkCmdWriteAccelerationStructuresPropertiesNV_CMockIgnoreArg_pAccelerationStructures(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteAccelerationStructuresPropertiesNV_IgnoreArg_queryType() vkCmdWriteAccelerationStructuresPropertiesNV_CMockIgnoreArg_queryType(__LINE__) +void vkCmdWriteAccelerationStructuresPropertiesNV_CMockIgnoreArg_queryType(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteAccelerationStructuresPropertiesNV_IgnoreArg_queryPool() vkCmdWriteAccelerationStructuresPropertiesNV_CMockIgnoreArg_queryPool(__LINE__) +void vkCmdWriteAccelerationStructuresPropertiesNV_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteAccelerationStructuresPropertiesNV_IgnoreArg_firstQuery() vkCmdWriteAccelerationStructuresPropertiesNV_CMockIgnoreArg_firstQuery(__LINE__) +void vkCmdWriteAccelerationStructuresPropertiesNV_CMockIgnoreArg_firstQuery(UNITY_LINE_TYPE cmock_line); +#define vkCompileDeferredNV_IgnoreAndReturn(cmock_retval) vkCompileDeferredNV_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCompileDeferredNV_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCompileDeferredNV_StopIgnore() vkCompileDeferredNV_CMockStopIgnore() +void vkCompileDeferredNV_CMockStopIgnore(void); +#define vkCompileDeferredNV_ExpectAnyArgsAndReturn(cmock_retval) vkCompileDeferredNV_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCompileDeferredNV_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCompileDeferredNV_ExpectAndReturn(device, pipeline, shader, cmock_retval) vkCompileDeferredNV_CMockExpectAndReturn(__LINE__, device, pipeline, shader, cmock_retval) +void vkCompileDeferredNV_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPipeline pipeline, uint32_t shader, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCompileDeferredNV_CALLBACK)(VkDevice device, VkPipeline pipeline, uint32_t shader, int cmock_num_calls); +void vkCompileDeferredNV_AddCallback(CMOCK_vkCompileDeferredNV_CALLBACK Callback); +void vkCompileDeferredNV_Stub(CMOCK_vkCompileDeferredNV_CALLBACK Callback); +#define vkCompileDeferredNV_StubWithCallback vkCompileDeferredNV_AddCallback +#define vkCompileDeferredNV_IgnoreArg_device() vkCompileDeferredNV_CMockIgnoreArg_device(__LINE__) +void vkCompileDeferredNV_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCompileDeferredNV_IgnoreArg_pipeline() vkCompileDeferredNV_CMockIgnoreArg_pipeline(__LINE__) +void vkCompileDeferredNV_CMockIgnoreArg_pipeline(UNITY_LINE_TYPE cmock_line); +#define vkCompileDeferredNV_IgnoreArg_shader() vkCompileDeferredNV_CMockIgnoreArg_shader(__LINE__) +void vkCompileDeferredNV_CMockIgnoreArg_shader(UNITY_LINE_TYPE cmock_line); +#define vkGetMemoryHostPointerPropertiesEXT_IgnoreAndReturn(cmock_retval) vkGetMemoryHostPointerPropertiesEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetMemoryHostPointerPropertiesEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetMemoryHostPointerPropertiesEXT_StopIgnore() vkGetMemoryHostPointerPropertiesEXT_CMockStopIgnore() +void vkGetMemoryHostPointerPropertiesEXT_CMockStopIgnore(void); +#define vkGetMemoryHostPointerPropertiesEXT_ExpectAnyArgsAndReturn(cmock_retval) vkGetMemoryHostPointerPropertiesEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetMemoryHostPointerPropertiesEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetMemoryHostPointerPropertiesEXT_ExpectAndReturn(device, handleType, pHostPointer, pMemoryHostPointerProperties, cmock_retval) vkGetMemoryHostPointerPropertiesEXT_CMockExpectAndReturn(__LINE__, device, handleType, pHostPointer, pMemoryHostPointerProperties, cmock_retval) +void vkGetMemoryHostPointerPropertiesEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALLBACK)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties, int cmock_num_calls); +void vkGetMemoryHostPointerPropertiesEXT_AddCallback(CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALLBACK Callback); +void vkGetMemoryHostPointerPropertiesEXT_Stub(CMOCK_vkGetMemoryHostPointerPropertiesEXT_CALLBACK Callback); +#define vkGetMemoryHostPointerPropertiesEXT_StubWithCallback vkGetMemoryHostPointerPropertiesEXT_AddCallback +#define vkGetMemoryHostPointerPropertiesEXT_ReturnThruPtr_pMemoryHostPointerProperties(pMemoryHostPointerProperties) vkGetMemoryHostPointerPropertiesEXT_CMockReturnMemThruPtr_pMemoryHostPointerProperties(__LINE__, pMemoryHostPointerProperties, sizeof(VkMemoryHostPointerPropertiesEXT)) +#define vkGetMemoryHostPointerPropertiesEXT_ReturnArrayThruPtr_pMemoryHostPointerProperties(pMemoryHostPointerProperties, cmock_len) vkGetMemoryHostPointerPropertiesEXT_CMockReturnMemThruPtr_pMemoryHostPointerProperties(__LINE__, pMemoryHostPointerProperties, cmock_len * sizeof(*pMemoryHostPointerProperties)) +#define vkGetMemoryHostPointerPropertiesEXT_ReturnMemThruPtr_pMemoryHostPointerProperties(pMemoryHostPointerProperties, cmock_size) vkGetMemoryHostPointerPropertiesEXT_CMockReturnMemThruPtr_pMemoryHostPointerProperties(__LINE__, pMemoryHostPointerProperties, cmock_size) +void vkGetMemoryHostPointerPropertiesEXT_CMockReturnMemThruPtr_pMemoryHostPointerProperties(UNITY_LINE_TYPE cmock_line, VkMemoryHostPointerPropertiesEXT const* pMemoryHostPointerProperties, size_t cmock_size); +#define vkGetMemoryHostPointerPropertiesEXT_IgnoreArg_device() vkGetMemoryHostPointerPropertiesEXT_CMockIgnoreArg_device(__LINE__) +void vkGetMemoryHostPointerPropertiesEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetMemoryHostPointerPropertiesEXT_IgnoreArg_handleType() vkGetMemoryHostPointerPropertiesEXT_CMockIgnoreArg_handleType(__LINE__) +void vkGetMemoryHostPointerPropertiesEXT_CMockIgnoreArg_handleType(UNITY_LINE_TYPE cmock_line); +#define vkGetMemoryHostPointerPropertiesEXT_IgnoreArg_pHostPointer() vkGetMemoryHostPointerPropertiesEXT_CMockIgnoreArg_pHostPointer(__LINE__) +void vkGetMemoryHostPointerPropertiesEXT_CMockIgnoreArg_pHostPointer(UNITY_LINE_TYPE cmock_line); +#define vkGetMemoryHostPointerPropertiesEXT_IgnoreArg_pMemoryHostPointerProperties() vkGetMemoryHostPointerPropertiesEXT_CMockIgnoreArg_pMemoryHostPointerProperties(__LINE__) +void vkGetMemoryHostPointerPropertiesEXT_CMockIgnoreArg_pMemoryHostPointerProperties(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteBufferMarkerAMD_Ignore() vkCmdWriteBufferMarkerAMD_CMockIgnore() +void vkCmdWriteBufferMarkerAMD_CMockIgnore(void); +#define vkCmdWriteBufferMarkerAMD_StopIgnore() vkCmdWriteBufferMarkerAMD_CMockStopIgnore() +void vkCmdWriteBufferMarkerAMD_CMockStopIgnore(void); +#define vkCmdWriteBufferMarkerAMD_ExpectAnyArgs() vkCmdWriteBufferMarkerAMD_CMockExpectAnyArgs(__LINE__) +void vkCmdWriteBufferMarkerAMD_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteBufferMarkerAMD_Expect(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker) vkCmdWriteBufferMarkerAMD_CMockExpect(__LINE__, commandBuffer, pipelineStage, dstBuffer, dstOffset, marker) +void vkCmdWriteBufferMarkerAMD_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker); +typedef void (* CMOCK_vkCmdWriteBufferMarkerAMD_CALLBACK)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker, int cmock_num_calls); +void vkCmdWriteBufferMarkerAMD_AddCallback(CMOCK_vkCmdWriteBufferMarkerAMD_CALLBACK Callback); +void vkCmdWriteBufferMarkerAMD_Stub(CMOCK_vkCmdWriteBufferMarkerAMD_CALLBACK Callback); +#define vkCmdWriteBufferMarkerAMD_StubWithCallback vkCmdWriteBufferMarkerAMD_AddCallback +#define vkCmdWriteBufferMarkerAMD_IgnoreArg_commandBuffer() vkCmdWriteBufferMarkerAMD_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdWriteBufferMarkerAMD_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteBufferMarkerAMD_IgnoreArg_pipelineStage() vkCmdWriteBufferMarkerAMD_CMockIgnoreArg_pipelineStage(__LINE__) +void vkCmdWriteBufferMarkerAMD_CMockIgnoreArg_pipelineStage(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteBufferMarkerAMD_IgnoreArg_dstBuffer() vkCmdWriteBufferMarkerAMD_CMockIgnoreArg_dstBuffer(__LINE__) +void vkCmdWriteBufferMarkerAMD_CMockIgnoreArg_dstBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteBufferMarkerAMD_IgnoreArg_dstOffset() vkCmdWriteBufferMarkerAMD_CMockIgnoreArg_dstOffset(__LINE__) +void vkCmdWriteBufferMarkerAMD_CMockIgnoreArg_dstOffset(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteBufferMarkerAMD_IgnoreArg_marker() vkCmdWriteBufferMarkerAMD_CMockIgnoreArg_marker(__LINE__) +void vkCmdWriteBufferMarkerAMD_CMockIgnoreArg_marker(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_IgnoreAndReturn(cmock_retval) vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_StopIgnore() vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockStopIgnore() +void vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockStopIgnore(void); +#define vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_ExpectAnyArgsAndReturn(cmock_retval) vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_ExpectAndReturn(physicalDevice, pTimeDomainCount, pTimeDomains, cmock_retval) vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockExpectAndReturn(__LINE__, physicalDevice, pTimeDomainCount, pTimeDomains, cmock_retval) +void vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALLBACK)(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains, int cmock_num_calls); +void vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_AddCallback(CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALLBACK Callback); +void vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_Stub(CMOCK_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CALLBACK Callback); +#define vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_StubWithCallback vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_AddCallback +#define vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_ReturnThruPtr_pTimeDomainCount(pTimeDomainCount) vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockReturnMemThruPtr_pTimeDomainCount(__LINE__, pTimeDomainCount, sizeof(uint32_t)) +#define vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_ReturnArrayThruPtr_pTimeDomainCount(pTimeDomainCount, cmock_len) vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockReturnMemThruPtr_pTimeDomainCount(__LINE__, pTimeDomainCount, cmock_len * sizeof(*pTimeDomainCount)) +#define vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_ReturnMemThruPtr_pTimeDomainCount(pTimeDomainCount, cmock_size) vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockReturnMemThruPtr_pTimeDomainCount(__LINE__, pTimeDomainCount, cmock_size) +void vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockReturnMemThruPtr_pTimeDomainCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pTimeDomainCount, size_t cmock_size); +#define vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_ReturnThruPtr_pTimeDomains(pTimeDomains) vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockReturnMemThruPtr_pTimeDomains(__LINE__, pTimeDomains, sizeof(VkTimeDomainEXT)) +#define vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_ReturnArrayThruPtr_pTimeDomains(pTimeDomains, cmock_len) vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockReturnMemThruPtr_pTimeDomains(__LINE__, pTimeDomains, cmock_len * sizeof(*pTimeDomains)) +#define vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_ReturnMemThruPtr_pTimeDomains(pTimeDomains, cmock_size) vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockReturnMemThruPtr_pTimeDomains(__LINE__, pTimeDomains, cmock_size) +void vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockReturnMemThruPtr_pTimeDomains(UNITY_LINE_TYPE cmock_line, VkTimeDomainEXT const* pTimeDomains, size_t cmock_size); +#define vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_IgnoreArg_physicalDevice() vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_IgnoreArg_pTimeDomainCount() vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockIgnoreArg_pTimeDomainCount(__LINE__) +void vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockIgnoreArg_pTimeDomainCount(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_IgnoreArg_pTimeDomains() vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockIgnoreArg_pTimeDomains(__LINE__) +void vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_CMockIgnoreArg_pTimeDomains(UNITY_LINE_TYPE cmock_line); +#define vkGetCalibratedTimestampsEXT_IgnoreAndReturn(cmock_retval) vkGetCalibratedTimestampsEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetCalibratedTimestampsEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetCalibratedTimestampsEXT_StopIgnore() vkGetCalibratedTimestampsEXT_CMockStopIgnore() +void vkGetCalibratedTimestampsEXT_CMockStopIgnore(void); +#define vkGetCalibratedTimestampsEXT_ExpectAnyArgsAndReturn(cmock_retval) vkGetCalibratedTimestampsEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetCalibratedTimestampsEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetCalibratedTimestampsEXT_ExpectAndReturn(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation, cmock_retval) vkGetCalibratedTimestampsEXT_CMockExpectAndReturn(__LINE__, device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation, cmock_retval) +void vkGetCalibratedTimestampsEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetCalibratedTimestampsEXT_CALLBACK)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation, int cmock_num_calls); +void vkGetCalibratedTimestampsEXT_AddCallback(CMOCK_vkGetCalibratedTimestampsEXT_CALLBACK Callback); +void vkGetCalibratedTimestampsEXT_Stub(CMOCK_vkGetCalibratedTimestampsEXT_CALLBACK Callback); +#define vkGetCalibratedTimestampsEXT_StubWithCallback vkGetCalibratedTimestampsEXT_AddCallback +#define vkGetCalibratedTimestampsEXT_ReturnThruPtr_pTimestamps(pTimestamps) vkGetCalibratedTimestampsEXT_CMockReturnMemThruPtr_pTimestamps(__LINE__, pTimestamps, sizeof(uint64_t)) +#define vkGetCalibratedTimestampsEXT_ReturnArrayThruPtr_pTimestamps(pTimestamps, cmock_len) vkGetCalibratedTimestampsEXT_CMockReturnMemThruPtr_pTimestamps(__LINE__, pTimestamps, cmock_len * sizeof(*pTimestamps)) +#define vkGetCalibratedTimestampsEXT_ReturnMemThruPtr_pTimestamps(pTimestamps, cmock_size) vkGetCalibratedTimestampsEXT_CMockReturnMemThruPtr_pTimestamps(__LINE__, pTimestamps, cmock_size) +void vkGetCalibratedTimestampsEXT_CMockReturnMemThruPtr_pTimestamps(UNITY_LINE_TYPE cmock_line, uint64_t const* pTimestamps, size_t cmock_size); +#define vkGetCalibratedTimestampsEXT_ReturnThruPtr_pMaxDeviation(pMaxDeviation) vkGetCalibratedTimestampsEXT_CMockReturnMemThruPtr_pMaxDeviation(__LINE__, pMaxDeviation, sizeof(uint64_t)) +#define vkGetCalibratedTimestampsEXT_ReturnArrayThruPtr_pMaxDeviation(pMaxDeviation, cmock_len) vkGetCalibratedTimestampsEXT_CMockReturnMemThruPtr_pMaxDeviation(__LINE__, pMaxDeviation, cmock_len * sizeof(*pMaxDeviation)) +#define vkGetCalibratedTimestampsEXT_ReturnMemThruPtr_pMaxDeviation(pMaxDeviation, cmock_size) vkGetCalibratedTimestampsEXT_CMockReturnMemThruPtr_pMaxDeviation(__LINE__, pMaxDeviation, cmock_size) +void vkGetCalibratedTimestampsEXT_CMockReturnMemThruPtr_pMaxDeviation(UNITY_LINE_TYPE cmock_line, uint64_t const* pMaxDeviation, size_t cmock_size); +#define vkGetCalibratedTimestampsEXT_IgnoreArg_device() vkGetCalibratedTimestampsEXT_CMockIgnoreArg_device(__LINE__) +void vkGetCalibratedTimestampsEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetCalibratedTimestampsEXT_IgnoreArg_timestampCount() vkGetCalibratedTimestampsEXT_CMockIgnoreArg_timestampCount(__LINE__) +void vkGetCalibratedTimestampsEXT_CMockIgnoreArg_timestampCount(UNITY_LINE_TYPE cmock_line); +#define vkGetCalibratedTimestampsEXT_IgnoreArg_pTimestampInfos() vkGetCalibratedTimestampsEXT_CMockIgnoreArg_pTimestampInfos(__LINE__) +void vkGetCalibratedTimestampsEXT_CMockIgnoreArg_pTimestampInfos(UNITY_LINE_TYPE cmock_line); +#define vkGetCalibratedTimestampsEXT_IgnoreArg_pTimestamps() vkGetCalibratedTimestampsEXT_CMockIgnoreArg_pTimestamps(__LINE__) +void vkGetCalibratedTimestampsEXT_CMockIgnoreArg_pTimestamps(UNITY_LINE_TYPE cmock_line); +#define vkGetCalibratedTimestampsEXT_IgnoreArg_pMaxDeviation() vkGetCalibratedTimestampsEXT_CMockIgnoreArg_pMaxDeviation(__LINE__) +void vkGetCalibratedTimestampsEXT_CMockIgnoreArg_pMaxDeviation(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksNV_Ignore() vkCmdDrawMeshTasksNV_CMockIgnore() +void vkCmdDrawMeshTasksNV_CMockIgnore(void); +#define vkCmdDrawMeshTasksNV_StopIgnore() vkCmdDrawMeshTasksNV_CMockStopIgnore() +void vkCmdDrawMeshTasksNV_CMockStopIgnore(void); +#define vkCmdDrawMeshTasksNV_ExpectAnyArgs() vkCmdDrawMeshTasksNV_CMockExpectAnyArgs(__LINE__) +void vkCmdDrawMeshTasksNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksNV_Expect(commandBuffer, taskCount, firstTask) vkCmdDrawMeshTasksNV_CMockExpect(__LINE__, commandBuffer, taskCount, firstTask) +void vkCmdDrawMeshTasksNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask); +typedef void (* CMOCK_vkCmdDrawMeshTasksNV_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask, int cmock_num_calls); +void vkCmdDrawMeshTasksNV_AddCallback(CMOCK_vkCmdDrawMeshTasksNV_CALLBACK Callback); +void vkCmdDrawMeshTasksNV_Stub(CMOCK_vkCmdDrawMeshTasksNV_CALLBACK Callback); +#define vkCmdDrawMeshTasksNV_StubWithCallback vkCmdDrawMeshTasksNV_AddCallback +#define vkCmdDrawMeshTasksNV_IgnoreArg_commandBuffer() vkCmdDrawMeshTasksNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDrawMeshTasksNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksNV_IgnoreArg_taskCount() vkCmdDrawMeshTasksNV_CMockIgnoreArg_taskCount(__LINE__) +void vkCmdDrawMeshTasksNV_CMockIgnoreArg_taskCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksNV_IgnoreArg_firstTask() vkCmdDrawMeshTasksNV_CMockIgnoreArg_firstTask(__LINE__) +void vkCmdDrawMeshTasksNV_CMockIgnoreArg_firstTask(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksIndirectNV_Ignore() vkCmdDrawMeshTasksIndirectNV_CMockIgnore() +void vkCmdDrawMeshTasksIndirectNV_CMockIgnore(void); +#define vkCmdDrawMeshTasksIndirectNV_StopIgnore() vkCmdDrawMeshTasksIndirectNV_CMockStopIgnore() +void vkCmdDrawMeshTasksIndirectNV_CMockStopIgnore(void); +#define vkCmdDrawMeshTasksIndirectNV_ExpectAnyArgs() vkCmdDrawMeshTasksIndirectNV_CMockExpectAnyArgs(__LINE__) +void vkCmdDrawMeshTasksIndirectNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksIndirectNV_Expect(commandBuffer, buffer, offset, drawCount, stride) vkCmdDrawMeshTasksIndirectNV_CMockExpect(__LINE__, commandBuffer, buffer, offset, drawCount, stride) +void vkCmdDrawMeshTasksIndirectNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void (* CMOCK_vkCmdDrawMeshTasksIndirectNV_CALLBACK)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride, int cmock_num_calls); +void vkCmdDrawMeshTasksIndirectNV_AddCallback(CMOCK_vkCmdDrawMeshTasksIndirectNV_CALLBACK Callback); +void vkCmdDrawMeshTasksIndirectNV_Stub(CMOCK_vkCmdDrawMeshTasksIndirectNV_CALLBACK Callback); +#define vkCmdDrawMeshTasksIndirectNV_StubWithCallback vkCmdDrawMeshTasksIndirectNV_AddCallback +#define vkCmdDrawMeshTasksIndirectNV_IgnoreArg_commandBuffer() vkCmdDrawMeshTasksIndirectNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDrawMeshTasksIndirectNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksIndirectNV_IgnoreArg_buffer() vkCmdDrawMeshTasksIndirectNV_CMockIgnoreArg_buffer(__LINE__) +void vkCmdDrawMeshTasksIndirectNV_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksIndirectNV_IgnoreArg_offset() vkCmdDrawMeshTasksIndirectNV_CMockIgnoreArg_offset(__LINE__) +void vkCmdDrawMeshTasksIndirectNV_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksIndirectNV_IgnoreArg_drawCount() vkCmdDrawMeshTasksIndirectNV_CMockIgnoreArg_drawCount(__LINE__) +void vkCmdDrawMeshTasksIndirectNV_CMockIgnoreArg_drawCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksIndirectNV_IgnoreArg_stride() vkCmdDrawMeshTasksIndirectNV_CMockIgnoreArg_stride(__LINE__) +void vkCmdDrawMeshTasksIndirectNV_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksIndirectCountNV_Ignore() vkCmdDrawMeshTasksIndirectCountNV_CMockIgnore() +void vkCmdDrawMeshTasksIndirectCountNV_CMockIgnore(void); +#define vkCmdDrawMeshTasksIndirectCountNV_StopIgnore() vkCmdDrawMeshTasksIndirectCountNV_CMockStopIgnore() +void vkCmdDrawMeshTasksIndirectCountNV_CMockStopIgnore(void); +#define vkCmdDrawMeshTasksIndirectCountNV_ExpectAnyArgs() vkCmdDrawMeshTasksIndirectCountNV_CMockExpectAnyArgs(__LINE__) +void vkCmdDrawMeshTasksIndirectCountNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksIndirectCountNV_Expect(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride) vkCmdDrawMeshTasksIndirectCountNV_CMockExpect(__LINE__, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride) +void vkCmdDrawMeshTasksIndirectCountNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef void (* CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALLBACK)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, int cmock_num_calls); +void vkCmdDrawMeshTasksIndirectCountNV_AddCallback(CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALLBACK Callback); +void vkCmdDrawMeshTasksIndirectCountNV_Stub(CMOCK_vkCmdDrawMeshTasksIndirectCountNV_CALLBACK Callback); +#define vkCmdDrawMeshTasksIndirectCountNV_StubWithCallback vkCmdDrawMeshTasksIndirectCountNV_AddCallback +#define vkCmdDrawMeshTasksIndirectCountNV_IgnoreArg_commandBuffer() vkCmdDrawMeshTasksIndirectCountNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDrawMeshTasksIndirectCountNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksIndirectCountNV_IgnoreArg_buffer() vkCmdDrawMeshTasksIndirectCountNV_CMockIgnoreArg_buffer(__LINE__) +void vkCmdDrawMeshTasksIndirectCountNV_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksIndirectCountNV_IgnoreArg_offset() vkCmdDrawMeshTasksIndirectCountNV_CMockIgnoreArg_offset(__LINE__) +void vkCmdDrawMeshTasksIndirectCountNV_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksIndirectCountNV_IgnoreArg_countBuffer() vkCmdDrawMeshTasksIndirectCountNV_CMockIgnoreArg_countBuffer(__LINE__) +void vkCmdDrawMeshTasksIndirectCountNV_CMockIgnoreArg_countBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksIndirectCountNV_IgnoreArg_countBufferOffset() vkCmdDrawMeshTasksIndirectCountNV_CMockIgnoreArg_countBufferOffset(__LINE__) +void vkCmdDrawMeshTasksIndirectCountNV_CMockIgnoreArg_countBufferOffset(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksIndirectCountNV_IgnoreArg_maxDrawCount() vkCmdDrawMeshTasksIndirectCountNV_CMockIgnoreArg_maxDrawCount(__LINE__) +void vkCmdDrawMeshTasksIndirectCountNV_CMockIgnoreArg_maxDrawCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksIndirectCountNV_IgnoreArg_stride() vkCmdDrawMeshTasksIndirectCountNV_CMockIgnoreArg_stride(__LINE__) +void vkCmdDrawMeshTasksIndirectCountNV_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetExclusiveScissorEnableNV_Ignore() vkCmdSetExclusiveScissorEnableNV_CMockIgnore() +void vkCmdSetExclusiveScissorEnableNV_CMockIgnore(void); +#define vkCmdSetExclusiveScissorEnableNV_StopIgnore() vkCmdSetExclusiveScissorEnableNV_CMockStopIgnore() +void vkCmdSetExclusiveScissorEnableNV_CMockStopIgnore(void); +#define vkCmdSetExclusiveScissorEnableNV_ExpectAnyArgs() vkCmdSetExclusiveScissorEnableNV_CMockExpectAnyArgs(__LINE__) +void vkCmdSetExclusiveScissorEnableNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetExclusiveScissorEnableNV_Expect(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables) vkCmdSetExclusiveScissorEnableNV_CMockExpect(__LINE__, commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables) +void vkCmdSetExclusiveScissorEnableNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkBool32* pExclusiveScissorEnables); +typedef void (* CMOCK_vkCmdSetExclusiveScissorEnableNV_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkBool32* pExclusiveScissorEnables, int cmock_num_calls); +void vkCmdSetExclusiveScissorEnableNV_AddCallback(CMOCK_vkCmdSetExclusiveScissorEnableNV_CALLBACK Callback); +void vkCmdSetExclusiveScissorEnableNV_Stub(CMOCK_vkCmdSetExclusiveScissorEnableNV_CALLBACK Callback); +#define vkCmdSetExclusiveScissorEnableNV_StubWithCallback vkCmdSetExclusiveScissorEnableNV_AddCallback +#define vkCmdSetExclusiveScissorEnableNV_IgnoreArg_commandBuffer() vkCmdSetExclusiveScissorEnableNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetExclusiveScissorEnableNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetExclusiveScissorEnableNV_IgnoreArg_firstExclusiveScissor() vkCmdSetExclusiveScissorEnableNV_CMockIgnoreArg_firstExclusiveScissor(__LINE__) +void vkCmdSetExclusiveScissorEnableNV_CMockIgnoreArg_firstExclusiveScissor(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetExclusiveScissorEnableNV_IgnoreArg_exclusiveScissorCount() vkCmdSetExclusiveScissorEnableNV_CMockIgnoreArg_exclusiveScissorCount(__LINE__) +void vkCmdSetExclusiveScissorEnableNV_CMockIgnoreArg_exclusiveScissorCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetExclusiveScissorEnableNV_IgnoreArg_pExclusiveScissorEnables() vkCmdSetExclusiveScissorEnableNV_CMockIgnoreArg_pExclusiveScissorEnables(__LINE__) +void vkCmdSetExclusiveScissorEnableNV_CMockIgnoreArg_pExclusiveScissorEnables(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetExclusiveScissorNV_Ignore() vkCmdSetExclusiveScissorNV_CMockIgnore() +void vkCmdSetExclusiveScissorNV_CMockIgnore(void); +#define vkCmdSetExclusiveScissorNV_StopIgnore() vkCmdSetExclusiveScissorNV_CMockStopIgnore() +void vkCmdSetExclusiveScissorNV_CMockStopIgnore(void); +#define vkCmdSetExclusiveScissorNV_ExpectAnyArgs() vkCmdSetExclusiveScissorNV_CMockExpectAnyArgs(__LINE__) +void vkCmdSetExclusiveScissorNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetExclusiveScissorNV_Expect(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors) vkCmdSetExclusiveScissorNV_CMockExpect(__LINE__, commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors) +void vkCmdSetExclusiveScissorNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors); +typedef void (* CMOCK_vkCmdSetExclusiveScissorNV_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors, int cmock_num_calls); +void vkCmdSetExclusiveScissorNV_AddCallback(CMOCK_vkCmdSetExclusiveScissorNV_CALLBACK Callback); +void vkCmdSetExclusiveScissorNV_Stub(CMOCK_vkCmdSetExclusiveScissorNV_CALLBACK Callback); +#define vkCmdSetExclusiveScissorNV_StubWithCallback vkCmdSetExclusiveScissorNV_AddCallback +#define vkCmdSetExclusiveScissorNV_IgnoreArg_commandBuffer() vkCmdSetExclusiveScissorNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetExclusiveScissorNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetExclusiveScissorNV_IgnoreArg_firstExclusiveScissor() vkCmdSetExclusiveScissorNV_CMockIgnoreArg_firstExclusiveScissor(__LINE__) +void vkCmdSetExclusiveScissorNV_CMockIgnoreArg_firstExclusiveScissor(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetExclusiveScissorNV_IgnoreArg_exclusiveScissorCount() vkCmdSetExclusiveScissorNV_CMockIgnoreArg_exclusiveScissorCount(__LINE__) +void vkCmdSetExclusiveScissorNV_CMockIgnoreArg_exclusiveScissorCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetExclusiveScissorNV_IgnoreArg_pExclusiveScissors() vkCmdSetExclusiveScissorNV_CMockIgnoreArg_pExclusiveScissors(__LINE__) +void vkCmdSetExclusiveScissorNV_CMockIgnoreArg_pExclusiveScissors(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCheckpointNV_Ignore() vkCmdSetCheckpointNV_CMockIgnore() +void vkCmdSetCheckpointNV_CMockIgnore(void); +#define vkCmdSetCheckpointNV_StopIgnore() vkCmdSetCheckpointNV_CMockStopIgnore() +void vkCmdSetCheckpointNV_CMockStopIgnore(void); +#define vkCmdSetCheckpointNV_ExpectAnyArgs() vkCmdSetCheckpointNV_CMockExpectAnyArgs(__LINE__) +void vkCmdSetCheckpointNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCheckpointNV_Expect(commandBuffer, pCheckpointMarker) vkCmdSetCheckpointNV_CMockExpect(__LINE__, commandBuffer, pCheckpointMarker) +void vkCmdSetCheckpointNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const void* pCheckpointMarker); +typedef void (* CMOCK_vkCmdSetCheckpointNV_CALLBACK)(VkCommandBuffer commandBuffer, const void* pCheckpointMarker, int cmock_num_calls); +void vkCmdSetCheckpointNV_AddCallback(CMOCK_vkCmdSetCheckpointNV_CALLBACK Callback); +void vkCmdSetCheckpointNV_Stub(CMOCK_vkCmdSetCheckpointNV_CALLBACK Callback); +#define vkCmdSetCheckpointNV_StubWithCallback vkCmdSetCheckpointNV_AddCallback +#define vkCmdSetCheckpointNV_IgnoreArg_commandBuffer() vkCmdSetCheckpointNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetCheckpointNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCheckpointNV_IgnoreArg_pCheckpointMarker() vkCmdSetCheckpointNV_CMockIgnoreArg_pCheckpointMarker(__LINE__) +void vkCmdSetCheckpointNV_CMockIgnoreArg_pCheckpointMarker(UNITY_LINE_TYPE cmock_line); +#define vkGetQueueCheckpointDataNV_Ignore() vkGetQueueCheckpointDataNV_CMockIgnore() +void vkGetQueueCheckpointDataNV_CMockIgnore(void); +#define vkGetQueueCheckpointDataNV_StopIgnore() vkGetQueueCheckpointDataNV_CMockStopIgnore() +void vkGetQueueCheckpointDataNV_CMockStopIgnore(void); +#define vkGetQueueCheckpointDataNV_ExpectAnyArgs() vkGetQueueCheckpointDataNV_CMockExpectAnyArgs(__LINE__) +void vkGetQueueCheckpointDataNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetQueueCheckpointDataNV_Expect(queue, pCheckpointDataCount, pCheckpointData) vkGetQueueCheckpointDataNV_CMockExpect(__LINE__, queue, pCheckpointDataCount, pCheckpointData) +void vkGetQueueCheckpointDataNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData); +typedef void (* CMOCK_vkGetQueueCheckpointDataNV_CALLBACK)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData, int cmock_num_calls); +void vkGetQueueCheckpointDataNV_AddCallback(CMOCK_vkGetQueueCheckpointDataNV_CALLBACK Callback); +void vkGetQueueCheckpointDataNV_Stub(CMOCK_vkGetQueueCheckpointDataNV_CALLBACK Callback); +#define vkGetQueueCheckpointDataNV_StubWithCallback vkGetQueueCheckpointDataNV_AddCallback +#define vkGetQueueCheckpointDataNV_ReturnThruPtr_pCheckpointDataCount(pCheckpointDataCount) vkGetQueueCheckpointDataNV_CMockReturnMemThruPtr_pCheckpointDataCount(__LINE__, pCheckpointDataCount, sizeof(uint32_t)) +#define vkGetQueueCheckpointDataNV_ReturnArrayThruPtr_pCheckpointDataCount(pCheckpointDataCount, cmock_len) vkGetQueueCheckpointDataNV_CMockReturnMemThruPtr_pCheckpointDataCount(__LINE__, pCheckpointDataCount, cmock_len * sizeof(*pCheckpointDataCount)) +#define vkGetQueueCheckpointDataNV_ReturnMemThruPtr_pCheckpointDataCount(pCheckpointDataCount, cmock_size) vkGetQueueCheckpointDataNV_CMockReturnMemThruPtr_pCheckpointDataCount(__LINE__, pCheckpointDataCount, cmock_size) +void vkGetQueueCheckpointDataNV_CMockReturnMemThruPtr_pCheckpointDataCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pCheckpointDataCount, size_t cmock_size); +#define vkGetQueueCheckpointDataNV_ReturnThruPtr_pCheckpointData(pCheckpointData) vkGetQueueCheckpointDataNV_CMockReturnMemThruPtr_pCheckpointData(__LINE__, pCheckpointData, sizeof(VkCheckpointDataNV)) +#define vkGetQueueCheckpointDataNV_ReturnArrayThruPtr_pCheckpointData(pCheckpointData, cmock_len) vkGetQueueCheckpointDataNV_CMockReturnMemThruPtr_pCheckpointData(__LINE__, pCheckpointData, cmock_len * sizeof(*pCheckpointData)) +#define vkGetQueueCheckpointDataNV_ReturnMemThruPtr_pCheckpointData(pCheckpointData, cmock_size) vkGetQueueCheckpointDataNV_CMockReturnMemThruPtr_pCheckpointData(__LINE__, pCheckpointData, cmock_size) +void vkGetQueueCheckpointDataNV_CMockReturnMemThruPtr_pCheckpointData(UNITY_LINE_TYPE cmock_line, VkCheckpointDataNV const* pCheckpointData, size_t cmock_size); +#define vkGetQueueCheckpointDataNV_IgnoreArg_queue() vkGetQueueCheckpointDataNV_CMockIgnoreArg_queue(__LINE__) +void vkGetQueueCheckpointDataNV_CMockIgnoreArg_queue(UNITY_LINE_TYPE cmock_line); +#define vkGetQueueCheckpointDataNV_IgnoreArg_pCheckpointDataCount() vkGetQueueCheckpointDataNV_CMockIgnoreArg_pCheckpointDataCount(__LINE__) +void vkGetQueueCheckpointDataNV_CMockIgnoreArg_pCheckpointDataCount(UNITY_LINE_TYPE cmock_line); +#define vkGetQueueCheckpointDataNV_IgnoreArg_pCheckpointData() vkGetQueueCheckpointDataNV_CMockIgnoreArg_pCheckpointData(__LINE__) +void vkGetQueueCheckpointDataNV_CMockIgnoreArg_pCheckpointData(UNITY_LINE_TYPE cmock_line); +#define vkInitializePerformanceApiINTEL_IgnoreAndReturn(cmock_retval) vkInitializePerformanceApiINTEL_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkInitializePerformanceApiINTEL_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkInitializePerformanceApiINTEL_StopIgnore() vkInitializePerformanceApiINTEL_CMockStopIgnore() +void vkInitializePerformanceApiINTEL_CMockStopIgnore(void); +#define vkInitializePerformanceApiINTEL_ExpectAnyArgsAndReturn(cmock_retval) vkInitializePerformanceApiINTEL_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkInitializePerformanceApiINTEL_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkInitializePerformanceApiINTEL_ExpectAndReturn(device, pInitializeInfo, cmock_retval) vkInitializePerformanceApiINTEL_CMockExpectAndReturn(__LINE__, device, pInitializeInfo, cmock_retval) +void vkInitializePerformanceApiINTEL_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkInitializePerformanceApiINTEL_CALLBACK)(VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo, int cmock_num_calls); +void vkInitializePerformanceApiINTEL_AddCallback(CMOCK_vkInitializePerformanceApiINTEL_CALLBACK Callback); +void vkInitializePerformanceApiINTEL_Stub(CMOCK_vkInitializePerformanceApiINTEL_CALLBACK Callback); +#define vkInitializePerformanceApiINTEL_StubWithCallback vkInitializePerformanceApiINTEL_AddCallback +#define vkInitializePerformanceApiINTEL_IgnoreArg_device() vkInitializePerformanceApiINTEL_CMockIgnoreArg_device(__LINE__) +void vkInitializePerformanceApiINTEL_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkInitializePerformanceApiINTEL_IgnoreArg_pInitializeInfo() vkInitializePerformanceApiINTEL_CMockIgnoreArg_pInitializeInfo(__LINE__) +void vkInitializePerformanceApiINTEL_CMockIgnoreArg_pInitializeInfo(UNITY_LINE_TYPE cmock_line); +#define vkUninitializePerformanceApiINTEL_Ignore() vkUninitializePerformanceApiINTEL_CMockIgnore() +void vkUninitializePerformanceApiINTEL_CMockIgnore(void); +#define vkUninitializePerformanceApiINTEL_StopIgnore() vkUninitializePerformanceApiINTEL_CMockStopIgnore() +void vkUninitializePerformanceApiINTEL_CMockStopIgnore(void); +#define vkUninitializePerformanceApiINTEL_ExpectAnyArgs() vkUninitializePerformanceApiINTEL_CMockExpectAnyArgs(__LINE__) +void vkUninitializePerformanceApiINTEL_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkUninitializePerformanceApiINTEL_Expect(device) vkUninitializePerformanceApiINTEL_CMockExpect(__LINE__, device) +void vkUninitializePerformanceApiINTEL_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device); +typedef void (* CMOCK_vkUninitializePerformanceApiINTEL_CALLBACK)(VkDevice device, int cmock_num_calls); +void vkUninitializePerformanceApiINTEL_AddCallback(CMOCK_vkUninitializePerformanceApiINTEL_CALLBACK Callback); +void vkUninitializePerformanceApiINTEL_Stub(CMOCK_vkUninitializePerformanceApiINTEL_CALLBACK Callback); +#define vkUninitializePerformanceApiINTEL_StubWithCallback vkUninitializePerformanceApiINTEL_AddCallback +#define vkUninitializePerformanceApiINTEL_IgnoreArg_device() vkUninitializePerformanceApiINTEL_CMockIgnoreArg_device(__LINE__) +void vkUninitializePerformanceApiINTEL_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetPerformanceMarkerINTEL_IgnoreAndReturn(cmock_retval) vkCmdSetPerformanceMarkerINTEL_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCmdSetPerformanceMarkerINTEL_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCmdSetPerformanceMarkerINTEL_StopIgnore() vkCmdSetPerformanceMarkerINTEL_CMockStopIgnore() +void vkCmdSetPerformanceMarkerINTEL_CMockStopIgnore(void); +#define vkCmdSetPerformanceMarkerINTEL_ExpectAnyArgsAndReturn(cmock_retval) vkCmdSetPerformanceMarkerINTEL_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCmdSetPerformanceMarkerINTEL_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCmdSetPerformanceMarkerINTEL_ExpectAndReturn(commandBuffer, pMarkerInfo, cmock_retval) vkCmdSetPerformanceMarkerINTEL_CMockExpectAndReturn(__LINE__, commandBuffer, pMarkerInfo, cmock_retval) +void vkCmdSetPerformanceMarkerINTEL_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCmdSetPerformanceMarkerINTEL_CALLBACK)(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo, int cmock_num_calls); +void vkCmdSetPerformanceMarkerINTEL_AddCallback(CMOCK_vkCmdSetPerformanceMarkerINTEL_CALLBACK Callback); +void vkCmdSetPerformanceMarkerINTEL_Stub(CMOCK_vkCmdSetPerformanceMarkerINTEL_CALLBACK Callback); +#define vkCmdSetPerformanceMarkerINTEL_StubWithCallback vkCmdSetPerformanceMarkerINTEL_AddCallback +#define vkCmdSetPerformanceMarkerINTEL_IgnoreArg_commandBuffer() vkCmdSetPerformanceMarkerINTEL_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetPerformanceMarkerINTEL_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetPerformanceMarkerINTEL_IgnoreArg_pMarkerInfo() vkCmdSetPerformanceMarkerINTEL_CMockIgnoreArg_pMarkerInfo(__LINE__) +void vkCmdSetPerformanceMarkerINTEL_CMockIgnoreArg_pMarkerInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetPerformanceStreamMarkerINTEL_IgnoreAndReturn(cmock_retval) vkCmdSetPerformanceStreamMarkerINTEL_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCmdSetPerformanceStreamMarkerINTEL_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCmdSetPerformanceStreamMarkerINTEL_StopIgnore() vkCmdSetPerformanceStreamMarkerINTEL_CMockStopIgnore() +void vkCmdSetPerformanceStreamMarkerINTEL_CMockStopIgnore(void); +#define vkCmdSetPerformanceStreamMarkerINTEL_ExpectAnyArgsAndReturn(cmock_retval) vkCmdSetPerformanceStreamMarkerINTEL_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCmdSetPerformanceStreamMarkerINTEL_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCmdSetPerformanceStreamMarkerINTEL_ExpectAndReturn(commandBuffer, pMarkerInfo, cmock_retval) vkCmdSetPerformanceStreamMarkerINTEL_CMockExpectAndReturn(__LINE__, commandBuffer, pMarkerInfo, cmock_retval) +void vkCmdSetPerformanceStreamMarkerINTEL_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCmdSetPerformanceStreamMarkerINTEL_CALLBACK)(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo, int cmock_num_calls); +void vkCmdSetPerformanceStreamMarkerINTEL_AddCallback(CMOCK_vkCmdSetPerformanceStreamMarkerINTEL_CALLBACK Callback); +void vkCmdSetPerformanceStreamMarkerINTEL_Stub(CMOCK_vkCmdSetPerformanceStreamMarkerINTEL_CALLBACK Callback); +#define vkCmdSetPerformanceStreamMarkerINTEL_StubWithCallback vkCmdSetPerformanceStreamMarkerINTEL_AddCallback +#define vkCmdSetPerformanceStreamMarkerINTEL_IgnoreArg_commandBuffer() vkCmdSetPerformanceStreamMarkerINTEL_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetPerformanceStreamMarkerINTEL_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetPerformanceStreamMarkerINTEL_IgnoreArg_pMarkerInfo() vkCmdSetPerformanceStreamMarkerINTEL_CMockIgnoreArg_pMarkerInfo(__LINE__) +void vkCmdSetPerformanceStreamMarkerINTEL_CMockIgnoreArg_pMarkerInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetPerformanceOverrideINTEL_IgnoreAndReturn(cmock_retval) vkCmdSetPerformanceOverrideINTEL_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCmdSetPerformanceOverrideINTEL_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCmdSetPerformanceOverrideINTEL_StopIgnore() vkCmdSetPerformanceOverrideINTEL_CMockStopIgnore() +void vkCmdSetPerformanceOverrideINTEL_CMockStopIgnore(void); +#define vkCmdSetPerformanceOverrideINTEL_ExpectAnyArgsAndReturn(cmock_retval) vkCmdSetPerformanceOverrideINTEL_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCmdSetPerformanceOverrideINTEL_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCmdSetPerformanceOverrideINTEL_ExpectAndReturn(commandBuffer, pOverrideInfo, cmock_retval) vkCmdSetPerformanceOverrideINTEL_CMockExpectAndReturn(__LINE__, commandBuffer, pOverrideInfo, cmock_retval) +void vkCmdSetPerformanceOverrideINTEL_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCmdSetPerformanceOverrideINTEL_CALLBACK)(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo, int cmock_num_calls); +void vkCmdSetPerformanceOverrideINTEL_AddCallback(CMOCK_vkCmdSetPerformanceOverrideINTEL_CALLBACK Callback); +void vkCmdSetPerformanceOverrideINTEL_Stub(CMOCK_vkCmdSetPerformanceOverrideINTEL_CALLBACK Callback); +#define vkCmdSetPerformanceOverrideINTEL_StubWithCallback vkCmdSetPerformanceOverrideINTEL_AddCallback +#define vkCmdSetPerformanceOverrideINTEL_IgnoreArg_commandBuffer() vkCmdSetPerformanceOverrideINTEL_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetPerformanceOverrideINTEL_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetPerformanceOverrideINTEL_IgnoreArg_pOverrideInfo() vkCmdSetPerformanceOverrideINTEL_CMockIgnoreArg_pOverrideInfo(__LINE__) +void vkCmdSetPerformanceOverrideINTEL_CMockIgnoreArg_pOverrideInfo(UNITY_LINE_TYPE cmock_line); +#define vkAcquirePerformanceConfigurationINTEL_IgnoreAndReturn(cmock_retval) vkAcquirePerformanceConfigurationINTEL_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkAcquirePerformanceConfigurationINTEL_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkAcquirePerformanceConfigurationINTEL_StopIgnore() vkAcquirePerformanceConfigurationINTEL_CMockStopIgnore() +void vkAcquirePerformanceConfigurationINTEL_CMockStopIgnore(void); +#define vkAcquirePerformanceConfigurationINTEL_ExpectAnyArgsAndReturn(cmock_retval) vkAcquirePerformanceConfigurationINTEL_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkAcquirePerformanceConfigurationINTEL_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkAcquirePerformanceConfigurationINTEL_ExpectAndReturn(device, pAcquireInfo, pConfiguration, cmock_retval) vkAcquirePerformanceConfigurationINTEL_CMockExpectAndReturn(__LINE__, device, pAcquireInfo, pConfiguration, cmock_retval) +void vkAcquirePerformanceConfigurationINTEL_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkAcquirePerformanceConfigurationINTEL_CALLBACK)(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration, int cmock_num_calls); +void vkAcquirePerformanceConfigurationINTEL_AddCallback(CMOCK_vkAcquirePerformanceConfigurationINTEL_CALLBACK Callback); +void vkAcquirePerformanceConfigurationINTEL_Stub(CMOCK_vkAcquirePerformanceConfigurationINTEL_CALLBACK Callback); +#define vkAcquirePerformanceConfigurationINTEL_StubWithCallback vkAcquirePerformanceConfigurationINTEL_AddCallback +#define vkAcquirePerformanceConfigurationINTEL_ReturnThruPtr_pConfiguration(pConfiguration) vkAcquirePerformanceConfigurationINTEL_CMockReturnMemThruPtr_pConfiguration(__LINE__, pConfiguration, sizeof(VkPerformanceConfigurationINTEL)) +#define vkAcquirePerformanceConfigurationINTEL_ReturnArrayThruPtr_pConfiguration(pConfiguration, cmock_len) vkAcquirePerformanceConfigurationINTEL_CMockReturnMemThruPtr_pConfiguration(__LINE__, pConfiguration, cmock_len * sizeof(*pConfiguration)) +#define vkAcquirePerformanceConfigurationINTEL_ReturnMemThruPtr_pConfiguration(pConfiguration, cmock_size) vkAcquirePerformanceConfigurationINTEL_CMockReturnMemThruPtr_pConfiguration(__LINE__, pConfiguration, cmock_size) +void vkAcquirePerformanceConfigurationINTEL_CMockReturnMemThruPtr_pConfiguration(UNITY_LINE_TYPE cmock_line, VkPerformanceConfigurationINTEL const* pConfiguration, size_t cmock_size); +#define vkAcquirePerformanceConfigurationINTEL_IgnoreArg_device() vkAcquirePerformanceConfigurationINTEL_CMockIgnoreArg_device(__LINE__) +void vkAcquirePerformanceConfigurationINTEL_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkAcquirePerformanceConfigurationINTEL_IgnoreArg_pAcquireInfo() vkAcquirePerformanceConfigurationINTEL_CMockIgnoreArg_pAcquireInfo(__LINE__) +void vkAcquirePerformanceConfigurationINTEL_CMockIgnoreArg_pAcquireInfo(UNITY_LINE_TYPE cmock_line); +#define vkAcquirePerformanceConfigurationINTEL_IgnoreArg_pConfiguration() vkAcquirePerformanceConfigurationINTEL_CMockIgnoreArg_pConfiguration(__LINE__) +void vkAcquirePerformanceConfigurationINTEL_CMockIgnoreArg_pConfiguration(UNITY_LINE_TYPE cmock_line); +#define vkReleasePerformanceConfigurationINTEL_IgnoreAndReturn(cmock_retval) vkReleasePerformanceConfigurationINTEL_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkReleasePerformanceConfigurationINTEL_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkReleasePerformanceConfigurationINTEL_StopIgnore() vkReleasePerformanceConfigurationINTEL_CMockStopIgnore() +void vkReleasePerformanceConfigurationINTEL_CMockStopIgnore(void); +#define vkReleasePerformanceConfigurationINTEL_ExpectAnyArgsAndReturn(cmock_retval) vkReleasePerformanceConfigurationINTEL_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkReleasePerformanceConfigurationINTEL_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkReleasePerformanceConfigurationINTEL_ExpectAndReturn(device, configuration, cmock_retval) vkReleasePerformanceConfigurationINTEL_CMockExpectAndReturn(__LINE__, device, configuration, cmock_retval) +void vkReleasePerformanceConfigurationINTEL_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPerformanceConfigurationINTEL configuration, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkReleasePerformanceConfigurationINTEL_CALLBACK)(VkDevice device, VkPerformanceConfigurationINTEL configuration, int cmock_num_calls); +void vkReleasePerformanceConfigurationINTEL_AddCallback(CMOCK_vkReleasePerformanceConfigurationINTEL_CALLBACK Callback); +void vkReleasePerformanceConfigurationINTEL_Stub(CMOCK_vkReleasePerformanceConfigurationINTEL_CALLBACK Callback); +#define vkReleasePerformanceConfigurationINTEL_StubWithCallback vkReleasePerformanceConfigurationINTEL_AddCallback +#define vkReleasePerformanceConfigurationINTEL_IgnoreArg_device() vkReleasePerformanceConfigurationINTEL_CMockIgnoreArg_device(__LINE__) +void vkReleasePerformanceConfigurationINTEL_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkReleasePerformanceConfigurationINTEL_IgnoreArg_configuration() vkReleasePerformanceConfigurationINTEL_CMockIgnoreArg_configuration(__LINE__) +void vkReleasePerformanceConfigurationINTEL_CMockIgnoreArg_configuration(UNITY_LINE_TYPE cmock_line); +#define vkQueueSetPerformanceConfigurationINTEL_IgnoreAndReturn(cmock_retval) vkQueueSetPerformanceConfigurationINTEL_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkQueueSetPerformanceConfigurationINTEL_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkQueueSetPerformanceConfigurationINTEL_StopIgnore() vkQueueSetPerformanceConfigurationINTEL_CMockStopIgnore() +void vkQueueSetPerformanceConfigurationINTEL_CMockStopIgnore(void); +#define vkQueueSetPerformanceConfigurationINTEL_ExpectAnyArgsAndReturn(cmock_retval) vkQueueSetPerformanceConfigurationINTEL_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkQueueSetPerformanceConfigurationINTEL_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkQueueSetPerformanceConfigurationINTEL_ExpectAndReturn(queue, configuration, cmock_retval) vkQueueSetPerformanceConfigurationINTEL_CMockExpectAndReturn(__LINE__, queue, configuration, cmock_retval) +void vkQueueSetPerformanceConfigurationINTEL_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkQueue queue, VkPerformanceConfigurationINTEL configuration, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkQueueSetPerformanceConfigurationINTEL_CALLBACK)(VkQueue queue, VkPerformanceConfigurationINTEL configuration, int cmock_num_calls); +void vkQueueSetPerformanceConfigurationINTEL_AddCallback(CMOCK_vkQueueSetPerformanceConfigurationINTEL_CALLBACK Callback); +void vkQueueSetPerformanceConfigurationINTEL_Stub(CMOCK_vkQueueSetPerformanceConfigurationINTEL_CALLBACK Callback); +#define vkQueueSetPerformanceConfigurationINTEL_StubWithCallback vkQueueSetPerformanceConfigurationINTEL_AddCallback +#define vkQueueSetPerformanceConfigurationINTEL_IgnoreArg_queue() vkQueueSetPerformanceConfigurationINTEL_CMockIgnoreArg_queue(__LINE__) +void vkQueueSetPerformanceConfigurationINTEL_CMockIgnoreArg_queue(UNITY_LINE_TYPE cmock_line); +#define vkQueueSetPerformanceConfigurationINTEL_IgnoreArg_configuration() vkQueueSetPerformanceConfigurationINTEL_CMockIgnoreArg_configuration(__LINE__) +void vkQueueSetPerformanceConfigurationINTEL_CMockIgnoreArg_configuration(UNITY_LINE_TYPE cmock_line); +#define vkGetPerformanceParameterINTEL_IgnoreAndReturn(cmock_retval) vkGetPerformanceParameterINTEL_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPerformanceParameterINTEL_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPerformanceParameterINTEL_StopIgnore() vkGetPerformanceParameterINTEL_CMockStopIgnore() +void vkGetPerformanceParameterINTEL_CMockStopIgnore(void); +#define vkGetPerformanceParameterINTEL_ExpectAnyArgsAndReturn(cmock_retval) vkGetPerformanceParameterINTEL_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPerformanceParameterINTEL_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPerformanceParameterINTEL_ExpectAndReturn(device, parameter, pValue, cmock_retval) vkGetPerformanceParameterINTEL_CMockExpectAndReturn(__LINE__, device, parameter, pValue, cmock_retval) +void vkGetPerformanceParameterINTEL_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPerformanceParameterINTEL_CALLBACK)(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue, int cmock_num_calls); +void vkGetPerformanceParameterINTEL_AddCallback(CMOCK_vkGetPerformanceParameterINTEL_CALLBACK Callback); +void vkGetPerformanceParameterINTEL_Stub(CMOCK_vkGetPerformanceParameterINTEL_CALLBACK Callback); +#define vkGetPerformanceParameterINTEL_StubWithCallback vkGetPerformanceParameterINTEL_AddCallback +#define vkGetPerformanceParameterINTEL_ReturnThruPtr_pValue(pValue) vkGetPerformanceParameterINTEL_CMockReturnMemThruPtr_pValue(__LINE__, pValue, sizeof(VkPerformanceValueINTEL)) +#define vkGetPerformanceParameterINTEL_ReturnArrayThruPtr_pValue(pValue, cmock_len) vkGetPerformanceParameterINTEL_CMockReturnMemThruPtr_pValue(__LINE__, pValue, cmock_len * sizeof(*pValue)) +#define vkGetPerformanceParameterINTEL_ReturnMemThruPtr_pValue(pValue, cmock_size) vkGetPerformanceParameterINTEL_CMockReturnMemThruPtr_pValue(__LINE__, pValue, cmock_size) +void vkGetPerformanceParameterINTEL_CMockReturnMemThruPtr_pValue(UNITY_LINE_TYPE cmock_line, VkPerformanceValueINTEL const* pValue, size_t cmock_size); +#define vkGetPerformanceParameterINTEL_IgnoreArg_device() vkGetPerformanceParameterINTEL_CMockIgnoreArg_device(__LINE__) +void vkGetPerformanceParameterINTEL_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetPerformanceParameterINTEL_IgnoreArg_parameter() vkGetPerformanceParameterINTEL_CMockIgnoreArg_parameter(__LINE__) +void vkGetPerformanceParameterINTEL_CMockIgnoreArg_parameter(UNITY_LINE_TYPE cmock_line); +#define vkGetPerformanceParameterINTEL_IgnoreArg_pValue() vkGetPerformanceParameterINTEL_CMockIgnoreArg_pValue(__LINE__) +void vkGetPerformanceParameterINTEL_CMockIgnoreArg_pValue(UNITY_LINE_TYPE cmock_line); +#define vkSetLocalDimmingAMD_Ignore() vkSetLocalDimmingAMD_CMockIgnore() +void vkSetLocalDimmingAMD_CMockIgnore(void); +#define vkSetLocalDimmingAMD_StopIgnore() vkSetLocalDimmingAMD_CMockStopIgnore() +void vkSetLocalDimmingAMD_CMockStopIgnore(void); +#define vkSetLocalDimmingAMD_ExpectAnyArgs() vkSetLocalDimmingAMD_CMockExpectAnyArgs(__LINE__) +void vkSetLocalDimmingAMD_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkSetLocalDimmingAMD_Expect(device, swapChain, localDimmingEnable) vkSetLocalDimmingAMD_CMockExpect(__LINE__, device, swapChain, localDimmingEnable) +void vkSetLocalDimmingAMD_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable); +typedef void (* CMOCK_vkSetLocalDimmingAMD_CALLBACK)(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable, int cmock_num_calls); +void vkSetLocalDimmingAMD_AddCallback(CMOCK_vkSetLocalDimmingAMD_CALLBACK Callback); +void vkSetLocalDimmingAMD_Stub(CMOCK_vkSetLocalDimmingAMD_CALLBACK Callback); +#define vkSetLocalDimmingAMD_StubWithCallback vkSetLocalDimmingAMD_AddCallback +#define vkSetLocalDimmingAMD_IgnoreArg_device() vkSetLocalDimmingAMD_CMockIgnoreArg_device(__LINE__) +void vkSetLocalDimmingAMD_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkSetLocalDimmingAMD_IgnoreArg_swapChain() vkSetLocalDimmingAMD_CMockIgnoreArg_swapChain(__LINE__) +void vkSetLocalDimmingAMD_CMockIgnoreArg_swapChain(UNITY_LINE_TYPE cmock_line); +#define vkSetLocalDimmingAMD_IgnoreArg_localDimmingEnable() vkSetLocalDimmingAMD_CMockIgnoreArg_localDimmingEnable(__LINE__) +void vkSetLocalDimmingAMD_CMockIgnoreArg_localDimmingEnable(UNITY_LINE_TYPE cmock_line); +#define vkGetBufferDeviceAddressEXT_IgnoreAndReturn(cmock_retval) vkGetBufferDeviceAddressEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetBufferDeviceAddressEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkDeviceAddress cmock_to_return); +#define vkGetBufferDeviceAddressEXT_StopIgnore() vkGetBufferDeviceAddressEXT_CMockStopIgnore() +void vkGetBufferDeviceAddressEXT_CMockStopIgnore(void); +#define vkGetBufferDeviceAddressEXT_ExpectAnyArgsAndReturn(cmock_retval) vkGetBufferDeviceAddressEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetBufferDeviceAddressEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkDeviceAddress cmock_to_return); +#define vkGetBufferDeviceAddressEXT_ExpectAndReturn(device, pInfo, cmock_retval) vkGetBufferDeviceAddressEXT_CMockExpectAndReturn(__LINE__, device, pInfo, cmock_retval) +void vkGetBufferDeviceAddressEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkBufferDeviceAddressInfo* pInfo, VkDeviceAddress cmock_to_return); +typedef VkDeviceAddress (* CMOCK_vkGetBufferDeviceAddressEXT_CALLBACK)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo, int cmock_num_calls); +void vkGetBufferDeviceAddressEXT_AddCallback(CMOCK_vkGetBufferDeviceAddressEXT_CALLBACK Callback); +void vkGetBufferDeviceAddressEXT_Stub(CMOCK_vkGetBufferDeviceAddressEXT_CALLBACK Callback); +#define vkGetBufferDeviceAddressEXT_StubWithCallback vkGetBufferDeviceAddressEXT_AddCallback +#define vkGetBufferDeviceAddressEXT_IgnoreArg_device() vkGetBufferDeviceAddressEXT_CMockIgnoreArg_device(__LINE__) +void vkGetBufferDeviceAddressEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetBufferDeviceAddressEXT_IgnoreArg_pInfo() vkGetBufferDeviceAddressEXT_CMockIgnoreArg_pInfo(__LINE__) +void vkGetBufferDeviceAddressEXT_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceToolPropertiesEXT_IgnoreAndReturn(cmock_retval) vkGetPhysicalDeviceToolPropertiesEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceToolPropertiesEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceToolPropertiesEXT_StopIgnore() vkGetPhysicalDeviceToolPropertiesEXT_CMockStopIgnore() +void vkGetPhysicalDeviceToolPropertiesEXT_CMockStopIgnore(void); +#define vkGetPhysicalDeviceToolPropertiesEXT_ExpectAnyArgsAndReturn(cmock_retval) vkGetPhysicalDeviceToolPropertiesEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceToolPropertiesEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceToolPropertiesEXT_ExpectAndReturn(physicalDevice, pToolCount, pToolProperties, cmock_retval) vkGetPhysicalDeviceToolPropertiesEXT_CMockExpectAndReturn(__LINE__, physicalDevice, pToolCount, pToolProperties, cmock_retval) +void vkGetPhysicalDeviceToolPropertiesEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALLBACK)(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties, int cmock_num_calls); +void vkGetPhysicalDeviceToolPropertiesEXT_AddCallback(CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALLBACK Callback); +void vkGetPhysicalDeviceToolPropertiesEXT_Stub(CMOCK_vkGetPhysicalDeviceToolPropertiesEXT_CALLBACK Callback); +#define vkGetPhysicalDeviceToolPropertiesEXT_StubWithCallback vkGetPhysicalDeviceToolPropertiesEXT_AddCallback +#define vkGetPhysicalDeviceToolPropertiesEXT_ReturnThruPtr_pToolCount(pToolCount) vkGetPhysicalDeviceToolPropertiesEXT_CMockReturnMemThruPtr_pToolCount(__LINE__, pToolCount, sizeof(uint32_t)) +#define vkGetPhysicalDeviceToolPropertiesEXT_ReturnArrayThruPtr_pToolCount(pToolCount, cmock_len) vkGetPhysicalDeviceToolPropertiesEXT_CMockReturnMemThruPtr_pToolCount(__LINE__, pToolCount, cmock_len * sizeof(*pToolCount)) +#define vkGetPhysicalDeviceToolPropertiesEXT_ReturnMemThruPtr_pToolCount(pToolCount, cmock_size) vkGetPhysicalDeviceToolPropertiesEXT_CMockReturnMemThruPtr_pToolCount(__LINE__, pToolCount, cmock_size) +void vkGetPhysicalDeviceToolPropertiesEXT_CMockReturnMemThruPtr_pToolCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pToolCount, size_t cmock_size); +#define vkGetPhysicalDeviceToolPropertiesEXT_ReturnThruPtr_pToolProperties(pToolProperties) vkGetPhysicalDeviceToolPropertiesEXT_CMockReturnMemThruPtr_pToolProperties(__LINE__, pToolProperties, sizeof(VkPhysicalDeviceToolProperties)) +#define vkGetPhysicalDeviceToolPropertiesEXT_ReturnArrayThruPtr_pToolProperties(pToolProperties, cmock_len) vkGetPhysicalDeviceToolPropertiesEXT_CMockReturnMemThruPtr_pToolProperties(__LINE__, pToolProperties, cmock_len * sizeof(*pToolProperties)) +#define vkGetPhysicalDeviceToolPropertiesEXT_ReturnMemThruPtr_pToolProperties(pToolProperties, cmock_size) vkGetPhysicalDeviceToolPropertiesEXT_CMockReturnMemThruPtr_pToolProperties(__LINE__, pToolProperties, cmock_size) +void vkGetPhysicalDeviceToolPropertiesEXT_CMockReturnMemThruPtr_pToolProperties(UNITY_LINE_TYPE cmock_line, VkPhysicalDeviceToolProperties const* pToolProperties, size_t cmock_size); +#define vkGetPhysicalDeviceToolPropertiesEXT_IgnoreArg_physicalDevice() vkGetPhysicalDeviceToolPropertiesEXT_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceToolPropertiesEXT_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceToolPropertiesEXT_IgnoreArg_pToolCount() vkGetPhysicalDeviceToolPropertiesEXT_CMockIgnoreArg_pToolCount(__LINE__) +void vkGetPhysicalDeviceToolPropertiesEXT_CMockIgnoreArg_pToolCount(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceToolPropertiesEXT_IgnoreArg_pToolProperties() vkGetPhysicalDeviceToolPropertiesEXT_CMockIgnoreArg_pToolProperties(__LINE__) +void vkGetPhysicalDeviceToolPropertiesEXT_CMockIgnoreArg_pToolProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_IgnoreAndReturn(cmock_retval) vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_StopIgnore() vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockStopIgnore() +void vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockStopIgnore(void); +#define vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_ExpectAnyArgsAndReturn(cmock_retval) vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_ExpectAndReturn(physicalDevice, pPropertyCount, pProperties, cmock_retval) vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockExpectAndReturn(__LINE__, physicalDevice, pPropertyCount, pProperties, cmock_retval) +void vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALLBACK)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties, int cmock_num_calls); +void vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_AddCallback(CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALLBACK Callback); +void vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_Stub(CMOCK_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CALLBACK Callback); +#define vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_StubWithCallback vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_AddCallback +#define vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_ReturnThruPtr_pPropertyCount(pPropertyCount) vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, sizeof(uint32_t)) +#define vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_ReturnArrayThruPtr_pPropertyCount(pPropertyCount, cmock_len) vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, cmock_len * sizeof(*pPropertyCount)) +#define vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_ReturnMemThruPtr_pPropertyCount(pPropertyCount, cmock_size) vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockReturnMemThruPtr_pPropertyCount(__LINE__, pPropertyCount, cmock_size) +void vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockReturnMemThruPtr_pPropertyCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPropertyCount, size_t cmock_size); +#define vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_ReturnThruPtr_pProperties(pProperties) vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, sizeof(VkCooperativeMatrixPropertiesNV)) +#define vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_ReturnArrayThruPtr_pProperties(pProperties, cmock_len) vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_len * sizeof(*pProperties)) +#define vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_ReturnMemThruPtr_pProperties(pProperties, cmock_size) vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_size) +void vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkCooperativeMatrixPropertiesNV const* pProperties, size_t cmock_size); +#define vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_IgnoreArg_physicalDevice() vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_IgnoreArg_pPropertyCount() vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockIgnoreArg_pPropertyCount(__LINE__) +void vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockIgnoreArg_pPropertyCount(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_IgnoreArg_pProperties() vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockIgnoreArg_pProperties(__LINE__) +void vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_IgnoreAndReturn(cmock_retval) vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_StopIgnore() vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockStopIgnore() +void vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockStopIgnore(void); +#define vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_ExpectAnyArgsAndReturn(cmock_retval) vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_ExpectAndReturn(physicalDevice, pCombinationCount, pCombinations, cmock_retval) vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockExpectAndReturn(__LINE__, physicalDevice, pCombinationCount, pCombinations, cmock_retval) +void vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALLBACK)(VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations, int cmock_num_calls); +void vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_AddCallback(CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALLBACK Callback); +void vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_Stub(CMOCK_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CALLBACK Callback); +#define vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_StubWithCallback vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_AddCallback +#define vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_ReturnThruPtr_pCombinationCount(pCombinationCount) vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockReturnMemThruPtr_pCombinationCount(__LINE__, pCombinationCount, sizeof(uint32_t)) +#define vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_ReturnArrayThruPtr_pCombinationCount(pCombinationCount, cmock_len) vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockReturnMemThruPtr_pCombinationCount(__LINE__, pCombinationCount, cmock_len * sizeof(*pCombinationCount)) +#define vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_ReturnMemThruPtr_pCombinationCount(pCombinationCount, cmock_size) vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockReturnMemThruPtr_pCombinationCount(__LINE__, pCombinationCount, cmock_size) +void vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockReturnMemThruPtr_pCombinationCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pCombinationCount, size_t cmock_size); +#define vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_ReturnThruPtr_pCombinations(pCombinations) vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockReturnMemThruPtr_pCombinations(__LINE__, pCombinations, sizeof(VkFramebufferMixedSamplesCombinationNV)) +#define vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_ReturnArrayThruPtr_pCombinations(pCombinations, cmock_len) vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockReturnMemThruPtr_pCombinations(__LINE__, pCombinations, cmock_len * sizeof(*pCombinations)) +#define vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_ReturnMemThruPtr_pCombinations(pCombinations, cmock_size) vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockReturnMemThruPtr_pCombinations(__LINE__, pCombinations, cmock_size) +void vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockReturnMemThruPtr_pCombinations(UNITY_LINE_TYPE cmock_line, VkFramebufferMixedSamplesCombinationNV const* pCombinations, size_t cmock_size); +#define vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_IgnoreArg_physicalDevice() vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_IgnoreArg_pCombinationCount() vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockIgnoreArg_pCombinationCount(__LINE__) +void vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockIgnoreArg_pCombinationCount(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_IgnoreArg_pCombinations() vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockIgnoreArg_pCombinations(__LINE__) +void vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_CMockIgnoreArg_pCombinations(UNITY_LINE_TYPE cmock_line); +#define vkCreateHeadlessSurfaceEXT_IgnoreAndReturn(cmock_retval) vkCreateHeadlessSurfaceEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateHeadlessSurfaceEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateHeadlessSurfaceEXT_StopIgnore() vkCreateHeadlessSurfaceEXT_CMockStopIgnore() +void vkCreateHeadlessSurfaceEXT_CMockStopIgnore(void); +#define vkCreateHeadlessSurfaceEXT_ExpectAnyArgsAndReturn(cmock_retval) vkCreateHeadlessSurfaceEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateHeadlessSurfaceEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateHeadlessSurfaceEXT_ExpectAndReturn(instance, pCreateInfo, pAllocator, pSurface, cmock_retval) vkCreateHeadlessSurfaceEXT_CMockExpectAndReturn(__LINE__, instance, pCreateInfo, pAllocator, pSurface, cmock_retval) +void vkCreateHeadlessSurfaceEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateHeadlessSurfaceEXT_CALLBACK)(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, int cmock_num_calls); +void vkCreateHeadlessSurfaceEXT_AddCallback(CMOCK_vkCreateHeadlessSurfaceEXT_CALLBACK Callback); +void vkCreateHeadlessSurfaceEXT_Stub(CMOCK_vkCreateHeadlessSurfaceEXT_CALLBACK Callback); +#define vkCreateHeadlessSurfaceEXT_StubWithCallback vkCreateHeadlessSurfaceEXT_AddCallback +#define vkCreateHeadlessSurfaceEXT_ReturnThruPtr_pSurface(pSurface) vkCreateHeadlessSurfaceEXT_CMockReturnMemThruPtr_pSurface(__LINE__, pSurface, sizeof(VkSurfaceKHR)) +#define vkCreateHeadlessSurfaceEXT_ReturnArrayThruPtr_pSurface(pSurface, cmock_len) vkCreateHeadlessSurfaceEXT_CMockReturnMemThruPtr_pSurface(__LINE__, pSurface, cmock_len * sizeof(*pSurface)) +#define vkCreateHeadlessSurfaceEXT_ReturnMemThruPtr_pSurface(pSurface, cmock_size) vkCreateHeadlessSurfaceEXT_CMockReturnMemThruPtr_pSurface(__LINE__, pSurface, cmock_size) +void vkCreateHeadlessSurfaceEXT_CMockReturnMemThruPtr_pSurface(UNITY_LINE_TYPE cmock_line, VkSurfaceKHR const* pSurface, size_t cmock_size); +#define vkCreateHeadlessSurfaceEXT_IgnoreArg_instance() vkCreateHeadlessSurfaceEXT_CMockIgnoreArg_instance(__LINE__) +void vkCreateHeadlessSurfaceEXT_CMockIgnoreArg_instance(UNITY_LINE_TYPE cmock_line); +#define vkCreateHeadlessSurfaceEXT_IgnoreArg_pCreateInfo() vkCreateHeadlessSurfaceEXT_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateHeadlessSurfaceEXT_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateHeadlessSurfaceEXT_IgnoreArg_pAllocator() vkCreateHeadlessSurfaceEXT_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateHeadlessSurfaceEXT_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateHeadlessSurfaceEXT_IgnoreArg_pSurface() vkCreateHeadlessSurfaceEXT_CMockIgnoreArg_pSurface(__LINE__) +void vkCreateHeadlessSurfaceEXT_CMockIgnoreArg_pSurface(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetLineStippleEXT_Ignore() vkCmdSetLineStippleEXT_CMockIgnore() +void vkCmdSetLineStippleEXT_CMockIgnore(void); +#define vkCmdSetLineStippleEXT_StopIgnore() vkCmdSetLineStippleEXT_CMockStopIgnore() +void vkCmdSetLineStippleEXT_CMockStopIgnore(void); +#define vkCmdSetLineStippleEXT_ExpectAnyArgs() vkCmdSetLineStippleEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetLineStippleEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetLineStippleEXT_Expect(commandBuffer, lineStippleFactor, lineStipplePattern) vkCmdSetLineStippleEXT_CMockExpect(__LINE__, commandBuffer, lineStippleFactor, lineStipplePattern) +void vkCmdSetLineStippleEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern); +typedef void (* CMOCK_vkCmdSetLineStippleEXT_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern, int cmock_num_calls); +void vkCmdSetLineStippleEXT_AddCallback(CMOCK_vkCmdSetLineStippleEXT_CALLBACK Callback); +void vkCmdSetLineStippleEXT_Stub(CMOCK_vkCmdSetLineStippleEXT_CALLBACK Callback); +#define vkCmdSetLineStippleEXT_StubWithCallback vkCmdSetLineStippleEXT_AddCallback +#define vkCmdSetLineStippleEXT_IgnoreArg_commandBuffer() vkCmdSetLineStippleEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetLineStippleEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetLineStippleEXT_IgnoreArg_lineStippleFactor() vkCmdSetLineStippleEXT_CMockIgnoreArg_lineStippleFactor(__LINE__) +void vkCmdSetLineStippleEXT_CMockIgnoreArg_lineStippleFactor(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetLineStippleEXT_IgnoreArg_lineStipplePattern() vkCmdSetLineStippleEXT_CMockIgnoreArg_lineStipplePattern(__LINE__) +void vkCmdSetLineStippleEXT_CMockIgnoreArg_lineStipplePattern(UNITY_LINE_TYPE cmock_line); +#define vkResetQueryPoolEXT_Ignore() vkResetQueryPoolEXT_CMockIgnore() +void vkResetQueryPoolEXT_CMockIgnore(void); +#define vkResetQueryPoolEXT_StopIgnore() vkResetQueryPoolEXT_CMockStopIgnore() +void vkResetQueryPoolEXT_CMockStopIgnore(void); +#define vkResetQueryPoolEXT_ExpectAnyArgs() vkResetQueryPoolEXT_CMockExpectAnyArgs(__LINE__) +void vkResetQueryPoolEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkResetQueryPoolEXT_Expect(device, queryPool, firstQuery, queryCount) vkResetQueryPoolEXT_CMockExpect(__LINE__, device, queryPool, firstQuery, queryCount) +void vkResetQueryPoolEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); +typedef void (* CMOCK_vkResetQueryPoolEXT_CALLBACK)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, int cmock_num_calls); +void vkResetQueryPoolEXT_AddCallback(CMOCK_vkResetQueryPoolEXT_CALLBACK Callback); +void vkResetQueryPoolEXT_Stub(CMOCK_vkResetQueryPoolEXT_CALLBACK Callback); +#define vkResetQueryPoolEXT_StubWithCallback vkResetQueryPoolEXT_AddCallback +#define vkResetQueryPoolEXT_IgnoreArg_device() vkResetQueryPoolEXT_CMockIgnoreArg_device(__LINE__) +void vkResetQueryPoolEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkResetQueryPoolEXT_IgnoreArg_queryPool() vkResetQueryPoolEXT_CMockIgnoreArg_queryPool(__LINE__) +void vkResetQueryPoolEXT_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line); +#define vkResetQueryPoolEXT_IgnoreArg_firstQuery() vkResetQueryPoolEXT_CMockIgnoreArg_firstQuery(__LINE__) +void vkResetQueryPoolEXT_CMockIgnoreArg_firstQuery(UNITY_LINE_TYPE cmock_line); +#define vkResetQueryPoolEXT_IgnoreArg_queryCount() vkResetQueryPoolEXT_CMockIgnoreArg_queryCount(__LINE__) +void vkResetQueryPoolEXT_CMockIgnoreArg_queryCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCullModeEXT_Ignore() vkCmdSetCullModeEXT_CMockIgnore() +void vkCmdSetCullModeEXT_CMockIgnore(void); +#define vkCmdSetCullModeEXT_StopIgnore() vkCmdSetCullModeEXT_CMockStopIgnore() +void vkCmdSetCullModeEXT_CMockStopIgnore(void); +#define vkCmdSetCullModeEXT_ExpectAnyArgs() vkCmdSetCullModeEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetCullModeEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCullModeEXT_Expect(commandBuffer, cullMode) vkCmdSetCullModeEXT_CMockExpect(__LINE__, commandBuffer, cullMode) +void vkCmdSetCullModeEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkCullModeFlags cullMode); +typedef void (* CMOCK_vkCmdSetCullModeEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode, int cmock_num_calls); +void vkCmdSetCullModeEXT_AddCallback(CMOCK_vkCmdSetCullModeEXT_CALLBACK Callback); +void vkCmdSetCullModeEXT_Stub(CMOCK_vkCmdSetCullModeEXT_CALLBACK Callback); +#define vkCmdSetCullModeEXT_StubWithCallback vkCmdSetCullModeEXT_AddCallback +#define vkCmdSetCullModeEXT_IgnoreArg_commandBuffer() vkCmdSetCullModeEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetCullModeEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCullModeEXT_IgnoreArg_cullMode() vkCmdSetCullModeEXT_CMockIgnoreArg_cullMode(__LINE__) +void vkCmdSetCullModeEXT_CMockIgnoreArg_cullMode(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetFrontFaceEXT_Ignore() vkCmdSetFrontFaceEXT_CMockIgnore() +void vkCmdSetFrontFaceEXT_CMockIgnore(void); +#define vkCmdSetFrontFaceEXT_StopIgnore() vkCmdSetFrontFaceEXT_CMockStopIgnore() +void vkCmdSetFrontFaceEXT_CMockStopIgnore(void); +#define vkCmdSetFrontFaceEXT_ExpectAnyArgs() vkCmdSetFrontFaceEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetFrontFaceEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetFrontFaceEXT_Expect(commandBuffer, frontFace) vkCmdSetFrontFaceEXT_CMockExpect(__LINE__, commandBuffer, frontFace) +void vkCmdSetFrontFaceEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkFrontFace frontFace); +typedef void (* CMOCK_vkCmdSetFrontFaceEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkFrontFace frontFace, int cmock_num_calls); +void vkCmdSetFrontFaceEXT_AddCallback(CMOCK_vkCmdSetFrontFaceEXT_CALLBACK Callback); +void vkCmdSetFrontFaceEXT_Stub(CMOCK_vkCmdSetFrontFaceEXT_CALLBACK Callback); +#define vkCmdSetFrontFaceEXT_StubWithCallback vkCmdSetFrontFaceEXT_AddCallback +#define vkCmdSetFrontFaceEXT_IgnoreArg_commandBuffer() vkCmdSetFrontFaceEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetFrontFaceEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetFrontFaceEXT_IgnoreArg_frontFace() vkCmdSetFrontFaceEXT_CMockIgnoreArg_frontFace(__LINE__) +void vkCmdSetFrontFaceEXT_CMockIgnoreArg_frontFace(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetPrimitiveTopologyEXT_Ignore() vkCmdSetPrimitiveTopologyEXT_CMockIgnore() +void vkCmdSetPrimitiveTopologyEXT_CMockIgnore(void); +#define vkCmdSetPrimitiveTopologyEXT_StopIgnore() vkCmdSetPrimitiveTopologyEXT_CMockStopIgnore() +void vkCmdSetPrimitiveTopologyEXT_CMockStopIgnore(void); +#define vkCmdSetPrimitiveTopologyEXT_ExpectAnyArgs() vkCmdSetPrimitiveTopologyEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetPrimitiveTopologyEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetPrimitiveTopologyEXT_Expect(commandBuffer, primitiveTopology) vkCmdSetPrimitiveTopologyEXT_CMockExpect(__LINE__, commandBuffer, primitiveTopology) +void vkCmdSetPrimitiveTopologyEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology); +typedef void (* CMOCK_vkCmdSetPrimitiveTopologyEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology, int cmock_num_calls); +void vkCmdSetPrimitiveTopologyEXT_AddCallback(CMOCK_vkCmdSetPrimitiveTopologyEXT_CALLBACK Callback); +void vkCmdSetPrimitiveTopologyEXT_Stub(CMOCK_vkCmdSetPrimitiveTopologyEXT_CALLBACK Callback); +#define vkCmdSetPrimitiveTopologyEXT_StubWithCallback vkCmdSetPrimitiveTopologyEXT_AddCallback +#define vkCmdSetPrimitiveTopologyEXT_IgnoreArg_commandBuffer() vkCmdSetPrimitiveTopologyEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetPrimitiveTopologyEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetPrimitiveTopologyEXT_IgnoreArg_primitiveTopology() vkCmdSetPrimitiveTopologyEXT_CMockIgnoreArg_primitiveTopology(__LINE__) +void vkCmdSetPrimitiveTopologyEXT_CMockIgnoreArg_primitiveTopology(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewportWithCountEXT_Ignore() vkCmdSetViewportWithCountEXT_CMockIgnore() +void vkCmdSetViewportWithCountEXT_CMockIgnore(void); +#define vkCmdSetViewportWithCountEXT_StopIgnore() vkCmdSetViewportWithCountEXT_CMockStopIgnore() +void vkCmdSetViewportWithCountEXT_CMockStopIgnore(void); +#define vkCmdSetViewportWithCountEXT_ExpectAnyArgs() vkCmdSetViewportWithCountEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetViewportWithCountEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewportWithCountEXT_Expect(commandBuffer, viewportCount, pViewports) vkCmdSetViewportWithCountEXT_CMockExpect(__LINE__, commandBuffer, viewportCount, pViewports) +void vkCmdSetViewportWithCountEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports); +typedef void (* CMOCK_vkCmdSetViewportWithCountEXT_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports, int cmock_num_calls); +void vkCmdSetViewportWithCountEXT_AddCallback(CMOCK_vkCmdSetViewportWithCountEXT_CALLBACK Callback); +void vkCmdSetViewportWithCountEXT_Stub(CMOCK_vkCmdSetViewportWithCountEXT_CALLBACK Callback); +#define vkCmdSetViewportWithCountEXT_StubWithCallback vkCmdSetViewportWithCountEXT_AddCallback +#define vkCmdSetViewportWithCountEXT_IgnoreArg_commandBuffer() vkCmdSetViewportWithCountEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetViewportWithCountEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewportWithCountEXT_IgnoreArg_viewportCount() vkCmdSetViewportWithCountEXT_CMockIgnoreArg_viewportCount(__LINE__) +void vkCmdSetViewportWithCountEXT_CMockIgnoreArg_viewportCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewportWithCountEXT_IgnoreArg_pViewports() vkCmdSetViewportWithCountEXT_CMockIgnoreArg_pViewports(__LINE__) +void vkCmdSetViewportWithCountEXT_CMockIgnoreArg_pViewports(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetScissorWithCountEXT_Ignore() vkCmdSetScissorWithCountEXT_CMockIgnore() +void vkCmdSetScissorWithCountEXT_CMockIgnore(void); +#define vkCmdSetScissorWithCountEXT_StopIgnore() vkCmdSetScissorWithCountEXT_CMockStopIgnore() +void vkCmdSetScissorWithCountEXT_CMockStopIgnore(void); +#define vkCmdSetScissorWithCountEXT_ExpectAnyArgs() vkCmdSetScissorWithCountEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetScissorWithCountEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetScissorWithCountEXT_Expect(commandBuffer, scissorCount, pScissors) vkCmdSetScissorWithCountEXT_CMockExpect(__LINE__, commandBuffer, scissorCount, pScissors) +void vkCmdSetScissorWithCountEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors); +typedef void (* CMOCK_vkCmdSetScissorWithCountEXT_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors, int cmock_num_calls); +void vkCmdSetScissorWithCountEXT_AddCallback(CMOCK_vkCmdSetScissorWithCountEXT_CALLBACK Callback); +void vkCmdSetScissorWithCountEXT_Stub(CMOCK_vkCmdSetScissorWithCountEXT_CALLBACK Callback); +#define vkCmdSetScissorWithCountEXT_StubWithCallback vkCmdSetScissorWithCountEXT_AddCallback +#define vkCmdSetScissorWithCountEXT_IgnoreArg_commandBuffer() vkCmdSetScissorWithCountEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetScissorWithCountEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetScissorWithCountEXT_IgnoreArg_scissorCount() vkCmdSetScissorWithCountEXT_CMockIgnoreArg_scissorCount(__LINE__) +void vkCmdSetScissorWithCountEXT_CMockIgnoreArg_scissorCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetScissorWithCountEXT_IgnoreArg_pScissors() vkCmdSetScissorWithCountEXT_CMockIgnoreArg_pScissors(__LINE__) +void vkCmdSetScissorWithCountEXT_CMockIgnoreArg_pScissors(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindVertexBuffers2EXT_Ignore() vkCmdBindVertexBuffers2EXT_CMockIgnore() +void vkCmdBindVertexBuffers2EXT_CMockIgnore(void); +#define vkCmdBindVertexBuffers2EXT_StopIgnore() vkCmdBindVertexBuffers2EXT_CMockStopIgnore() +void vkCmdBindVertexBuffers2EXT_CMockStopIgnore(void); +#define vkCmdBindVertexBuffers2EXT_ExpectAnyArgs() vkCmdBindVertexBuffers2EXT_CMockExpectAnyArgs(__LINE__) +void vkCmdBindVertexBuffers2EXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindVertexBuffers2EXT_Expect(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides) vkCmdBindVertexBuffers2EXT_CMockExpect(__LINE__, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides) +void vkCmdBindVertexBuffers2EXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides); +typedef void (* CMOCK_vkCmdBindVertexBuffers2EXT_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides, int cmock_num_calls); +void vkCmdBindVertexBuffers2EXT_AddCallback(CMOCK_vkCmdBindVertexBuffers2EXT_CALLBACK Callback); +void vkCmdBindVertexBuffers2EXT_Stub(CMOCK_vkCmdBindVertexBuffers2EXT_CALLBACK Callback); +#define vkCmdBindVertexBuffers2EXT_StubWithCallback vkCmdBindVertexBuffers2EXT_AddCallback +#define vkCmdBindVertexBuffers2EXT_IgnoreArg_commandBuffer() vkCmdBindVertexBuffers2EXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBindVertexBuffers2EXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindVertexBuffers2EXT_IgnoreArg_firstBinding() vkCmdBindVertexBuffers2EXT_CMockIgnoreArg_firstBinding(__LINE__) +void vkCmdBindVertexBuffers2EXT_CMockIgnoreArg_firstBinding(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindVertexBuffers2EXT_IgnoreArg_bindingCount() vkCmdBindVertexBuffers2EXT_CMockIgnoreArg_bindingCount(__LINE__) +void vkCmdBindVertexBuffers2EXT_CMockIgnoreArg_bindingCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindVertexBuffers2EXT_IgnoreArg_pBuffers() vkCmdBindVertexBuffers2EXT_CMockIgnoreArg_pBuffers(__LINE__) +void vkCmdBindVertexBuffers2EXT_CMockIgnoreArg_pBuffers(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindVertexBuffers2EXT_IgnoreArg_pOffsets() vkCmdBindVertexBuffers2EXT_CMockIgnoreArg_pOffsets(__LINE__) +void vkCmdBindVertexBuffers2EXT_CMockIgnoreArg_pOffsets(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindVertexBuffers2EXT_IgnoreArg_pSizes() vkCmdBindVertexBuffers2EXT_CMockIgnoreArg_pSizes(__LINE__) +void vkCmdBindVertexBuffers2EXT_CMockIgnoreArg_pSizes(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindVertexBuffers2EXT_IgnoreArg_pStrides() vkCmdBindVertexBuffers2EXT_CMockIgnoreArg_pStrides(__LINE__) +void vkCmdBindVertexBuffers2EXT_CMockIgnoreArg_pStrides(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthTestEnableEXT_Ignore() vkCmdSetDepthTestEnableEXT_CMockIgnore() +void vkCmdSetDepthTestEnableEXT_CMockIgnore(void); +#define vkCmdSetDepthTestEnableEXT_StopIgnore() vkCmdSetDepthTestEnableEXT_CMockStopIgnore() +void vkCmdSetDepthTestEnableEXT_CMockStopIgnore(void); +#define vkCmdSetDepthTestEnableEXT_ExpectAnyArgs() vkCmdSetDepthTestEnableEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetDepthTestEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthTestEnableEXT_Expect(commandBuffer, depthTestEnable) vkCmdSetDepthTestEnableEXT_CMockExpect(__LINE__, commandBuffer, depthTestEnable) +void vkCmdSetDepthTestEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 depthTestEnable); +typedef void (* CMOCK_vkCmdSetDepthTestEnableEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable, int cmock_num_calls); +void vkCmdSetDepthTestEnableEXT_AddCallback(CMOCK_vkCmdSetDepthTestEnableEXT_CALLBACK Callback); +void vkCmdSetDepthTestEnableEXT_Stub(CMOCK_vkCmdSetDepthTestEnableEXT_CALLBACK Callback); +#define vkCmdSetDepthTestEnableEXT_StubWithCallback vkCmdSetDepthTestEnableEXT_AddCallback +#define vkCmdSetDepthTestEnableEXT_IgnoreArg_commandBuffer() vkCmdSetDepthTestEnableEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetDepthTestEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthTestEnableEXT_IgnoreArg_depthTestEnable() vkCmdSetDepthTestEnableEXT_CMockIgnoreArg_depthTestEnable(__LINE__) +void vkCmdSetDepthTestEnableEXT_CMockIgnoreArg_depthTestEnable(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthWriteEnableEXT_Ignore() vkCmdSetDepthWriteEnableEXT_CMockIgnore() +void vkCmdSetDepthWriteEnableEXT_CMockIgnore(void); +#define vkCmdSetDepthWriteEnableEXT_StopIgnore() vkCmdSetDepthWriteEnableEXT_CMockStopIgnore() +void vkCmdSetDepthWriteEnableEXT_CMockStopIgnore(void); +#define vkCmdSetDepthWriteEnableEXT_ExpectAnyArgs() vkCmdSetDepthWriteEnableEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetDepthWriteEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthWriteEnableEXT_Expect(commandBuffer, depthWriteEnable) vkCmdSetDepthWriteEnableEXT_CMockExpect(__LINE__, commandBuffer, depthWriteEnable) +void vkCmdSetDepthWriteEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); +typedef void (* CMOCK_vkCmdSetDepthWriteEnableEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable, int cmock_num_calls); +void vkCmdSetDepthWriteEnableEXT_AddCallback(CMOCK_vkCmdSetDepthWriteEnableEXT_CALLBACK Callback); +void vkCmdSetDepthWriteEnableEXT_Stub(CMOCK_vkCmdSetDepthWriteEnableEXT_CALLBACK Callback); +#define vkCmdSetDepthWriteEnableEXT_StubWithCallback vkCmdSetDepthWriteEnableEXT_AddCallback +#define vkCmdSetDepthWriteEnableEXT_IgnoreArg_commandBuffer() vkCmdSetDepthWriteEnableEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetDepthWriteEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthWriteEnableEXT_IgnoreArg_depthWriteEnable() vkCmdSetDepthWriteEnableEXT_CMockIgnoreArg_depthWriteEnable(__LINE__) +void vkCmdSetDepthWriteEnableEXT_CMockIgnoreArg_depthWriteEnable(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthCompareOpEXT_Ignore() vkCmdSetDepthCompareOpEXT_CMockIgnore() +void vkCmdSetDepthCompareOpEXT_CMockIgnore(void); +#define vkCmdSetDepthCompareOpEXT_StopIgnore() vkCmdSetDepthCompareOpEXT_CMockStopIgnore() +void vkCmdSetDepthCompareOpEXT_CMockStopIgnore(void); +#define vkCmdSetDepthCompareOpEXT_ExpectAnyArgs() vkCmdSetDepthCompareOpEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetDepthCompareOpEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthCompareOpEXT_Expect(commandBuffer, depthCompareOp) vkCmdSetDepthCompareOpEXT_CMockExpect(__LINE__, commandBuffer, depthCompareOp) +void vkCmdSetDepthCompareOpEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp); +typedef void (* CMOCK_vkCmdSetDepthCompareOpEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp, int cmock_num_calls); +void vkCmdSetDepthCompareOpEXT_AddCallback(CMOCK_vkCmdSetDepthCompareOpEXT_CALLBACK Callback); +void vkCmdSetDepthCompareOpEXT_Stub(CMOCK_vkCmdSetDepthCompareOpEXT_CALLBACK Callback); +#define vkCmdSetDepthCompareOpEXT_StubWithCallback vkCmdSetDepthCompareOpEXT_AddCallback +#define vkCmdSetDepthCompareOpEXT_IgnoreArg_commandBuffer() vkCmdSetDepthCompareOpEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetDepthCompareOpEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthCompareOpEXT_IgnoreArg_depthCompareOp() vkCmdSetDepthCompareOpEXT_CMockIgnoreArg_depthCompareOp(__LINE__) +void vkCmdSetDepthCompareOpEXT_CMockIgnoreArg_depthCompareOp(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthBoundsTestEnableEXT_Ignore() vkCmdSetDepthBoundsTestEnableEXT_CMockIgnore() +void vkCmdSetDepthBoundsTestEnableEXT_CMockIgnore(void); +#define vkCmdSetDepthBoundsTestEnableEXT_StopIgnore() vkCmdSetDepthBoundsTestEnableEXT_CMockStopIgnore() +void vkCmdSetDepthBoundsTestEnableEXT_CMockStopIgnore(void); +#define vkCmdSetDepthBoundsTestEnableEXT_ExpectAnyArgs() vkCmdSetDepthBoundsTestEnableEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetDepthBoundsTestEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthBoundsTestEnableEXT_Expect(commandBuffer, depthBoundsTestEnable) vkCmdSetDepthBoundsTestEnableEXT_CMockExpect(__LINE__, commandBuffer, depthBoundsTestEnable) +void vkCmdSetDepthBoundsTestEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable); +typedef void (* CMOCK_vkCmdSetDepthBoundsTestEnableEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable, int cmock_num_calls); +void vkCmdSetDepthBoundsTestEnableEXT_AddCallback(CMOCK_vkCmdSetDepthBoundsTestEnableEXT_CALLBACK Callback); +void vkCmdSetDepthBoundsTestEnableEXT_Stub(CMOCK_vkCmdSetDepthBoundsTestEnableEXT_CALLBACK Callback); +#define vkCmdSetDepthBoundsTestEnableEXT_StubWithCallback vkCmdSetDepthBoundsTestEnableEXT_AddCallback +#define vkCmdSetDepthBoundsTestEnableEXT_IgnoreArg_commandBuffer() vkCmdSetDepthBoundsTestEnableEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetDepthBoundsTestEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthBoundsTestEnableEXT_IgnoreArg_depthBoundsTestEnable() vkCmdSetDepthBoundsTestEnableEXT_CMockIgnoreArg_depthBoundsTestEnable(__LINE__) +void vkCmdSetDepthBoundsTestEnableEXT_CMockIgnoreArg_depthBoundsTestEnable(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilTestEnableEXT_Ignore() vkCmdSetStencilTestEnableEXT_CMockIgnore() +void vkCmdSetStencilTestEnableEXT_CMockIgnore(void); +#define vkCmdSetStencilTestEnableEXT_StopIgnore() vkCmdSetStencilTestEnableEXT_CMockStopIgnore() +void vkCmdSetStencilTestEnableEXT_CMockStopIgnore(void); +#define vkCmdSetStencilTestEnableEXT_ExpectAnyArgs() vkCmdSetStencilTestEnableEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetStencilTestEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilTestEnableEXT_Expect(commandBuffer, stencilTestEnable) vkCmdSetStencilTestEnableEXT_CMockExpect(__LINE__, commandBuffer, stencilTestEnable) +void vkCmdSetStencilTestEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable); +typedef void (* CMOCK_vkCmdSetStencilTestEnableEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable, int cmock_num_calls); +void vkCmdSetStencilTestEnableEXT_AddCallback(CMOCK_vkCmdSetStencilTestEnableEXT_CALLBACK Callback); +void vkCmdSetStencilTestEnableEXT_Stub(CMOCK_vkCmdSetStencilTestEnableEXT_CALLBACK Callback); +#define vkCmdSetStencilTestEnableEXT_StubWithCallback vkCmdSetStencilTestEnableEXT_AddCallback +#define vkCmdSetStencilTestEnableEXT_IgnoreArg_commandBuffer() vkCmdSetStencilTestEnableEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetStencilTestEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilTestEnableEXT_IgnoreArg_stencilTestEnable() vkCmdSetStencilTestEnableEXT_CMockIgnoreArg_stencilTestEnable(__LINE__) +void vkCmdSetStencilTestEnableEXT_CMockIgnoreArg_stencilTestEnable(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilOpEXT_Ignore() vkCmdSetStencilOpEXT_CMockIgnore() +void vkCmdSetStencilOpEXT_CMockIgnore(void); +#define vkCmdSetStencilOpEXT_StopIgnore() vkCmdSetStencilOpEXT_CMockStopIgnore() +void vkCmdSetStencilOpEXT_CMockStopIgnore(void); +#define vkCmdSetStencilOpEXT_ExpectAnyArgs() vkCmdSetStencilOpEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetStencilOpEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilOpEXT_Expect(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp) vkCmdSetStencilOpEXT_CMockExpect(__LINE__, commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp) +void vkCmdSetStencilOpEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp); +typedef void (* CMOCK_vkCmdSetStencilOpEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp, int cmock_num_calls); +void vkCmdSetStencilOpEXT_AddCallback(CMOCK_vkCmdSetStencilOpEXT_CALLBACK Callback); +void vkCmdSetStencilOpEXT_Stub(CMOCK_vkCmdSetStencilOpEXT_CALLBACK Callback); +#define vkCmdSetStencilOpEXT_StubWithCallback vkCmdSetStencilOpEXT_AddCallback +#define vkCmdSetStencilOpEXT_IgnoreArg_commandBuffer() vkCmdSetStencilOpEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetStencilOpEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilOpEXT_IgnoreArg_faceMask() vkCmdSetStencilOpEXT_CMockIgnoreArg_faceMask(__LINE__) +void vkCmdSetStencilOpEXT_CMockIgnoreArg_faceMask(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilOpEXT_IgnoreArg_failOp() vkCmdSetStencilOpEXT_CMockIgnoreArg_failOp(__LINE__) +void vkCmdSetStencilOpEXT_CMockIgnoreArg_failOp(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilOpEXT_IgnoreArg_passOp() vkCmdSetStencilOpEXT_CMockIgnoreArg_passOp(__LINE__) +void vkCmdSetStencilOpEXT_CMockIgnoreArg_passOp(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilOpEXT_IgnoreArg_depthFailOp() vkCmdSetStencilOpEXT_CMockIgnoreArg_depthFailOp(__LINE__) +void vkCmdSetStencilOpEXT_CMockIgnoreArg_depthFailOp(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetStencilOpEXT_IgnoreArg_compareOp() vkCmdSetStencilOpEXT_CMockIgnoreArg_compareOp(__LINE__) +void vkCmdSetStencilOpEXT_CMockIgnoreArg_compareOp(UNITY_LINE_TYPE cmock_line); +#define vkReleaseSwapchainImagesEXT_IgnoreAndReturn(cmock_retval) vkReleaseSwapchainImagesEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkReleaseSwapchainImagesEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkReleaseSwapchainImagesEXT_StopIgnore() vkReleaseSwapchainImagesEXT_CMockStopIgnore() +void vkReleaseSwapchainImagesEXT_CMockStopIgnore(void); +#define vkReleaseSwapchainImagesEXT_ExpectAnyArgsAndReturn(cmock_retval) vkReleaseSwapchainImagesEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkReleaseSwapchainImagesEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkReleaseSwapchainImagesEXT_ExpectAndReturn(device, pReleaseInfo, cmock_retval) vkReleaseSwapchainImagesEXT_CMockExpectAndReturn(__LINE__, device, pReleaseInfo, cmock_retval) +void vkReleaseSwapchainImagesEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkReleaseSwapchainImagesEXT_CALLBACK)(VkDevice device, const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo, int cmock_num_calls); +void vkReleaseSwapchainImagesEXT_AddCallback(CMOCK_vkReleaseSwapchainImagesEXT_CALLBACK Callback); +void vkReleaseSwapchainImagesEXT_Stub(CMOCK_vkReleaseSwapchainImagesEXT_CALLBACK Callback); +#define vkReleaseSwapchainImagesEXT_StubWithCallback vkReleaseSwapchainImagesEXT_AddCallback +#define vkReleaseSwapchainImagesEXT_IgnoreArg_device() vkReleaseSwapchainImagesEXT_CMockIgnoreArg_device(__LINE__) +void vkReleaseSwapchainImagesEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkReleaseSwapchainImagesEXT_IgnoreArg_pReleaseInfo() vkReleaseSwapchainImagesEXT_CMockIgnoreArg_pReleaseInfo(__LINE__) +void vkReleaseSwapchainImagesEXT_CMockIgnoreArg_pReleaseInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetGeneratedCommandsMemoryRequirementsNV_Ignore() vkGetGeneratedCommandsMemoryRequirementsNV_CMockIgnore() +void vkGetGeneratedCommandsMemoryRequirementsNV_CMockIgnore(void); +#define vkGetGeneratedCommandsMemoryRequirementsNV_StopIgnore() vkGetGeneratedCommandsMemoryRequirementsNV_CMockStopIgnore() +void vkGetGeneratedCommandsMemoryRequirementsNV_CMockStopIgnore(void); +#define vkGetGeneratedCommandsMemoryRequirementsNV_ExpectAnyArgs() vkGetGeneratedCommandsMemoryRequirementsNV_CMockExpectAnyArgs(__LINE__) +void vkGetGeneratedCommandsMemoryRequirementsNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetGeneratedCommandsMemoryRequirementsNV_Expect(device, pInfo, pMemoryRequirements) vkGetGeneratedCommandsMemoryRequirementsNV_CMockExpect(__LINE__, device, pInfo, pMemoryRequirements) +void vkGetGeneratedCommandsMemoryRequirementsNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (* CMOCK_vkGetGeneratedCommandsMemoryRequirementsNV_CALLBACK)(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements, int cmock_num_calls); +void vkGetGeneratedCommandsMemoryRequirementsNV_AddCallback(CMOCK_vkGetGeneratedCommandsMemoryRequirementsNV_CALLBACK Callback); +void vkGetGeneratedCommandsMemoryRequirementsNV_Stub(CMOCK_vkGetGeneratedCommandsMemoryRequirementsNV_CALLBACK Callback); +#define vkGetGeneratedCommandsMemoryRequirementsNV_StubWithCallback vkGetGeneratedCommandsMemoryRequirementsNV_AddCallback +#define vkGetGeneratedCommandsMemoryRequirementsNV_ReturnThruPtr_pMemoryRequirements(pMemoryRequirements) vkGetGeneratedCommandsMemoryRequirementsNV_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, sizeof(VkMemoryRequirements2)) +#define vkGetGeneratedCommandsMemoryRequirementsNV_ReturnArrayThruPtr_pMemoryRequirements(pMemoryRequirements, cmock_len) vkGetGeneratedCommandsMemoryRequirementsNV_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, cmock_len * sizeof(*pMemoryRequirements)) +#define vkGetGeneratedCommandsMemoryRequirementsNV_ReturnMemThruPtr_pMemoryRequirements(pMemoryRequirements, cmock_size) vkGetGeneratedCommandsMemoryRequirementsNV_CMockReturnMemThruPtr_pMemoryRequirements(__LINE__, pMemoryRequirements, cmock_size) +void vkGetGeneratedCommandsMemoryRequirementsNV_CMockReturnMemThruPtr_pMemoryRequirements(UNITY_LINE_TYPE cmock_line, VkMemoryRequirements2 const* pMemoryRequirements, size_t cmock_size); +#define vkGetGeneratedCommandsMemoryRequirementsNV_IgnoreArg_device() vkGetGeneratedCommandsMemoryRequirementsNV_CMockIgnoreArg_device(__LINE__) +void vkGetGeneratedCommandsMemoryRequirementsNV_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetGeneratedCommandsMemoryRequirementsNV_IgnoreArg_pInfo() vkGetGeneratedCommandsMemoryRequirementsNV_CMockIgnoreArg_pInfo(__LINE__) +void vkGetGeneratedCommandsMemoryRequirementsNV_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetGeneratedCommandsMemoryRequirementsNV_IgnoreArg_pMemoryRequirements() vkGetGeneratedCommandsMemoryRequirementsNV_CMockIgnoreArg_pMemoryRequirements(__LINE__) +void vkGetGeneratedCommandsMemoryRequirementsNV_CMockIgnoreArg_pMemoryRequirements(UNITY_LINE_TYPE cmock_line); +#define vkCmdPreprocessGeneratedCommandsNV_Ignore() vkCmdPreprocessGeneratedCommandsNV_CMockIgnore() +void vkCmdPreprocessGeneratedCommandsNV_CMockIgnore(void); +#define vkCmdPreprocessGeneratedCommandsNV_StopIgnore() vkCmdPreprocessGeneratedCommandsNV_CMockStopIgnore() +void vkCmdPreprocessGeneratedCommandsNV_CMockStopIgnore(void); +#define vkCmdPreprocessGeneratedCommandsNV_ExpectAnyArgs() vkCmdPreprocessGeneratedCommandsNV_CMockExpectAnyArgs(__LINE__) +void vkCmdPreprocessGeneratedCommandsNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdPreprocessGeneratedCommandsNV_Expect(commandBuffer, pGeneratedCommandsInfo) vkCmdPreprocessGeneratedCommandsNV_CMockExpect(__LINE__, commandBuffer, pGeneratedCommandsInfo) +void vkCmdPreprocessGeneratedCommandsNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); +typedef void (* CMOCK_vkCmdPreprocessGeneratedCommandsNV_CALLBACK)(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo, int cmock_num_calls); +void vkCmdPreprocessGeneratedCommandsNV_AddCallback(CMOCK_vkCmdPreprocessGeneratedCommandsNV_CALLBACK Callback); +void vkCmdPreprocessGeneratedCommandsNV_Stub(CMOCK_vkCmdPreprocessGeneratedCommandsNV_CALLBACK Callback); +#define vkCmdPreprocessGeneratedCommandsNV_StubWithCallback vkCmdPreprocessGeneratedCommandsNV_AddCallback +#define vkCmdPreprocessGeneratedCommandsNV_IgnoreArg_commandBuffer() vkCmdPreprocessGeneratedCommandsNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdPreprocessGeneratedCommandsNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdPreprocessGeneratedCommandsNV_IgnoreArg_pGeneratedCommandsInfo() vkCmdPreprocessGeneratedCommandsNV_CMockIgnoreArg_pGeneratedCommandsInfo(__LINE__) +void vkCmdPreprocessGeneratedCommandsNV_CMockIgnoreArg_pGeneratedCommandsInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdExecuteGeneratedCommandsNV_Ignore() vkCmdExecuteGeneratedCommandsNV_CMockIgnore() +void vkCmdExecuteGeneratedCommandsNV_CMockIgnore(void); +#define vkCmdExecuteGeneratedCommandsNV_StopIgnore() vkCmdExecuteGeneratedCommandsNV_CMockStopIgnore() +void vkCmdExecuteGeneratedCommandsNV_CMockStopIgnore(void); +#define vkCmdExecuteGeneratedCommandsNV_ExpectAnyArgs() vkCmdExecuteGeneratedCommandsNV_CMockExpectAnyArgs(__LINE__) +void vkCmdExecuteGeneratedCommandsNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdExecuteGeneratedCommandsNV_Expect(commandBuffer, isPreprocessed, pGeneratedCommandsInfo) vkCmdExecuteGeneratedCommandsNV_CMockExpect(__LINE__, commandBuffer, isPreprocessed, pGeneratedCommandsInfo) +void vkCmdExecuteGeneratedCommandsNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); +typedef void (* CMOCK_vkCmdExecuteGeneratedCommandsNV_CALLBACK)(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo, int cmock_num_calls); +void vkCmdExecuteGeneratedCommandsNV_AddCallback(CMOCK_vkCmdExecuteGeneratedCommandsNV_CALLBACK Callback); +void vkCmdExecuteGeneratedCommandsNV_Stub(CMOCK_vkCmdExecuteGeneratedCommandsNV_CALLBACK Callback); +#define vkCmdExecuteGeneratedCommandsNV_StubWithCallback vkCmdExecuteGeneratedCommandsNV_AddCallback +#define vkCmdExecuteGeneratedCommandsNV_IgnoreArg_commandBuffer() vkCmdExecuteGeneratedCommandsNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdExecuteGeneratedCommandsNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdExecuteGeneratedCommandsNV_IgnoreArg_isPreprocessed() vkCmdExecuteGeneratedCommandsNV_CMockIgnoreArg_isPreprocessed(__LINE__) +void vkCmdExecuteGeneratedCommandsNV_CMockIgnoreArg_isPreprocessed(UNITY_LINE_TYPE cmock_line); +#define vkCmdExecuteGeneratedCommandsNV_IgnoreArg_pGeneratedCommandsInfo() vkCmdExecuteGeneratedCommandsNV_CMockIgnoreArg_pGeneratedCommandsInfo(__LINE__) +void vkCmdExecuteGeneratedCommandsNV_CMockIgnoreArg_pGeneratedCommandsInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindPipelineShaderGroupNV_Ignore() vkCmdBindPipelineShaderGroupNV_CMockIgnore() +void vkCmdBindPipelineShaderGroupNV_CMockIgnore(void); +#define vkCmdBindPipelineShaderGroupNV_StopIgnore() vkCmdBindPipelineShaderGroupNV_CMockStopIgnore() +void vkCmdBindPipelineShaderGroupNV_CMockStopIgnore(void); +#define vkCmdBindPipelineShaderGroupNV_ExpectAnyArgs() vkCmdBindPipelineShaderGroupNV_CMockExpectAnyArgs(__LINE__) +void vkCmdBindPipelineShaderGroupNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindPipelineShaderGroupNV_Expect(commandBuffer, pipelineBindPoint, pipeline, groupIndex) vkCmdBindPipelineShaderGroupNV_CMockExpect(__LINE__, commandBuffer, pipelineBindPoint, pipeline, groupIndex) +void vkCmdBindPipelineShaderGroupNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex); +typedef void (* CMOCK_vkCmdBindPipelineShaderGroupNV_CALLBACK)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex, int cmock_num_calls); +void vkCmdBindPipelineShaderGroupNV_AddCallback(CMOCK_vkCmdBindPipelineShaderGroupNV_CALLBACK Callback); +void vkCmdBindPipelineShaderGroupNV_Stub(CMOCK_vkCmdBindPipelineShaderGroupNV_CALLBACK Callback); +#define vkCmdBindPipelineShaderGroupNV_StubWithCallback vkCmdBindPipelineShaderGroupNV_AddCallback +#define vkCmdBindPipelineShaderGroupNV_IgnoreArg_commandBuffer() vkCmdBindPipelineShaderGroupNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBindPipelineShaderGroupNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindPipelineShaderGroupNV_IgnoreArg_pipelineBindPoint() vkCmdBindPipelineShaderGroupNV_CMockIgnoreArg_pipelineBindPoint(__LINE__) +void vkCmdBindPipelineShaderGroupNV_CMockIgnoreArg_pipelineBindPoint(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindPipelineShaderGroupNV_IgnoreArg_pipeline() vkCmdBindPipelineShaderGroupNV_CMockIgnoreArg_pipeline(__LINE__) +void vkCmdBindPipelineShaderGroupNV_CMockIgnoreArg_pipeline(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindPipelineShaderGroupNV_IgnoreArg_groupIndex() vkCmdBindPipelineShaderGroupNV_CMockIgnoreArg_groupIndex(__LINE__) +void vkCmdBindPipelineShaderGroupNV_CMockIgnoreArg_groupIndex(UNITY_LINE_TYPE cmock_line); +#define vkCreateIndirectCommandsLayoutNV_IgnoreAndReturn(cmock_retval) vkCreateIndirectCommandsLayoutNV_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateIndirectCommandsLayoutNV_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateIndirectCommandsLayoutNV_StopIgnore() vkCreateIndirectCommandsLayoutNV_CMockStopIgnore() +void vkCreateIndirectCommandsLayoutNV_CMockStopIgnore(void); +#define vkCreateIndirectCommandsLayoutNV_ExpectAnyArgsAndReturn(cmock_retval) vkCreateIndirectCommandsLayoutNV_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateIndirectCommandsLayoutNV_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateIndirectCommandsLayoutNV_ExpectAndReturn(device, pCreateInfo, pAllocator, pIndirectCommandsLayout, cmock_retval) vkCreateIndirectCommandsLayoutNV_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pIndirectCommandsLayout, cmock_retval) +void vkCreateIndirectCommandsLayoutNV_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateIndirectCommandsLayoutNV_CALLBACK)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout, int cmock_num_calls); +void vkCreateIndirectCommandsLayoutNV_AddCallback(CMOCK_vkCreateIndirectCommandsLayoutNV_CALLBACK Callback); +void vkCreateIndirectCommandsLayoutNV_Stub(CMOCK_vkCreateIndirectCommandsLayoutNV_CALLBACK Callback); +#define vkCreateIndirectCommandsLayoutNV_StubWithCallback vkCreateIndirectCommandsLayoutNV_AddCallback +#define vkCreateIndirectCommandsLayoutNV_ReturnThruPtr_pIndirectCommandsLayout(pIndirectCommandsLayout) vkCreateIndirectCommandsLayoutNV_CMockReturnMemThruPtr_pIndirectCommandsLayout(__LINE__, pIndirectCommandsLayout, sizeof(VkIndirectCommandsLayoutNV)) +#define vkCreateIndirectCommandsLayoutNV_ReturnArrayThruPtr_pIndirectCommandsLayout(pIndirectCommandsLayout, cmock_len) vkCreateIndirectCommandsLayoutNV_CMockReturnMemThruPtr_pIndirectCommandsLayout(__LINE__, pIndirectCommandsLayout, cmock_len * sizeof(*pIndirectCommandsLayout)) +#define vkCreateIndirectCommandsLayoutNV_ReturnMemThruPtr_pIndirectCommandsLayout(pIndirectCommandsLayout, cmock_size) vkCreateIndirectCommandsLayoutNV_CMockReturnMemThruPtr_pIndirectCommandsLayout(__LINE__, pIndirectCommandsLayout, cmock_size) +void vkCreateIndirectCommandsLayoutNV_CMockReturnMemThruPtr_pIndirectCommandsLayout(UNITY_LINE_TYPE cmock_line, VkIndirectCommandsLayoutNV const* pIndirectCommandsLayout, size_t cmock_size); +#define vkCreateIndirectCommandsLayoutNV_IgnoreArg_device() vkCreateIndirectCommandsLayoutNV_CMockIgnoreArg_device(__LINE__) +void vkCreateIndirectCommandsLayoutNV_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateIndirectCommandsLayoutNV_IgnoreArg_pCreateInfo() vkCreateIndirectCommandsLayoutNV_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateIndirectCommandsLayoutNV_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateIndirectCommandsLayoutNV_IgnoreArg_pAllocator() vkCreateIndirectCommandsLayoutNV_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateIndirectCommandsLayoutNV_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateIndirectCommandsLayoutNV_IgnoreArg_pIndirectCommandsLayout() vkCreateIndirectCommandsLayoutNV_CMockIgnoreArg_pIndirectCommandsLayout(__LINE__) +void vkCreateIndirectCommandsLayoutNV_CMockIgnoreArg_pIndirectCommandsLayout(UNITY_LINE_TYPE cmock_line); +#define vkDestroyIndirectCommandsLayoutNV_Ignore() vkDestroyIndirectCommandsLayoutNV_CMockIgnore() +void vkDestroyIndirectCommandsLayoutNV_CMockIgnore(void); +#define vkDestroyIndirectCommandsLayoutNV_StopIgnore() vkDestroyIndirectCommandsLayoutNV_CMockStopIgnore() +void vkDestroyIndirectCommandsLayoutNV_CMockStopIgnore(void); +#define vkDestroyIndirectCommandsLayoutNV_ExpectAnyArgs() vkDestroyIndirectCommandsLayoutNV_CMockExpectAnyArgs(__LINE__) +void vkDestroyIndirectCommandsLayoutNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyIndirectCommandsLayoutNV_Expect(device, indirectCommandsLayout, pAllocator) vkDestroyIndirectCommandsLayoutNV_CMockExpect(__LINE__, device, indirectCommandsLayout, pAllocator) +void vkDestroyIndirectCommandsLayoutNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyIndirectCommandsLayoutNV_CALLBACK)(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyIndirectCommandsLayoutNV_AddCallback(CMOCK_vkDestroyIndirectCommandsLayoutNV_CALLBACK Callback); +void vkDestroyIndirectCommandsLayoutNV_Stub(CMOCK_vkDestroyIndirectCommandsLayoutNV_CALLBACK Callback); +#define vkDestroyIndirectCommandsLayoutNV_StubWithCallback vkDestroyIndirectCommandsLayoutNV_AddCallback +#define vkDestroyIndirectCommandsLayoutNV_IgnoreArg_device() vkDestroyIndirectCommandsLayoutNV_CMockIgnoreArg_device(__LINE__) +void vkDestroyIndirectCommandsLayoutNV_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyIndirectCommandsLayoutNV_IgnoreArg_indirectCommandsLayout() vkDestroyIndirectCommandsLayoutNV_CMockIgnoreArg_indirectCommandsLayout(__LINE__) +void vkDestroyIndirectCommandsLayoutNV_CMockIgnoreArg_indirectCommandsLayout(UNITY_LINE_TYPE cmock_line); +#define vkDestroyIndirectCommandsLayoutNV_IgnoreArg_pAllocator() vkDestroyIndirectCommandsLayoutNV_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyIndirectCommandsLayoutNV_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkAcquireDrmDisplayEXT_IgnoreAndReturn(cmock_retval) vkAcquireDrmDisplayEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkAcquireDrmDisplayEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkAcquireDrmDisplayEXT_StopIgnore() vkAcquireDrmDisplayEXT_CMockStopIgnore() +void vkAcquireDrmDisplayEXT_CMockStopIgnore(void); +#define vkAcquireDrmDisplayEXT_ExpectAnyArgsAndReturn(cmock_retval) vkAcquireDrmDisplayEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkAcquireDrmDisplayEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkAcquireDrmDisplayEXT_ExpectAndReturn(physicalDevice, drmFd, display, cmock_retval) vkAcquireDrmDisplayEXT_CMockExpectAndReturn(__LINE__, physicalDevice, drmFd, display, cmock_retval) +void vkAcquireDrmDisplayEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkAcquireDrmDisplayEXT_CALLBACK)(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display, int cmock_num_calls); +void vkAcquireDrmDisplayEXT_AddCallback(CMOCK_vkAcquireDrmDisplayEXT_CALLBACK Callback); +void vkAcquireDrmDisplayEXT_Stub(CMOCK_vkAcquireDrmDisplayEXT_CALLBACK Callback); +#define vkAcquireDrmDisplayEXT_StubWithCallback vkAcquireDrmDisplayEXT_AddCallback +#define vkAcquireDrmDisplayEXT_IgnoreArg_physicalDevice() vkAcquireDrmDisplayEXT_CMockIgnoreArg_physicalDevice(__LINE__) +void vkAcquireDrmDisplayEXT_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkAcquireDrmDisplayEXT_IgnoreArg_drmFd() vkAcquireDrmDisplayEXT_CMockIgnoreArg_drmFd(__LINE__) +void vkAcquireDrmDisplayEXT_CMockIgnoreArg_drmFd(UNITY_LINE_TYPE cmock_line); +#define vkAcquireDrmDisplayEXT_IgnoreArg_display() vkAcquireDrmDisplayEXT_CMockIgnoreArg_display(__LINE__) +void vkAcquireDrmDisplayEXT_CMockIgnoreArg_display(UNITY_LINE_TYPE cmock_line); +#define vkGetDrmDisplayEXT_IgnoreAndReturn(cmock_retval) vkGetDrmDisplayEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetDrmDisplayEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetDrmDisplayEXT_StopIgnore() vkGetDrmDisplayEXT_CMockStopIgnore() +void vkGetDrmDisplayEXT_CMockStopIgnore(void); +#define vkGetDrmDisplayEXT_ExpectAnyArgsAndReturn(cmock_retval) vkGetDrmDisplayEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetDrmDisplayEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetDrmDisplayEXT_ExpectAndReturn(physicalDevice, drmFd, connectorId, display, cmock_retval) vkGetDrmDisplayEXT_CMockExpectAndReturn(__LINE__, physicalDevice, drmFd, connectorId, display, cmock_retval) +void vkGetDrmDisplayEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetDrmDisplayEXT_CALLBACK)(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display, int cmock_num_calls); +void vkGetDrmDisplayEXT_AddCallback(CMOCK_vkGetDrmDisplayEXT_CALLBACK Callback); +void vkGetDrmDisplayEXT_Stub(CMOCK_vkGetDrmDisplayEXT_CALLBACK Callback); +#define vkGetDrmDisplayEXT_StubWithCallback vkGetDrmDisplayEXT_AddCallback +#define vkGetDrmDisplayEXT_ReturnThruPtr_display(display) vkGetDrmDisplayEXT_CMockReturnMemThruPtr_display(__LINE__, display, sizeof(VkDisplayKHR)) +#define vkGetDrmDisplayEXT_ReturnArrayThruPtr_display(display, cmock_len) vkGetDrmDisplayEXT_CMockReturnMemThruPtr_display(__LINE__, display, cmock_len * sizeof(*display)) +#define vkGetDrmDisplayEXT_ReturnMemThruPtr_display(display, cmock_size) vkGetDrmDisplayEXT_CMockReturnMemThruPtr_display(__LINE__, display, cmock_size) +void vkGetDrmDisplayEXT_CMockReturnMemThruPtr_display(UNITY_LINE_TYPE cmock_line, VkDisplayKHR const* display, size_t cmock_size); +#define vkGetDrmDisplayEXT_IgnoreArg_physicalDevice() vkGetDrmDisplayEXT_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetDrmDisplayEXT_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetDrmDisplayEXT_IgnoreArg_drmFd() vkGetDrmDisplayEXT_CMockIgnoreArg_drmFd(__LINE__) +void vkGetDrmDisplayEXT_CMockIgnoreArg_drmFd(UNITY_LINE_TYPE cmock_line); +#define vkGetDrmDisplayEXT_IgnoreArg_connectorId() vkGetDrmDisplayEXT_CMockIgnoreArg_connectorId(__LINE__) +void vkGetDrmDisplayEXT_CMockIgnoreArg_connectorId(UNITY_LINE_TYPE cmock_line); +#define vkGetDrmDisplayEXT_IgnoreArg_display() vkGetDrmDisplayEXT_CMockIgnoreArg_display(__LINE__) +void vkGetDrmDisplayEXT_CMockIgnoreArg_display(UNITY_LINE_TYPE cmock_line); +#define vkCreatePrivateDataSlotEXT_IgnoreAndReturn(cmock_retval) vkCreatePrivateDataSlotEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreatePrivateDataSlotEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreatePrivateDataSlotEXT_StopIgnore() vkCreatePrivateDataSlotEXT_CMockStopIgnore() +void vkCreatePrivateDataSlotEXT_CMockStopIgnore(void); +#define vkCreatePrivateDataSlotEXT_ExpectAnyArgsAndReturn(cmock_retval) vkCreatePrivateDataSlotEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreatePrivateDataSlotEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreatePrivateDataSlotEXT_ExpectAndReturn(device, pCreateInfo, pAllocator, pPrivateDataSlot, cmock_retval) vkCreatePrivateDataSlotEXT_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pPrivateDataSlot, cmock_retval) +void vkCreatePrivateDataSlotEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreatePrivateDataSlotEXT_CALLBACK)(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot, int cmock_num_calls); +void vkCreatePrivateDataSlotEXT_AddCallback(CMOCK_vkCreatePrivateDataSlotEXT_CALLBACK Callback); +void vkCreatePrivateDataSlotEXT_Stub(CMOCK_vkCreatePrivateDataSlotEXT_CALLBACK Callback); +#define vkCreatePrivateDataSlotEXT_StubWithCallback vkCreatePrivateDataSlotEXT_AddCallback +#define vkCreatePrivateDataSlotEXT_ReturnThruPtr_pPrivateDataSlot(pPrivateDataSlot) vkCreatePrivateDataSlotEXT_CMockReturnMemThruPtr_pPrivateDataSlot(__LINE__, pPrivateDataSlot, sizeof(VkPrivateDataSlot)) +#define vkCreatePrivateDataSlotEXT_ReturnArrayThruPtr_pPrivateDataSlot(pPrivateDataSlot, cmock_len) vkCreatePrivateDataSlotEXT_CMockReturnMemThruPtr_pPrivateDataSlot(__LINE__, pPrivateDataSlot, cmock_len * sizeof(*pPrivateDataSlot)) +#define vkCreatePrivateDataSlotEXT_ReturnMemThruPtr_pPrivateDataSlot(pPrivateDataSlot, cmock_size) vkCreatePrivateDataSlotEXT_CMockReturnMemThruPtr_pPrivateDataSlot(__LINE__, pPrivateDataSlot, cmock_size) +void vkCreatePrivateDataSlotEXT_CMockReturnMemThruPtr_pPrivateDataSlot(UNITY_LINE_TYPE cmock_line, VkPrivateDataSlot const* pPrivateDataSlot, size_t cmock_size); +#define vkCreatePrivateDataSlotEXT_IgnoreArg_device() vkCreatePrivateDataSlotEXT_CMockIgnoreArg_device(__LINE__) +void vkCreatePrivateDataSlotEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreatePrivateDataSlotEXT_IgnoreArg_pCreateInfo() vkCreatePrivateDataSlotEXT_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreatePrivateDataSlotEXT_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreatePrivateDataSlotEXT_IgnoreArg_pAllocator() vkCreatePrivateDataSlotEXT_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreatePrivateDataSlotEXT_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreatePrivateDataSlotEXT_IgnoreArg_pPrivateDataSlot() vkCreatePrivateDataSlotEXT_CMockIgnoreArg_pPrivateDataSlot(__LINE__) +void vkCreatePrivateDataSlotEXT_CMockIgnoreArg_pPrivateDataSlot(UNITY_LINE_TYPE cmock_line); +#define vkDestroyPrivateDataSlotEXT_Ignore() vkDestroyPrivateDataSlotEXT_CMockIgnore() +void vkDestroyPrivateDataSlotEXT_CMockIgnore(void); +#define vkDestroyPrivateDataSlotEXT_StopIgnore() vkDestroyPrivateDataSlotEXT_CMockStopIgnore() +void vkDestroyPrivateDataSlotEXT_CMockStopIgnore(void); +#define vkDestroyPrivateDataSlotEXT_ExpectAnyArgs() vkDestroyPrivateDataSlotEXT_CMockExpectAnyArgs(__LINE__) +void vkDestroyPrivateDataSlotEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyPrivateDataSlotEXT_Expect(device, privateDataSlot, pAllocator) vkDestroyPrivateDataSlotEXT_CMockExpect(__LINE__, device, privateDataSlot, pAllocator) +void vkDestroyPrivateDataSlotEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyPrivateDataSlotEXT_CALLBACK)(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyPrivateDataSlotEXT_AddCallback(CMOCK_vkDestroyPrivateDataSlotEXT_CALLBACK Callback); +void vkDestroyPrivateDataSlotEXT_Stub(CMOCK_vkDestroyPrivateDataSlotEXT_CALLBACK Callback); +#define vkDestroyPrivateDataSlotEXT_StubWithCallback vkDestroyPrivateDataSlotEXT_AddCallback +#define vkDestroyPrivateDataSlotEXT_IgnoreArg_device() vkDestroyPrivateDataSlotEXT_CMockIgnoreArg_device(__LINE__) +void vkDestroyPrivateDataSlotEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyPrivateDataSlotEXT_IgnoreArg_privateDataSlot() vkDestroyPrivateDataSlotEXT_CMockIgnoreArg_privateDataSlot(__LINE__) +void vkDestroyPrivateDataSlotEXT_CMockIgnoreArg_privateDataSlot(UNITY_LINE_TYPE cmock_line); +#define vkDestroyPrivateDataSlotEXT_IgnoreArg_pAllocator() vkDestroyPrivateDataSlotEXT_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyPrivateDataSlotEXT_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkSetPrivateDataEXT_IgnoreAndReturn(cmock_retval) vkSetPrivateDataEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkSetPrivateDataEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkSetPrivateDataEXT_StopIgnore() vkSetPrivateDataEXT_CMockStopIgnore() +void vkSetPrivateDataEXT_CMockStopIgnore(void); +#define vkSetPrivateDataEXT_ExpectAnyArgsAndReturn(cmock_retval) vkSetPrivateDataEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkSetPrivateDataEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkSetPrivateDataEXT_ExpectAndReturn(device, objectType, objectHandle, privateDataSlot, data, cmock_retval) vkSetPrivateDataEXT_CMockExpectAndReturn(__LINE__, device, objectType, objectHandle, privateDataSlot, data, cmock_retval) +void vkSetPrivateDataEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkSetPrivateDataEXT_CALLBACK)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data, int cmock_num_calls); +void vkSetPrivateDataEXT_AddCallback(CMOCK_vkSetPrivateDataEXT_CALLBACK Callback); +void vkSetPrivateDataEXT_Stub(CMOCK_vkSetPrivateDataEXT_CALLBACK Callback); +#define vkSetPrivateDataEXT_StubWithCallback vkSetPrivateDataEXT_AddCallback +#define vkSetPrivateDataEXT_IgnoreArg_device() vkSetPrivateDataEXT_CMockIgnoreArg_device(__LINE__) +void vkSetPrivateDataEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkSetPrivateDataEXT_IgnoreArg_objectType() vkSetPrivateDataEXT_CMockIgnoreArg_objectType(__LINE__) +void vkSetPrivateDataEXT_CMockIgnoreArg_objectType(UNITY_LINE_TYPE cmock_line); +#define vkSetPrivateDataEXT_IgnoreArg_objectHandle() vkSetPrivateDataEXT_CMockIgnoreArg_objectHandle(__LINE__) +void vkSetPrivateDataEXT_CMockIgnoreArg_objectHandle(UNITY_LINE_TYPE cmock_line); +#define vkSetPrivateDataEXT_IgnoreArg_privateDataSlot() vkSetPrivateDataEXT_CMockIgnoreArg_privateDataSlot(__LINE__) +void vkSetPrivateDataEXT_CMockIgnoreArg_privateDataSlot(UNITY_LINE_TYPE cmock_line); +#define vkSetPrivateDataEXT_IgnoreArg_data() vkSetPrivateDataEXT_CMockIgnoreArg_data(__LINE__) +void vkSetPrivateDataEXT_CMockIgnoreArg_data(UNITY_LINE_TYPE cmock_line); +#define vkGetPrivateDataEXT_Ignore() vkGetPrivateDataEXT_CMockIgnore() +void vkGetPrivateDataEXT_CMockIgnore(void); +#define vkGetPrivateDataEXT_StopIgnore() vkGetPrivateDataEXT_CMockStopIgnore() +void vkGetPrivateDataEXT_CMockStopIgnore(void); +#define vkGetPrivateDataEXT_ExpectAnyArgs() vkGetPrivateDataEXT_CMockExpectAnyArgs(__LINE__) +void vkGetPrivateDataEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetPrivateDataEXT_Expect(device, objectType, objectHandle, privateDataSlot, pData) vkGetPrivateDataEXT_CMockExpect(__LINE__, device, objectType, objectHandle, privateDataSlot, pData) +void vkGetPrivateDataEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData); +typedef void (* CMOCK_vkGetPrivateDataEXT_CALLBACK)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData, int cmock_num_calls); +void vkGetPrivateDataEXT_AddCallback(CMOCK_vkGetPrivateDataEXT_CALLBACK Callback); +void vkGetPrivateDataEXT_Stub(CMOCK_vkGetPrivateDataEXT_CALLBACK Callback); +#define vkGetPrivateDataEXT_StubWithCallback vkGetPrivateDataEXT_AddCallback +#define vkGetPrivateDataEXT_ReturnThruPtr_pData(pData) vkGetPrivateDataEXT_CMockReturnMemThruPtr_pData(__LINE__, pData, sizeof(uint64_t)) +#define vkGetPrivateDataEXT_ReturnArrayThruPtr_pData(pData, cmock_len) vkGetPrivateDataEXT_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_len * sizeof(*pData)) +#define vkGetPrivateDataEXT_ReturnMemThruPtr_pData(pData, cmock_size) vkGetPrivateDataEXT_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_size) +void vkGetPrivateDataEXT_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, uint64_t const* pData, size_t cmock_size); +#define vkGetPrivateDataEXT_IgnoreArg_device() vkGetPrivateDataEXT_CMockIgnoreArg_device(__LINE__) +void vkGetPrivateDataEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetPrivateDataEXT_IgnoreArg_objectType() vkGetPrivateDataEXT_CMockIgnoreArg_objectType(__LINE__) +void vkGetPrivateDataEXT_CMockIgnoreArg_objectType(UNITY_LINE_TYPE cmock_line); +#define vkGetPrivateDataEXT_IgnoreArg_objectHandle() vkGetPrivateDataEXT_CMockIgnoreArg_objectHandle(__LINE__) +void vkGetPrivateDataEXT_CMockIgnoreArg_objectHandle(UNITY_LINE_TYPE cmock_line); +#define vkGetPrivateDataEXT_IgnoreArg_privateDataSlot() vkGetPrivateDataEXT_CMockIgnoreArg_privateDataSlot(__LINE__) +void vkGetPrivateDataEXT_CMockIgnoreArg_privateDataSlot(UNITY_LINE_TYPE cmock_line); +#define vkGetPrivateDataEXT_IgnoreArg_pData() vkGetPrivateDataEXT_CMockIgnoreArg_pData(__LINE__) +void vkGetPrivateDataEXT_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line); +#define vkGetDescriptorSetLayoutSizeEXT_Ignore() vkGetDescriptorSetLayoutSizeEXT_CMockIgnore() +void vkGetDescriptorSetLayoutSizeEXT_CMockIgnore(void); +#define vkGetDescriptorSetLayoutSizeEXT_StopIgnore() vkGetDescriptorSetLayoutSizeEXT_CMockStopIgnore() +void vkGetDescriptorSetLayoutSizeEXT_CMockStopIgnore(void); +#define vkGetDescriptorSetLayoutSizeEXT_ExpectAnyArgs() vkGetDescriptorSetLayoutSizeEXT_CMockExpectAnyArgs(__LINE__) +void vkGetDescriptorSetLayoutSizeEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetDescriptorSetLayoutSizeEXT_Expect(device, layout, pLayoutSizeInBytes) vkGetDescriptorSetLayoutSizeEXT_CMockExpect(__LINE__, device, layout, pLayoutSizeInBytes) +void vkGetDescriptorSetLayoutSizeEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize* pLayoutSizeInBytes); +typedef void (* CMOCK_vkGetDescriptorSetLayoutSizeEXT_CALLBACK)(VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize* pLayoutSizeInBytes, int cmock_num_calls); +void vkGetDescriptorSetLayoutSizeEXT_AddCallback(CMOCK_vkGetDescriptorSetLayoutSizeEXT_CALLBACK Callback); +void vkGetDescriptorSetLayoutSizeEXT_Stub(CMOCK_vkGetDescriptorSetLayoutSizeEXT_CALLBACK Callback); +#define vkGetDescriptorSetLayoutSizeEXT_StubWithCallback vkGetDescriptorSetLayoutSizeEXT_AddCallback +#define vkGetDescriptorSetLayoutSizeEXT_ReturnThruPtr_pLayoutSizeInBytes(pLayoutSizeInBytes) vkGetDescriptorSetLayoutSizeEXT_CMockReturnMemThruPtr_pLayoutSizeInBytes(__LINE__, pLayoutSizeInBytes, sizeof(VkDeviceSize)) +#define vkGetDescriptorSetLayoutSizeEXT_ReturnArrayThruPtr_pLayoutSizeInBytes(pLayoutSizeInBytes, cmock_len) vkGetDescriptorSetLayoutSizeEXT_CMockReturnMemThruPtr_pLayoutSizeInBytes(__LINE__, pLayoutSizeInBytes, cmock_len * sizeof(*pLayoutSizeInBytes)) +#define vkGetDescriptorSetLayoutSizeEXT_ReturnMemThruPtr_pLayoutSizeInBytes(pLayoutSizeInBytes, cmock_size) vkGetDescriptorSetLayoutSizeEXT_CMockReturnMemThruPtr_pLayoutSizeInBytes(__LINE__, pLayoutSizeInBytes, cmock_size) +void vkGetDescriptorSetLayoutSizeEXT_CMockReturnMemThruPtr_pLayoutSizeInBytes(UNITY_LINE_TYPE cmock_line, VkDeviceSize const* pLayoutSizeInBytes, size_t cmock_size); +#define vkGetDescriptorSetLayoutSizeEXT_IgnoreArg_device() vkGetDescriptorSetLayoutSizeEXT_CMockIgnoreArg_device(__LINE__) +void vkGetDescriptorSetLayoutSizeEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetDescriptorSetLayoutSizeEXT_IgnoreArg_layout() vkGetDescriptorSetLayoutSizeEXT_CMockIgnoreArg_layout(__LINE__) +void vkGetDescriptorSetLayoutSizeEXT_CMockIgnoreArg_layout(UNITY_LINE_TYPE cmock_line); +#define vkGetDescriptorSetLayoutSizeEXT_IgnoreArg_pLayoutSizeInBytes() vkGetDescriptorSetLayoutSizeEXT_CMockIgnoreArg_pLayoutSizeInBytes(__LINE__) +void vkGetDescriptorSetLayoutSizeEXT_CMockIgnoreArg_pLayoutSizeInBytes(UNITY_LINE_TYPE cmock_line); +#define vkGetDescriptorSetLayoutBindingOffsetEXT_Ignore() vkGetDescriptorSetLayoutBindingOffsetEXT_CMockIgnore() +void vkGetDescriptorSetLayoutBindingOffsetEXT_CMockIgnore(void); +#define vkGetDescriptorSetLayoutBindingOffsetEXT_StopIgnore() vkGetDescriptorSetLayoutBindingOffsetEXT_CMockStopIgnore() +void vkGetDescriptorSetLayoutBindingOffsetEXT_CMockStopIgnore(void); +#define vkGetDescriptorSetLayoutBindingOffsetEXT_ExpectAnyArgs() vkGetDescriptorSetLayoutBindingOffsetEXT_CMockExpectAnyArgs(__LINE__) +void vkGetDescriptorSetLayoutBindingOffsetEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetDescriptorSetLayoutBindingOffsetEXT_Expect(device, layout, binding, pOffset) vkGetDescriptorSetLayoutBindingOffsetEXT_CMockExpect(__LINE__, device, layout, binding, pOffset) +void vkGetDescriptorSetLayoutBindingOffsetEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize* pOffset); +typedef void (* CMOCK_vkGetDescriptorSetLayoutBindingOffsetEXT_CALLBACK)(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize* pOffset, int cmock_num_calls); +void vkGetDescriptorSetLayoutBindingOffsetEXT_AddCallback(CMOCK_vkGetDescriptorSetLayoutBindingOffsetEXT_CALLBACK Callback); +void vkGetDescriptorSetLayoutBindingOffsetEXT_Stub(CMOCK_vkGetDescriptorSetLayoutBindingOffsetEXT_CALLBACK Callback); +#define vkGetDescriptorSetLayoutBindingOffsetEXT_StubWithCallback vkGetDescriptorSetLayoutBindingOffsetEXT_AddCallback +#define vkGetDescriptorSetLayoutBindingOffsetEXT_ReturnThruPtr_pOffset(pOffset) vkGetDescriptorSetLayoutBindingOffsetEXT_CMockReturnMemThruPtr_pOffset(__LINE__, pOffset, sizeof(VkDeviceSize)) +#define vkGetDescriptorSetLayoutBindingOffsetEXT_ReturnArrayThruPtr_pOffset(pOffset, cmock_len) vkGetDescriptorSetLayoutBindingOffsetEXT_CMockReturnMemThruPtr_pOffset(__LINE__, pOffset, cmock_len * sizeof(*pOffset)) +#define vkGetDescriptorSetLayoutBindingOffsetEXT_ReturnMemThruPtr_pOffset(pOffset, cmock_size) vkGetDescriptorSetLayoutBindingOffsetEXT_CMockReturnMemThruPtr_pOffset(__LINE__, pOffset, cmock_size) +void vkGetDescriptorSetLayoutBindingOffsetEXT_CMockReturnMemThruPtr_pOffset(UNITY_LINE_TYPE cmock_line, VkDeviceSize const* pOffset, size_t cmock_size); +#define vkGetDescriptorSetLayoutBindingOffsetEXT_IgnoreArg_device() vkGetDescriptorSetLayoutBindingOffsetEXT_CMockIgnoreArg_device(__LINE__) +void vkGetDescriptorSetLayoutBindingOffsetEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetDescriptorSetLayoutBindingOffsetEXT_IgnoreArg_layout() vkGetDescriptorSetLayoutBindingOffsetEXT_CMockIgnoreArg_layout(__LINE__) +void vkGetDescriptorSetLayoutBindingOffsetEXT_CMockIgnoreArg_layout(UNITY_LINE_TYPE cmock_line); +#define vkGetDescriptorSetLayoutBindingOffsetEXT_IgnoreArg_binding() vkGetDescriptorSetLayoutBindingOffsetEXT_CMockIgnoreArg_binding(__LINE__) +void vkGetDescriptorSetLayoutBindingOffsetEXT_CMockIgnoreArg_binding(UNITY_LINE_TYPE cmock_line); +#define vkGetDescriptorSetLayoutBindingOffsetEXT_IgnoreArg_pOffset() vkGetDescriptorSetLayoutBindingOffsetEXT_CMockIgnoreArg_pOffset(__LINE__) +void vkGetDescriptorSetLayoutBindingOffsetEXT_CMockIgnoreArg_pOffset(UNITY_LINE_TYPE cmock_line); +#define vkGetDescriptorEXT_Ignore() vkGetDescriptorEXT_CMockIgnore() +void vkGetDescriptorEXT_CMockIgnore(void); +#define vkGetDescriptorEXT_StopIgnore() vkGetDescriptorEXT_CMockStopIgnore() +void vkGetDescriptorEXT_CMockStopIgnore(void); +#define vkGetDescriptorEXT_ExpectAnyArgs() vkGetDescriptorEXT_CMockExpectAnyArgs(__LINE__) +void vkGetDescriptorEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetDescriptorEXT_Expect(device, pDescriptorInfo, dataSize, pDescriptor) vkGetDescriptorEXT_CMockExpect(__LINE__, device, pDescriptorInfo, dataSize, pDescriptor) +void vkGetDescriptorEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, void* pDescriptor); +typedef void (* CMOCK_vkGetDescriptorEXT_CALLBACK)(VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, void* pDescriptor, int cmock_num_calls); +void vkGetDescriptorEXT_AddCallback(CMOCK_vkGetDescriptorEXT_CALLBACK Callback); +void vkGetDescriptorEXT_Stub(CMOCK_vkGetDescriptorEXT_CALLBACK Callback); +#define vkGetDescriptorEXT_StubWithCallback vkGetDescriptorEXT_AddCallback +#define vkGetDescriptorEXT_ReturnThruPtr_pDescriptor(pDescriptor) vkGetDescriptorEXT_CMockReturnMemThruPtr_pDescriptor(__LINE__, pDescriptor, sizeof(*pDescriptor)) +#define vkGetDescriptorEXT_ReturnArrayThruPtr_pDescriptor(pDescriptor, cmock_len) vkGetDescriptorEXT_CMockReturnMemThruPtr_pDescriptor(__LINE__, pDescriptor, cmock_len * sizeof(*pDescriptor)) +#define vkGetDescriptorEXT_ReturnMemThruPtr_pDescriptor(pDescriptor, cmock_size) vkGetDescriptorEXT_CMockReturnMemThruPtr_pDescriptor(__LINE__, pDescriptor, cmock_size) +void vkGetDescriptorEXT_CMockReturnMemThruPtr_pDescriptor(UNITY_LINE_TYPE cmock_line, void const* pDescriptor, size_t cmock_size); +#define vkGetDescriptorEXT_IgnoreArg_device() vkGetDescriptorEXT_CMockIgnoreArg_device(__LINE__) +void vkGetDescriptorEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetDescriptorEXT_IgnoreArg_pDescriptorInfo() vkGetDescriptorEXT_CMockIgnoreArg_pDescriptorInfo(__LINE__) +void vkGetDescriptorEXT_CMockIgnoreArg_pDescriptorInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetDescriptorEXT_IgnoreArg_dataSize() vkGetDescriptorEXT_CMockIgnoreArg_dataSize(__LINE__) +void vkGetDescriptorEXT_CMockIgnoreArg_dataSize(UNITY_LINE_TYPE cmock_line); +#define vkGetDescriptorEXT_IgnoreArg_pDescriptor() vkGetDescriptorEXT_CMockIgnoreArg_pDescriptor(__LINE__) +void vkGetDescriptorEXT_CMockIgnoreArg_pDescriptor(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindDescriptorBuffersEXT_Ignore() vkCmdBindDescriptorBuffersEXT_CMockIgnore() +void vkCmdBindDescriptorBuffersEXT_CMockIgnore(void); +#define vkCmdBindDescriptorBuffersEXT_StopIgnore() vkCmdBindDescriptorBuffersEXT_CMockStopIgnore() +void vkCmdBindDescriptorBuffersEXT_CMockStopIgnore(void); +#define vkCmdBindDescriptorBuffersEXT_ExpectAnyArgs() vkCmdBindDescriptorBuffersEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdBindDescriptorBuffersEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindDescriptorBuffersEXT_Expect(commandBuffer, bufferCount, pBindingInfos) vkCmdBindDescriptorBuffersEXT_CMockExpect(__LINE__, commandBuffer, bufferCount, pBindingInfos) +void vkCmdBindDescriptorBuffersEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT* pBindingInfos); +typedef void (* CMOCK_vkCmdBindDescriptorBuffersEXT_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT* pBindingInfos, int cmock_num_calls); +void vkCmdBindDescriptorBuffersEXT_AddCallback(CMOCK_vkCmdBindDescriptorBuffersEXT_CALLBACK Callback); +void vkCmdBindDescriptorBuffersEXT_Stub(CMOCK_vkCmdBindDescriptorBuffersEXT_CALLBACK Callback); +#define vkCmdBindDescriptorBuffersEXT_StubWithCallback vkCmdBindDescriptorBuffersEXT_AddCallback +#define vkCmdBindDescriptorBuffersEXT_IgnoreArg_commandBuffer() vkCmdBindDescriptorBuffersEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBindDescriptorBuffersEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindDescriptorBuffersEXT_IgnoreArg_bufferCount() vkCmdBindDescriptorBuffersEXT_CMockIgnoreArg_bufferCount(__LINE__) +void vkCmdBindDescriptorBuffersEXT_CMockIgnoreArg_bufferCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindDescriptorBuffersEXT_IgnoreArg_pBindingInfos() vkCmdBindDescriptorBuffersEXT_CMockIgnoreArg_pBindingInfos(__LINE__) +void vkCmdBindDescriptorBuffersEXT_CMockIgnoreArg_pBindingInfos(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDescriptorBufferOffsetsEXT_Ignore() vkCmdSetDescriptorBufferOffsetsEXT_CMockIgnore() +void vkCmdSetDescriptorBufferOffsetsEXT_CMockIgnore(void); +#define vkCmdSetDescriptorBufferOffsetsEXT_StopIgnore() vkCmdSetDescriptorBufferOffsetsEXT_CMockStopIgnore() +void vkCmdSetDescriptorBufferOffsetsEXT_CMockStopIgnore(void); +#define vkCmdSetDescriptorBufferOffsetsEXT_ExpectAnyArgs() vkCmdSetDescriptorBufferOffsetsEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetDescriptorBufferOffsetsEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDescriptorBufferOffsetsEXT_Expect(commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets) vkCmdSetDescriptorBufferOffsetsEXT_CMockExpect(__LINE__, commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets) +void vkCmdSetDescriptorBufferOffsetsEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets); +typedef void (* CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets, int cmock_num_calls); +void vkCmdSetDescriptorBufferOffsetsEXT_AddCallback(CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALLBACK Callback); +void vkCmdSetDescriptorBufferOffsetsEXT_Stub(CMOCK_vkCmdSetDescriptorBufferOffsetsEXT_CALLBACK Callback); +#define vkCmdSetDescriptorBufferOffsetsEXT_StubWithCallback vkCmdSetDescriptorBufferOffsetsEXT_AddCallback +#define vkCmdSetDescriptorBufferOffsetsEXT_IgnoreArg_commandBuffer() vkCmdSetDescriptorBufferOffsetsEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetDescriptorBufferOffsetsEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDescriptorBufferOffsetsEXT_IgnoreArg_pipelineBindPoint() vkCmdSetDescriptorBufferOffsetsEXT_CMockIgnoreArg_pipelineBindPoint(__LINE__) +void vkCmdSetDescriptorBufferOffsetsEXT_CMockIgnoreArg_pipelineBindPoint(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDescriptorBufferOffsetsEXT_IgnoreArg_layout() vkCmdSetDescriptorBufferOffsetsEXT_CMockIgnoreArg_layout(__LINE__) +void vkCmdSetDescriptorBufferOffsetsEXT_CMockIgnoreArg_layout(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDescriptorBufferOffsetsEXT_IgnoreArg_firstSet() vkCmdSetDescriptorBufferOffsetsEXT_CMockIgnoreArg_firstSet(__LINE__) +void vkCmdSetDescriptorBufferOffsetsEXT_CMockIgnoreArg_firstSet(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDescriptorBufferOffsetsEXT_IgnoreArg_setCount() vkCmdSetDescriptorBufferOffsetsEXT_CMockIgnoreArg_setCount(__LINE__) +void vkCmdSetDescriptorBufferOffsetsEXT_CMockIgnoreArg_setCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDescriptorBufferOffsetsEXT_IgnoreArg_pBufferIndices() vkCmdSetDescriptorBufferOffsetsEXT_CMockIgnoreArg_pBufferIndices(__LINE__) +void vkCmdSetDescriptorBufferOffsetsEXT_CMockIgnoreArg_pBufferIndices(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDescriptorBufferOffsetsEXT_IgnoreArg_pOffsets() vkCmdSetDescriptorBufferOffsetsEXT_CMockIgnoreArg_pOffsets(__LINE__) +void vkCmdSetDescriptorBufferOffsetsEXT_CMockIgnoreArg_pOffsets(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindDescriptorBufferEmbeddedSamplersEXT_Ignore() vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CMockIgnore() +void vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CMockIgnore(void); +#define vkCmdBindDescriptorBufferEmbeddedSamplersEXT_StopIgnore() vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CMockStopIgnore() +void vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CMockStopIgnore(void); +#define vkCmdBindDescriptorBufferEmbeddedSamplersEXT_ExpectAnyArgs() vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindDescriptorBufferEmbeddedSamplersEXT_Expect(commandBuffer, pipelineBindPoint, layout, set) vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CMockExpect(__LINE__, commandBuffer, pipelineBindPoint, layout, set) +void vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set); +typedef void (* CMOCK_vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, int cmock_num_calls); +void vkCmdBindDescriptorBufferEmbeddedSamplersEXT_AddCallback(CMOCK_vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CALLBACK Callback); +void vkCmdBindDescriptorBufferEmbeddedSamplersEXT_Stub(CMOCK_vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CALLBACK Callback); +#define vkCmdBindDescriptorBufferEmbeddedSamplersEXT_StubWithCallback vkCmdBindDescriptorBufferEmbeddedSamplersEXT_AddCallback +#define vkCmdBindDescriptorBufferEmbeddedSamplersEXT_IgnoreArg_commandBuffer() vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindDescriptorBufferEmbeddedSamplersEXT_IgnoreArg_pipelineBindPoint() vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CMockIgnoreArg_pipelineBindPoint(__LINE__) +void vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CMockIgnoreArg_pipelineBindPoint(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindDescriptorBufferEmbeddedSamplersEXT_IgnoreArg_layout() vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CMockIgnoreArg_layout(__LINE__) +void vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CMockIgnoreArg_layout(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindDescriptorBufferEmbeddedSamplersEXT_IgnoreArg_set() vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CMockIgnoreArg_set(__LINE__) +void vkCmdBindDescriptorBufferEmbeddedSamplersEXT_CMockIgnoreArg_set(UNITY_LINE_TYPE cmock_line); +#define vkGetBufferOpaqueCaptureDescriptorDataEXT_IgnoreAndReturn(cmock_retval) vkGetBufferOpaqueCaptureDescriptorDataEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetBufferOpaqueCaptureDescriptorDataEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetBufferOpaqueCaptureDescriptorDataEXT_StopIgnore() vkGetBufferOpaqueCaptureDescriptorDataEXT_CMockStopIgnore() +void vkGetBufferOpaqueCaptureDescriptorDataEXT_CMockStopIgnore(void); +#define vkGetBufferOpaqueCaptureDescriptorDataEXT_ExpectAnyArgsAndReturn(cmock_retval) vkGetBufferOpaqueCaptureDescriptorDataEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetBufferOpaqueCaptureDescriptorDataEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetBufferOpaqueCaptureDescriptorDataEXT_ExpectAndReturn(device, pInfo, pData, cmock_retval) vkGetBufferOpaqueCaptureDescriptorDataEXT_CMockExpectAndReturn(__LINE__, device, pInfo, pData, cmock_retval) +void vkGetBufferOpaqueCaptureDescriptorDataEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT* pInfo, void* pData, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetBufferOpaqueCaptureDescriptorDataEXT_CALLBACK)(VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT* pInfo, void* pData, int cmock_num_calls); +void vkGetBufferOpaqueCaptureDescriptorDataEXT_AddCallback(CMOCK_vkGetBufferOpaqueCaptureDescriptorDataEXT_CALLBACK Callback); +void vkGetBufferOpaqueCaptureDescriptorDataEXT_Stub(CMOCK_vkGetBufferOpaqueCaptureDescriptorDataEXT_CALLBACK Callback); +#define vkGetBufferOpaqueCaptureDescriptorDataEXT_StubWithCallback vkGetBufferOpaqueCaptureDescriptorDataEXT_AddCallback +#define vkGetBufferOpaqueCaptureDescriptorDataEXT_ReturnThruPtr_pData(pData) vkGetBufferOpaqueCaptureDescriptorDataEXT_CMockReturnMemThruPtr_pData(__LINE__, pData, sizeof(*pData)) +#define vkGetBufferOpaqueCaptureDescriptorDataEXT_ReturnArrayThruPtr_pData(pData, cmock_len) vkGetBufferOpaqueCaptureDescriptorDataEXT_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_len * sizeof(*pData)) +#define vkGetBufferOpaqueCaptureDescriptorDataEXT_ReturnMemThruPtr_pData(pData, cmock_size) vkGetBufferOpaqueCaptureDescriptorDataEXT_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_size) +void vkGetBufferOpaqueCaptureDescriptorDataEXT_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, void const* pData, size_t cmock_size); +#define vkGetBufferOpaqueCaptureDescriptorDataEXT_IgnoreArg_device() vkGetBufferOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_device(__LINE__) +void vkGetBufferOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetBufferOpaqueCaptureDescriptorDataEXT_IgnoreArg_pInfo() vkGetBufferOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_pInfo(__LINE__) +void vkGetBufferOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetBufferOpaqueCaptureDescriptorDataEXT_IgnoreArg_pData() vkGetBufferOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_pData(__LINE__) +void vkGetBufferOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line); +#define vkGetImageOpaqueCaptureDescriptorDataEXT_IgnoreAndReturn(cmock_retval) vkGetImageOpaqueCaptureDescriptorDataEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetImageOpaqueCaptureDescriptorDataEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetImageOpaqueCaptureDescriptorDataEXT_StopIgnore() vkGetImageOpaqueCaptureDescriptorDataEXT_CMockStopIgnore() +void vkGetImageOpaqueCaptureDescriptorDataEXT_CMockStopIgnore(void); +#define vkGetImageOpaqueCaptureDescriptorDataEXT_ExpectAnyArgsAndReturn(cmock_retval) vkGetImageOpaqueCaptureDescriptorDataEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetImageOpaqueCaptureDescriptorDataEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetImageOpaqueCaptureDescriptorDataEXT_ExpectAndReturn(device, pInfo, pData, cmock_retval) vkGetImageOpaqueCaptureDescriptorDataEXT_CMockExpectAndReturn(__LINE__, device, pInfo, pData, cmock_retval) +void vkGetImageOpaqueCaptureDescriptorDataEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkImageCaptureDescriptorDataInfoEXT* pInfo, void* pData, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetImageOpaqueCaptureDescriptorDataEXT_CALLBACK)(VkDevice device, const VkImageCaptureDescriptorDataInfoEXT* pInfo, void* pData, int cmock_num_calls); +void vkGetImageOpaqueCaptureDescriptorDataEXT_AddCallback(CMOCK_vkGetImageOpaqueCaptureDescriptorDataEXT_CALLBACK Callback); +void vkGetImageOpaqueCaptureDescriptorDataEXT_Stub(CMOCK_vkGetImageOpaqueCaptureDescriptorDataEXT_CALLBACK Callback); +#define vkGetImageOpaqueCaptureDescriptorDataEXT_StubWithCallback vkGetImageOpaqueCaptureDescriptorDataEXT_AddCallback +#define vkGetImageOpaqueCaptureDescriptorDataEXT_ReturnThruPtr_pData(pData) vkGetImageOpaqueCaptureDescriptorDataEXT_CMockReturnMemThruPtr_pData(__LINE__, pData, sizeof(*pData)) +#define vkGetImageOpaqueCaptureDescriptorDataEXT_ReturnArrayThruPtr_pData(pData, cmock_len) vkGetImageOpaqueCaptureDescriptorDataEXT_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_len * sizeof(*pData)) +#define vkGetImageOpaqueCaptureDescriptorDataEXT_ReturnMemThruPtr_pData(pData, cmock_size) vkGetImageOpaqueCaptureDescriptorDataEXT_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_size) +void vkGetImageOpaqueCaptureDescriptorDataEXT_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, void const* pData, size_t cmock_size); +#define vkGetImageOpaqueCaptureDescriptorDataEXT_IgnoreArg_device() vkGetImageOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_device(__LINE__) +void vkGetImageOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetImageOpaqueCaptureDescriptorDataEXT_IgnoreArg_pInfo() vkGetImageOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_pInfo(__LINE__) +void vkGetImageOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetImageOpaqueCaptureDescriptorDataEXT_IgnoreArg_pData() vkGetImageOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_pData(__LINE__) +void vkGetImageOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line); +#define vkGetImageViewOpaqueCaptureDescriptorDataEXT_IgnoreAndReturn(cmock_retval) vkGetImageViewOpaqueCaptureDescriptorDataEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetImageViewOpaqueCaptureDescriptorDataEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetImageViewOpaqueCaptureDescriptorDataEXT_StopIgnore() vkGetImageViewOpaqueCaptureDescriptorDataEXT_CMockStopIgnore() +void vkGetImageViewOpaqueCaptureDescriptorDataEXT_CMockStopIgnore(void); +#define vkGetImageViewOpaqueCaptureDescriptorDataEXT_ExpectAnyArgsAndReturn(cmock_retval) vkGetImageViewOpaqueCaptureDescriptorDataEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetImageViewOpaqueCaptureDescriptorDataEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetImageViewOpaqueCaptureDescriptorDataEXT_ExpectAndReturn(device, pInfo, pData, cmock_retval) vkGetImageViewOpaqueCaptureDescriptorDataEXT_CMockExpectAndReturn(__LINE__, device, pInfo, pData, cmock_retval) +void vkGetImageViewOpaqueCaptureDescriptorDataEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetImageViewOpaqueCaptureDescriptorDataEXT_CALLBACK)(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData, int cmock_num_calls); +void vkGetImageViewOpaqueCaptureDescriptorDataEXT_AddCallback(CMOCK_vkGetImageViewOpaqueCaptureDescriptorDataEXT_CALLBACK Callback); +void vkGetImageViewOpaqueCaptureDescriptorDataEXT_Stub(CMOCK_vkGetImageViewOpaqueCaptureDescriptorDataEXT_CALLBACK Callback); +#define vkGetImageViewOpaqueCaptureDescriptorDataEXT_StubWithCallback vkGetImageViewOpaqueCaptureDescriptorDataEXT_AddCallback +#define vkGetImageViewOpaqueCaptureDescriptorDataEXT_ReturnThruPtr_pData(pData) vkGetImageViewOpaqueCaptureDescriptorDataEXT_CMockReturnMemThruPtr_pData(__LINE__, pData, sizeof(*pData)) +#define vkGetImageViewOpaqueCaptureDescriptorDataEXT_ReturnArrayThruPtr_pData(pData, cmock_len) vkGetImageViewOpaqueCaptureDescriptorDataEXT_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_len * sizeof(*pData)) +#define vkGetImageViewOpaqueCaptureDescriptorDataEXT_ReturnMemThruPtr_pData(pData, cmock_size) vkGetImageViewOpaqueCaptureDescriptorDataEXT_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_size) +void vkGetImageViewOpaqueCaptureDescriptorDataEXT_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, void const* pData, size_t cmock_size); +#define vkGetImageViewOpaqueCaptureDescriptorDataEXT_IgnoreArg_device() vkGetImageViewOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_device(__LINE__) +void vkGetImageViewOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetImageViewOpaqueCaptureDescriptorDataEXT_IgnoreArg_pInfo() vkGetImageViewOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_pInfo(__LINE__) +void vkGetImageViewOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetImageViewOpaqueCaptureDescriptorDataEXT_IgnoreArg_pData() vkGetImageViewOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_pData(__LINE__) +void vkGetImageViewOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line); +#define vkGetSamplerOpaqueCaptureDescriptorDataEXT_IgnoreAndReturn(cmock_retval) vkGetSamplerOpaqueCaptureDescriptorDataEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetSamplerOpaqueCaptureDescriptorDataEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetSamplerOpaqueCaptureDescriptorDataEXT_StopIgnore() vkGetSamplerOpaqueCaptureDescriptorDataEXT_CMockStopIgnore() +void vkGetSamplerOpaqueCaptureDescriptorDataEXT_CMockStopIgnore(void); +#define vkGetSamplerOpaqueCaptureDescriptorDataEXT_ExpectAnyArgsAndReturn(cmock_retval) vkGetSamplerOpaqueCaptureDescriptorDataEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetSamplerOpaqueCaptureDescriptorDataEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetSamplerOpaqueCaptureDescriptorDataEXT_ExpectAndReturn(device, pInfo, pData, cmock_retval) vkGetSamplerOpaqueCaptureDescriptorDataEXT_CMockExpectAndReturn(__LINE__, device, pInfo, pData, cmock_retval) +void vkGetSamplerOpaqueCaptureDescriptorDataEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, void* pData, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetSamplerOpaqueCaptureDescriptorDataEXT_CALLBACK)(VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, void* pData, int cmock_num_calls); +void vkGetSamplerOpaqueCaptureDescriptorDataEXT_AddCallback(CMOCK_vkGetSamplerOpaqueCaptureDescriptorDataEXT_CALLBACK Callback); +void vkGetSamplerOpaqueCaptureDescriptorDataEXT_Stub(CMOCK_vkGetSamplerOpaqueCaptureDescriptorDataEXT_CALLBACK Callback); +#define vkGetSamplerOpaqueCaptureDescriptorDataEXT_StubWithCallback vkGetSamplerOpaqueCaptureDescriptorDataEXT_AddCallback +#define vkGetSamplerOpaqueCaptureDescriptorDataEXT_ReturnThruPtr_pData(pData) vkGetSamplerOpaqueCaptureDescriptorDataEXT_CMockReturnMemThruPtr_pData(__LINE__, pData, sizeof(*pData)) +#define vkGetSamplerOpaqueCaptureDescriptorDataEXT_ReturnArrayThruPtr_pData(pData, cmock_len) vkGetSamplerOpaqueCaptureDescriptorDataEXT_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_len * sizeof(*pData)) +#define vkGetSamplerOpaqueCaptureDescriptorDataEXT_ReturnMemThruPtr_pData(pData, cmock_size) vkGetSamplerOpaqueCaptureDescriptorDataEXT_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_size) +void vkGetSamplerOpaqueCaptureDescriptorDataEXT_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, void const* pData, size_t cmock_size); +#define vkGetSamplerOpaqueCaptureDescriptorDataEXT_IgnoreArg_device() vkGetSamplerOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_device(__LINE__) +void vkGetSamplerOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetSamplerOpaqueCaptureDescriptorDataEXT_IgnoreArg_pInfo() vkGetSamplerOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_pInfo(__LINE__) +void vkGetSamplerOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetSamplerOpaqueCaptureDescriptorDataEXT_IgnoreArg_pData() vkGetSamplerOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_pData(__LINE__) +void vkGetSamplerOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line); +#define vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_IgnoreAndReturn(cmock_retval) vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_StopIgnore() vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CMockStopIgnore() +void vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CMockStopIgnore(void); +#define vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_ExpectAnyArgsAndReturn(cmock_retval) vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_ExpectAndReturn(device, pInfo, pData, cmock_retval) vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CMockExpectAndReturn(__LINE__, device, pInfo, pData, cmock_retval) +void vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CALLBACK)(VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData, int cmock_num_calls); +void vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_AddCallback(CMOCK_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CALLBACK Callback); +void vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_Stub(CMOCK_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CALLBACK Callback); +#define vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_StubWithCallback vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_AddCallback +#define vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_ReturnThruPtr_pData(pData) vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CMockReturnMemThruPtr_pData(__LINE__, pData, sizeof(*pData)) +#define vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_ReturnArrayThruPtr_pData(pData, cmock_len) vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_len * sizeof(*pData)) +#define vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_ReturnMemThruPtr_pData(pData, cmock_size) vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_size) +void vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, void const* pData, size_t cmock_size); +#define vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_IgnoreArg_device() vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_device(__LINE__) +void vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_IgnoreArg_pInfo() vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_pInfo(__LINE__) +void vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_IgnoreArg_pData() vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_pData(__LINE__) +void vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetFragmentShadingRateEnumNV_Ignore() vkCmdSetFragmentShadingRateEnumNV_CMockIgnore() +void vkCmdSetFragmentShadingRateEnumNV_CMockIgnore(void); +#define vkCmdSetFragmentShadingRateEnumNV_StopIgnore() vkCmdSetFragmentShadingRateEnumNV_CMockStopIgnore() +void vkCmdSetFragmentShadingRateEnumNV_CMockStopIgnore(void); +#define vkCmdSetFragmentShadingRateEnumNV_ExpectAnyArgs() vkCmdSetFragmentShadingRateEnumNV_CMockExpectAnyArgs(__LINE__) +void vkCmdSetFragmentShadingRateEnumNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetFragmentShadingRateEnumNV_Expect(commandBuffer, shadingRate, combinerOps) vkCmdSetFragmentShadingRateEnumNV_CMockExpect(__LINE__, commandBuffer, shadingRate, combinerOps) +void vkCmdSetFragmentShadingRateEnumNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR* combinerOps); +typedef void (* CMOCK_vkCmdSetFragmentShadingRateEnumNV_CALLBACK)(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR* combinerOps, int cmock_num_calls); +void vkCmdSetFragmentShadingRateEnumNV_AddCallback(CMOCK_vkCmdSetFragmentShadingRateEnumNV_CALLBACK Callback); +void vkCmdSetFragmentShadingRateEnumNV_Stub(CMOCK_vkCmdSetFragmentShadingRateEnumNV_CALLBACK Callback); +#define vkCmdSetFragmentShadingRateEnumNV_StubWithCallback vkCmdSetFragmentShadingRateEnumNV_AddCallback +#define vkCmdSetFragmentShadingRateEnumNV_IgnoreArg_commandBuffer() vkCmdSetFragmentShadingRateEnumNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetFragmentShadingRateEnumNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetFragmentShadingRateEnumNV_IgnoreArg_shadingRate() vkCmdSetFragmentShadingRateEnumNV_CMockIgnoreArg_shadingRate(__LINE__) +void vkCmdSetFragmentShadingRateEnumNV_CMockIgnoreArg_shadingRate(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetFragmentShadingRateEnumNV_IgnoreArg_combinerOps() vkCmdSetFragmentShadingRateEnumNV_CMockIgnoreArg_combinerOps(__LINE__) +void vkCmdSetFragmentShadingRateEnumNV_CMockIgnoreArg_combinerOps(UNITY_LINE_TYPE cmock_line); +#define vkGetImageSubresourceLayout2EXT_Ignore() vkGetImageSubresourceLayout2EXT_CMockIgnore() +void vkGetImageSubresourceLayout2EXT_CMockIgnore(void); +#define vkGetImageSubresourceLayout2EXT_StopIgnore() vkGetImageSubresourceLayout2EXT_CMockStopIgnore() +void vkGetImageSubresourceLayout2EXT_CMockStopIgnore(void); +#define vkGetImageSubresourceLayout2EXT_ExpectAnyArgs() vkGetImageSubresourceLayout2EXT_CMockExpectAnyArgs(__LINE__) +void vkGetImageSubresourceLayout2EXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetImageSubresourceLayout2EXT_Expect(device, image, pSubresource, pLayout) vkGetImageSubresourceLayout2EXT_CMockExpect(__LINE__, device, image, pSubresource, pLayout) +void vkGetImageSubresourceLayout2EXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkImage image, const VkImageSubresource2EXT* pSubresource, VkSubresourceLayout2EXT* pLayout); +typedef void (* CMOCK_vkGetImageSubresourceLayout2EXT_CALLBACK)(VkDevice device, VkImage image, const VkImageSubresource2EXT* pSubresource, VkSubresourceLayout2EXT* pLayout, int cmock_num_calls); +void vkGetImageSubresourceLayout2EXT_AddCallback(CMOCK_vkGetImageSubresourceLayout2EXT_CALLBACK Callback); +void vkGetImageSubresourceLayout2EXT_Stub(CMOCK_vkGetImageSubresourceLayout2EXT_CALLBACK Callback); +#define vkGetImageSubresourceLayout2EXT_StubWithCallback vkGetImageSubresourceLayout2EXT_AddCallback +#define vkGetImageSubresourceLayout2EXT_ReturnThruPtr_pLayout(pLayout) vkGetImageSubresourceLayout2EXT_CMockReturnMemThruPtr_pLayout(__LINE__, pLayout, sizeof(VkSubresourceLayout2EXT)) +#define vkGetImageSubresourceLayout2EXT_ReturnArrayThruPtr_pLayout(pLayout, cmock_len) vkGetImageSubresourceLayout2EXT_CMockReturnMemThruPtr_pLayout(__LINE__, pLayout, cmock_len * sizeof(*pLayout)) +#define vkGetImageSubresourceLayout2EXT_ReturnMemThruPtr_pLayout(pLayout, cmock_size) vkGetImageSubresourceLayout2EXT_CMockReturnMemThruPtr_pLayout(__LINE__, pLayout, cmock_size) +void vkGetImageSubresourceLayout2EXT_CMockReturnMemThruPtr_pLayout(UNITY_LINE_TYPE cmock_line, VkSubresourceLayout2EXT const* pLayout, size_t cmock_size); +#define vkGetImageSubresourceLayout2EXT_IgnoreArg_device() vkGetImageSubresourceLayout2EXT_CMockIgnoreArg_device(__LINE__) +void vkGetImageSubresourceLayout2EXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetImageSubresourceLayout2EXT_IgnoreArg_image() vkGetImageSubresourceLayout2EXT_CMockIgnoreArg_image(__LINE__) +void vkGetImageSubresourceLayout2EXT_CMockIgnoreArg_image(UNITY_LINE_TYPE cmock_line); +#define vkGetImageSubresourceLayout2EXT_IgnoreArg_pSubresource() vkGetImageSubresourceLayout2EXT_CMockIgnoreArg_pSubresource(__LINE__) +void vkGetImageSubresourceLayout2EXT_CMockIgnoreArg_pSubresource(UNITY_LINE_TYPE cmock_line); +#define vkGetImageSubresourceLayout2EXT_IgnoreArg_pLayout() vkGetImageSubresourceLayout2EXT_CMockIgnoreArg_pLayout(__LINE__) +void vkGetImageSubresourceLayout2EXT_CMockIgnoreArg_pLayout(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceFaultInfoEXT_IgnoreAndReturn(cmock_retval) vkGetDeviceFaultInfoEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetDeviceFaultInfoEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetDeviceFaultInfoEXT_StopIgnore() vkGetDeviceFaultInfoEXT_CMockStopIgnore() +void vkGetDeviceFaultInfoEXT_CMockStopIgnore(void); +#define vkGetDeviceFaultInfoEXT_ExpectAnyArgsAndReturn(cmock_retval) vkGetDeviceFaultInfoEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetDeviceFaultInfoEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetDeviceFaultInfoEXT_ExpectAndReturn(device, pFaultCounts, pFaultInfo, cmock_retval) vkGetDeviceFaultInfoEXT_CMockExpectAndReturn(__LINE__, device, pFaultCounts, pFaultInfo, cmock_retval) +void vkGetDeviceFaultInfoEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetDeviceFaultInfoEXT_CALLBACK)(VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo, int cmock_num_calls); +void vkGetDeviceFaultInfoEXT_AddCallback(CMOCK_vkGetDeviceFaultInfoEXT_CALLBACK Callback); +void vkGetDeviceFaultInfoEXT_Stub(CMOCK_vkGetDeviceFaultInfoEXT_CALLBACK Callback); +#define vkGetDeviceFaultInfoEXT_StubWithCallback vkGetDeviceFaultInfoEXT_AddCallback +#define vkGetDeviceFaultInfoEXT_ReturnThruPtr_pFaultCounts(pFaultCounts) vkGetDeviceFaultInfoEXT_CMockReturnMemThruPtr_pFaultCounts(__LINE__, pFaultCounts, sizeof(VkDeviceFaultCountsEXT)) +#define vkGetDeviceFaultInfoEXT_ReturnArrayThruPtr_pFaultCounts(pFaultCounts, cmock_len) vkGetDeviceFaultInfoEXT_CMockReturnMemThruPtr_pFaultCounts(__LINE__, pFaultCounts, cmock_len * sizeof(*pFaultCounts)) +#define vkGetDeviceFaultInfoEXT_ReturnMemThruPtr_pFaultCounts(pFaultCounts, cmock_size) vkGetDeviceFaultInfoEXT_CMockReturnMemThruPtr_pFaultCounts(__LINE__, pFaultCounts, cmock_size) +void vkGetDeviceFaultInfoEXT_CMockReturnMemThruPtr_pFaultCounts(UNITY_LINE_TYPE cmock_line, VkDeviceFaultCountsEXT const* pFaultCounts, size_t cmock_size); +#define vkGetDeviceFaultInfoEXT_ReturnThruPtr_pFaultInfo(pFaultInfo) vkGetDeviceFaultInfoEXT_CMockReturnMemThruPtr_pFaultInfo(__LINE__, pFaultInfo, sizeof(VkDeviceFaultInfoEXT)) +#define vkGetDeviceFaultInfoEXT_ReturnArrayThruPtr_pFaultInfo(pFaultInfo, cmock_len) vkGetDeviceFaultInfoEXT_CMockReturnMemThruPtr_pFaultInfo(__LINE__, pFaultInfo, cmock_len * sizeof(*pFaultInfo)) +#define vkGetDeviceFaultInfoEXT_ReturnMemThruPtr_pFaultInfo(pFaultInfo, cmock_size) vkGetDeviceFaultInfoEXT_CMockReturnMemThruPtr_pFaultInfo(__LINE__, pFaultInfo, cmock_size) +void vkGetDeviceFaultInfoEXT_CMockReturnMemThruPtr_pFaultInfo(UNITY_LINE_TYPE cmock_line, VkDeviceFaultInfoEXT const* pFaultInfo, size_t cmock_size); +#define vkGetDeviceFaultInfoEXT_IgnoreArg_device() vkGetDeviceFaultInfoEXT_CMockIgnoreArg_device(__LINE__) +void vkGetDeviceFaultInfoEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceFaultInfoEXT_IgnoreArg_pFaultCounts() vkGetDeviceFaultInfoEXT_CMockIgnoreArg_pFaultCounts(__LINE__) +void vkGetDeviceFaultInfoEXT_CMockIgnoreArg_pFaultCounts(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceFaultInfoEXT_IgnoreArg_pFaultInfo() vkGetDeviceFaultInfoEXT_CMockIgnoreArg_pFaultInfo(__LINE__) +void vkGetDeviceFaultInfoEXT_CMockIgnoreArg_pFaultInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetVertexInputEXT_Ignore() vkCmdSetVertexInputEXT_CMockIgnore() +void vkCmdSetVertexInputEXT_CMockIgnore(void); +#define vkCmdSetVertexInputEXT_StopIgnore() vkCmdSetVertexInputEXT_CMockStopIgnore() +void vkCmdSetVertexInputEXT_CMockStopIgnore(void); +#define vkCmdSetVertexInputEXT_ExpectAnyArgs() vkCmdSetVertexInputEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetVertexInputEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetVertexInputEXT_Expect(commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions) vkCmdSetVertexInputEXT_CMockExpect(__LINE__, commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions) +void vkCmdSetVertexInputEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions); +typedef void (* CMOCK_vkCmdSetVertexInputEXT_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions, int cmock_num_calls); +void vkCmdSetVertexInputEXT_AddCallback(CMOCK_vkCmdSetVertexInputEXT_CALLBACK Callback); +void vkCmdSetVertexInputEXT_Stub(CMOCK_vkCmdSetVertexInputEXT_CALLBACK Callback); +#define vkCmdSetVertexInputEXT_StubWithCallback vkCmdSetVertexInputEXT_AddCallback +#define vkCmdSetVertexInputEXT_IgnoreArg_commandBuffer() vkCmdSetVertexInputEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetVertexInputEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetVertexInputEXT_IgnoreArg_vertexBindingDescriptionCount() vkCmdSetVertexInputEXT_CMockIgnoreArg_vertexBindingDescriptionCount(__LINE__) +void vkCmdSetVertexInputEXT_CMockIgnoreArg_vertexBindingDescriptionCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetVertexInputEXT_IgnoreArg_pVertexBindingDescriptions() vkCmdSetVertexInputEXT_CMockIgnoreArg_pVertexBindingDescriptions(__LINE__) +void vkCmdSetVertexInputEXT_CMockIgnoreArg_pVertexBindingDescriptions(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetVertexInputEXT_IgnoreArg_vertexAttributeDescriptionCount() vkCmdSetVertexInputEXT_CMockIgnoreArg_vertexAttributeDescriptionCount(__LINE__) +void vkCmdSetVertexInputEXT_CMockIgnoreArg_vertexAttributeDescriptionCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetVertexInputEXT_IgnoreArg_pVertexAttributeDescriptions() vkCmdSetVertexInputEXT_CMockIgnoreArg_pVertexAttributeDescriptions(__LINE__) +void vkCmdSetVertexInputEXT_CMockIgnoreArg_pVertexAttributeDescriptions(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_IgnoreAndReturn(cmock_retval) vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_StopIgnore() vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CMockStopIgnore() +void vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CMockStopIgnore(void); +#define vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_ExpectAnyArgsAndReturn(cmock_retval) vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_ExpectAndReturn(device, renderpass, pMaxWorkgroupSize, cmock_retval) vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CMockExpectAndReturn(__LINE__, device, renderpass, pMaxWorkgroupSize, cmock_retval) +void vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CALLBACK)(VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize, int cmock_num_calls); +void vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_AddCallback(CMOCK_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CALLBACK Callback); +void vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_Stub(CMOCK_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CALLBACK Callback); +#define vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_StubWithCallback vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_AddCallback +#define vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_ReturnThruPtr_pMaxWorkgroupSize(pMaxWorkgroupSize) vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CMockReturnMemThruPtr_pMaxWorkgroupSize(__LINE__, pMaxWorkgroupSize, sizeof(VkExtent2D)) +#define vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_ReturnArrayThruPtr_pMaxWorkgroupSize(pMaxWorkgroupSize, cmock_len) vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CMockReturnMemThruPtr_pMaxWorkgroupSize(__LINE__, pMaxWorkgroupSize, cmock_len * sizeof(*pMaxWorkgroupSize)) +#define vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_ReturnMemThruPtr_pMaxWorkgroupSize(pMaxWorkgroupSize, cmock_size) vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CMockReturnMemThruPtr_pMaxWorkgroupSize(__LINE__, pMaxWorkgroupSize, cmock_size) +void vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CMockReturnMemThruPtr_pMaxWorkgroupSize(UNITY_LINE_TYPE cmock_line, VkExtent2D const* pMaxWorkgroupSize, size_t cmock_size); +#define vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_IgnoreArg_device() vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CMockIgnoreArg_device(__LINE__) +void vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_IgnoreArg_renderpass() vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CMockIgnoreArg_renderpass(__LINE__) +void vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CMockIgnoreArg_renderpass(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_IgnoreArg_pMaxWorkgroupSize() vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CMockIgnoreArg_pMaxWorkgroupSize(__LINE__) +void vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_CMockIgnoreArg_pMaxWorkgroupSize(UNITY_LINE_TYPE cmock_line); +#define vkCmdSubpassShadingHUAWEI_Ignore() vkCmdSubpassShadingHUAWEI_CMockIgnore() +void vkCmdSubpassShadingHUAWEI_CMockIgnore(void); +#define vkCmdSubpassShadingHUAWEI_StopIgnore() vkCmdSubpassShadingHUAWEI_CMockStopIgnore() +void vkCmdSubpassShadingHUAWEI_CMockStopIgnore(void); +#define vkCmdSubpassShadingHUAWEI_ExpectAnyArgs() vkCmdSubpassShadingHUAWEI_CMockExpectAnyArgs(__LINE__) +void vkCmdSubpassShadingHUAWEI_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSubpassShadingHUAWEI_Expect(commandBuffer) vkCmdSubpassShadingHUAWEI_CMockExpect(__LINE__, commandBuffer) +void vkCmdSubpassShadingHUAWEI_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer); +typedef void (* CMOCK_vkCmdSubpassShadingHUAWEI_CALLBACK)(VkCommandBuffer commandBuffer, int cmock_num_calls); +void vkCmdSubpassShadingHUAWEI_AddCallback(CMOCK_vkCmdSubpassShadingHUAWEI_CALLBACK Callback); +void vkCmdSubpassShadingHUAWEI_Stub(CMOCK_vkCmdSubpassShadingHUAWEI_CALLBACK Callback); +#define vkCmdSubpassShadingHUAWEI_StubWithCallback vkCmdSubpassShadingHUAWEI_AddCallback +#define vkCmdSubpassShadingHUAWEI_IgnoreArg_commandBuffer() vkCmdSubpassShadingHUAWEI_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSubpassShadingHUAWEI_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindInvocationMaskHUAWEI_Ignore() vkCmdBindInvocationMaskHUAWEI_CMockIgnore() +void vkCmdBindInvocationMaskHUAWEI_CMockIgnore(void); +#define vkCmdBindInvocationMaskHUAWEI_StopIgnore() vkCmdBindInvocationMaskHUAWEI_CMockStopIgnore() +void vkCmdBindInvocationMaskHUAWEI_CMockStopIgnore(void); +#define vkCmdBindInvocationMaskHUAWEI_ExpectAnyArgs() vkCmdBindInvocationMaskHUAWEI_CMockExpectAnyArgs(__LINE__) +void vkCmdBindInvocationMaskHUAWEI_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindInvocationMaskHUAWEI_Expect(commandBuffer, imageView, imageLayout) vkCmdBindInvocationMaskHUAWEI_CMockExpect(__LINE__, commandBuffer, imageView, imageLayout) +void vkCmdBindInvocationMaskHUAWEI_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout); +typedef void (* CMOCK_vkCmdBindInvocationMaskHUAWEI_CALLBACK)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout, int cmock_num_calls); +void vkCmdBindInvocationMaskHUAWEI_AddCallback(CMOCK_vkCmdBindInvocationMaskHUAWEI_CALLBACK Callback); +void vkCmdBindInvocationMaskHUAWEI_Stub(CMOCK_vkCmdBindInvocationMaskHUAWEI_CALLBACK Callback); +#define vkCmdBindInvocationMaskHUAWEI_StubWithCallback vkCmdBindInvocationMaskHUAWEI_AddCallback +#define vkCmdBindInvocationMaskHUAWEI_IgnoreArg_commandBuffer() vkCmdBindInvocationMaskHUAWEI_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBindInvocationMaskHUAWEI_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindInvocationMaskHUAWEI_IgnoreArg_imageView() vkCmdBindInvocationMaskHUAWEI_CMockIgnoreArg_imageView(__LINE__) +void vkCmdBindInvocationMaskHUAWEI_CMockIgnoreArg_imageView(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindInvocationMaskHUAWEI_IgnoreArg_imageLayout() vkCmdBindInvocationMaskHUAWEI_CMockIgnoreArg_imageLayout(__LINE__) +void vkCmdBindInvocationMaskHUAWEI_CMockIgnoreArg_imageLayout(UNITY_LINE_TYPE cmock_line); +#define vkGetMemoryRemoteAddressNV_IgnoreAndReturn(cmock_retval) vkGetMemoryRemoteAddressNV_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetMemoryRemoteAddressNV_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetMemoryRemoteAddressNV_StopIgnore() vkGetMemoryRemoteAddressNV_CMockStopIgnore() +void vkGetMemoryRemoteAddressNV_CMockStopIgnore(void); +#define vkGetMemoryRemoteAddressNV_ExpectAnyArgsAndReturn(cmock_retval) vkGetMemoryRemoteAddressNV_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetMemoryRemoteAddressNV_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetMemoryRemoteAddressNV_ExpectAndReturn(device, pMemoryGetRemoteAddressInfo, pAddress, cmock_retval) vkGetMemoryRemoteAddressNV_CMockExpectAndReturn(__LINE__, device, pMemoryGetRemoteAddressInfo, pAddress, cmock_retval) +void vkGetMemoryRemoteAddressNV_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetMemoryRemoteAddressNV_CALLBACK)(VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress, int cmock_num_calls); +void vkGetMemoryRemoteAddressNV_AddCallback(CMOCK_vkGetMemoryRemoteAddressNV_CALLBACK Callback); +void vkGetMemoryRemoteAddressNV_Stub(CMOCK_vkGetMemoryRemoteAddressNV_CALLBACK Callback); +#define vkGetMemoryRemoteAddressNV_StubWithCallback vkGetMemoryRemoteAddressNV_AddCallback +#define vkGetMemoryRemoteAddressNV_ReturnThruPtr_pAddress(pAddress) vkGetMemoryRemoteAddressNV_CMockReturnMemThruPtr_pAddress(__LINE__, pAddress, sizeof(VkRemoteAddressNV)) +#define vkGetMemoryRemoteAddressNV_ReturnArrayThruPtr_pAddress(pAddress, cmock_len) vkGetMemoryRemoteAddressNV_CMockReturnMemThruPtr_pAddress(__LINE__, pAddress, cmock_len * sizeof(*pAddress)) +#define vkGetMemoryRemoteAddressNV_ReturnMemThruPtr_pAddress(pAddress, cmock_size) vkGetMemoryRemoteAddressNV_CMockReturnMemThruPtr_pAddress(__LINE__, pAddress, cmock_size) +void vkGetMemoryRemoteAddressNV_CMockReturnMemThruPtr_pAddress(UNITY_LINE_TYPE cmock_line, VkRemoteAddressNV const* pAddress, size_t cmock_size); +#define vkGetMemoryRemoteAddressNV_IgnoreArg_device() vkGetMemoryRemoteAddressNV_CMockIgnoreArg_device(__LINE__) +void vkGetMemoryRemoteAddressNV_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetMemoryRemoteAddressNV_IgnoreArg_pMemoryGetRemoteAddressInfo() vkGetMemoryRemoteAddressNV_CMockIgnoreArg_pMemoryGetRemoteAddressInfo(__LINE__) +void vkGetMemoryRemoteAddressNV_CMockIgnoreArg_pMemoryGetRemoteAddressInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetMemoryRemoteAddressNV_IgnoreArg_pAddress() vkGetMemoryRemoteAddressNV_CMockIgnoreArg_pAddress(__LINE__) +void vkGetMemoryRemoteAddressNV_CMockIgnoreArg_pAddress(UNITY_LINE_TYPE cmock_line); +#define vkGetPipelinePropertiesEXT_IgnoreAndReturn(cmock_retval) vkGetPipelinePropertiesEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPipelinePropertiesEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPipelinePropertiesEXT_StopIgnore() vkGetPipelinePropertiesEXT_CMockStopIgnore() +void vkGetPipelinePropertiesEXT_CMockStopIgnore(void); +#define vkGetPipelinePropertiesEXT_ExpectAnyArgsAndReturn(cmock_retval) vkGetPipelinePropertiesEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPipelinePropertiesEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPipelinePropertiesEXT_ExpectAndReturn(device, pPipelineInfo, pPipelineProperties, cmock_retval) vkGetPipelinePropertiesEXT_CMockExpectAndReturn(__LINE__, device, pPipelineInfo, pPipelineProperties, cmock_retval) +void vkGetPipelinePropertiesEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPipelinePropertiesEXT_CALLBACK)(VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties, int cmock_num_calls); +void vkGetPipelinePropertiesEXT_AddCallback(CMOCK_vkGetPipelinePropertiesEXT_CALLBACK Callback); +void vkGetPipelinePropertiesEXT_Stub(CMOCK_vkGetPipelinePropertiesEXT_CALLBACK Callback); +#define vkGetPipelinePropertiesEXT_StubWithCallback vkGetPipelinePropertiesEXT_AddCallback +#define vkGetPipelinePropertiesEXT_ReturnThruPtr_pPipelineProperties(pPipelineProperties) vkGetPipelinePropertiesEXT_CMockReturnMemThruPtr_pPipelineProperties(__LINE__, pPipelineProperties, sizeof(VkBaseOutStructure)) +#define vkGetPipelinePropertiesEXT_ReturnArrayThruPtr_pPipelineProperties(pPipelineProperties, cmock_len) vkGetPipelinePropertiesEXT_CMockReturnMemThruPtr_pPipelineProperties(__LINE__, pPipelineProperties, cmock_len * sizeof(*pPipelineProperties)) +#define vkGetPipelinePropertiesEXT_ReturnMemThruPtr_pPipelineProperties(pPipelineProperties, cmock_size) vkGetPipelinePropertiesEXT_CMockReturnMemThruPtr_pPipelineProperties(__LINE__, pPipelineProperties, cmock_size) +void vkGetPipelinePropertiesEXT_CMockReturnMemThruPtr_pPipelineProperties(UNITY_LINE_TYPE cmock_line, VkBaseOutStructure const* pPipelineProperties, size_t cmock_size); +#define vkGetPipelinePropertiesEXT_IgnoreArg_device() vkGetPipelinePropertiesEXT_CMockIgnoreArg_device(__LINE__) +void vkGetPipelinePropertiesEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetPipelinePropertiesEXT_IgnoreArg_pPipelineInfo() vkGetPipelinePropertiesEXT_CMockIgnoreArg_pPipelineInfo(__LINE__) +void vkGetPipelinePropertiesEXT_CMockIgnoreArg_pPipelineInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetPipelinePropertiesEXT_IgnoreArg_pPipelineProperties() vkGetPipelinePropertiesEXT_CMockIgnoreArg_pPipelineProperties(__LINE__) +void vkGetPipelinePropertiesEXT_CMockIgnoreArg_pPipelineProperties(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetPatchControlPointsEXT_Ignore() vkCmdSetPatchControlPointsEXT_CMockIgnore() +void vkCmdSetPatchControlPointsEXT_CMockIgnore(void); +#define vkCmdSetPatchControlPointsEXT_StopIgnore() vkCmdSetPatchControlPointsEXT_CMockStopIgnore() +void vkCmdSetPatchControlPointsEXT_CMockStopIgnore(void); +#define vkCmdSetPatchControlPointsEXT_ExpectAnyArgs() vkCmdSetPatchControlPointsEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetPatchControlPointsEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetPatchControlPointsEXT_Expect(commandBuffer, patchControlPoints) vkCmdSetPatchControlPointsEXT_CMockExpect(__LINE__, commandBuffer, patchControlPoints) +void vkCmdSetPatchControlPointsEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t patchControlPoints); +typedef void (* CMOCK_vkCmdSetPatchControlPointsEXT_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t patchControlPoints, int cmock_num_calls); +void vkCmdSetPatchControlPointsEXT_AddCallback(CMOCK_vkCmdSetPatchControlPointsEXT_CALLBACK Callback); +void vkCmdSetPatchControlPointsEXT_Stub(CMOCK_vkCmdSetPatchControlPointsEXT_CALLBACK Callback); +#define vkCmdSetPatchControlPointsEXT_StubWithCallback vkCmdSetPatchControlPointsEXT_AddCallback +#define vkCmdSetPatchControlPointsEXT_IgnoreArg_commandBuffer() vkCmdSetPatchControlPointsEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetPatchControlPointsEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetPatchControlPointsEXT_IgnoreArg_patchControlPoints() vkCmdSetPatchControlPointsEXT_CMockIgnoreArg_patchControlPoints(__LINE__) +void vkCmdSetPatchControlPointsEXT_CMockIgnoreArg_patchControlPoints(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetRasterizerDiscardEnableEXT_Ignore() vkCmdSetRasterizerDiscardEnableEXT_CMockIgnore() +void vkCmdSetRasterizerDiscardEnableEXT_CMockIgnore(void); +#define vkCmdSetRasterizerDiscardEnableEXT_StopIgnore() vkCmdSetRasterizerDiscardEnableEXT_CMockStopIgnore() +void vkCmdSetRasterizerDiscardEnableEXT_CMockStopIgnore(void); +#define vkCmdSetRasterizerDiscardEnableEXT_ExpectAnyArgs() vkCmdSetRasterizerDiscardEnableEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetRasterizerDiscardEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetRasterizerDiscardEnableEXT_Expect(commandBuffer, rasterizerDiscardEnable) vkCmdSetRasterizerDiscardEnableEXT_CMockExpect(__LINE__, commandBuffer, rasterizerDiscardEnable) +void vkCmdSetRasterizerDiscardEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); +typedef void (* CMOCK_vkCmdSetRasterizerDiscardEnableEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable, int cmock_num_calls); +void vkCmdSetRasterizerDiscardEnableEXT_AddCallback(CMOCK_vkCmdSetRasterizerDiscardEnableEXT_CALLBACK Callback); +void vkCmdSetRasterizerDiscardEnableEXT_Stub(CMOCK_vkCmdSetRasterizerDiscardEnableEXT_CALLBACK Callback); +#define vkCmdSetRasterizerDiscardEnableEXT_StubWithCallback vkCmdSetRasterizerDiscardEnableEXT_AddCallback +#define vkCmdSetRasterizerDiscardEnableEXT_IgnoreArg_commandBuffer() vkCmdSetRasterizerDiscardEnableEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetRasterizerDiscardEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetRasterizerDiscardEnableEXT_IgnoreArg_rasterizerDiscardEnable() vkCmdSetRasterizerDiscardEnableEXT_CMockIgnoreArg_rasterizerDiscardEnable(__LINE__) +void vkCmdSetRasterizerDiscardEnableEXT_CMockIgnoreArg_rasterizerDiscardEnable(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthBiasEnableEXT_Ignore() vkCmdSetDepthBiasEnableEXT_CMockIgnore() +void vkCmdSetDepthBiasEnableEXT_CMockIgnore(void); +#define vkCmdSetDepthBiasEnableEXT_StopIgnore() vkCmdSetDepthBiasEnableEXT_CMockStopIgnore() +void vkCmdSetDepthBiasEnableEXT_CMockStopIgnore(void); +#define vkCmdSetDepthBiasEnableEXT_ExpectAnyArgs() vkCmdSetDepthBiasEnableEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetDepthBiasEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthBiasEnableEXT_Expect(commandBuffer, depthBiasEnable) vkCmdSetDepthBiasEnableEXT_CMockExpect(__LINE__, commandBuffer, depthBiasEnable) +void vkCmdSetDepthBiasEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable); +typedef void (* CMOCK_vkCmdSetDepthBiasEnableEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable, int cmock_num_calls); +void vkCmdSetDepthBiasEnableEXT_AddCallback(CMOCK_vkCmdSetDepthBiasEnableEXT_CALLBACK Callback); +void vkCmdSetDepthBiasEnableEXT_Stub(CMOCK_vkCmdSetDepthBiasEnableEXT_CALLBACK Callback); +#define vkCmdSetDepthBiasEnableEXT_StubWithCallback vkCmdSetDepthBiasEnableEXT_AddCallback +#define vkCmdSetDepthBiasEnableEXT_IgnoreArg_commandBuffer() vkCmdSetDepthBiasEnableEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetDepthBiasEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthBiasEnableEXT_IgnoreArg_depthBiasEnable() vkCmdSetDepthBiasEnableEXT_CMockIgnoreArg_depthBiasEnable(__LINE__) +void vkCmdSetDepthBiasEnableEXT_CMockIgnoreArg_depthBiasEnable(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetLogicOpEXT_Ignore() vkCmdSetLogicOpEXT_CMockIgnore() +void vkCmdSetLogicOpEXT_CMockIgnore(void); +#define vkCmdSetLogicOpEXT_StopIgnore() vkCmdSetLogicOpEXT_CMockStopIgnore() +void vkCmdSetLogicOpEXT_CMockStopIgnore(void); +#define vkCmdSetLogicOpEXT_ExpectAnyArgs() vkCmdSetLogicOpEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetLogicOpEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetLogicOpEXT_Expect(commandBuffer, logicOp) vkCmdSetLogicOpEXT_CMockExpect(__LINE__, commandBuffer, logicOp) +void vkCmdSetLogicOpEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkLogicOp logicOp); +typedef void (* CMOCK_vkCmdSetLogicOpEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkLogicOp logicOp, int cmock_num_calls); +void vkCmdSetLogicOpEXT_AddCallback(CMOCK_vkCmdSetLogicOpEXT_CALLBACK Callback); +void vkCmdSetLogicOpEXT_Stub(CMOCK_vkCmdSetLogicOpEXT_CALLBACK Callback); +#define vkCmdSetLogicOpEXT_StubWithCallback vkCmdSetLogicOpEXT_AddCallback +#define vkCmdSetLogicOpEXT_IgnoreArg_commandBuffer() vkCmdSetLogicOpEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetLogicOpEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetLogicOpEXT_IgnoreArg_logicOp() vkCmdSetLogicOpEXT_CMockIgnoreArg_logicOp(__LINE__) +void vkCmdSetLogicOpEXT_CMockIgnoreArg_logicOp(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetPrimitiveRestartEnableEXT_Ignore() vkCmdSetPrimitiveRestartEnableEXT_CMockIgnore() +void vkCmdSetPrimitiveRestartEnableEXT_CMockIgnore(void); +#define vkCmdSetPrimitiveRestartEnableEXT_StopIgnore() vkCmdSetPrimitiveRestartEnableEXT_CMockStopIgnore() +void vkCmdSetPrimitiveRestartEnableEXT_CMockStopIgnore(void); +#define vkCmdSetPrimitiveRestartEnableEXT_ExpectAnyArgs() vkCmdSetPrimitiveRestartEnableEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetPrimitiveRestartEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetPrimitiveRestartEnableEXT_Expect(commandBuffer, primitiveRestartEnable) vkCmdSetPrimitiveRestartEnableEXT_CMockExpect(__LINE__, commandBuffer, primitiveRestartEnable) +void vkCmdSetPrimitiveRestartEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); +typedef void (* CMOCK_vkCmdSetPrimitiveRestartEnableEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable, int cmock_num_calls); +void vkCmdSetPrimitiveRestartEnableEXT_AddCallback(CMOCK_vkCmdSetPrimitiveRestartEnableEXT_CALLBACK Callback); +void vkCmdSetPrimitiveRestartEnableEXT_Stub(CMOCK_vkCmdSetPrimitiveRestartEnableEXT_CALLBACK Callback); +#define vkCmdSetPrimitiveRestartEnableEXT_StubWithCallback vkCmdSetPrimitiveRestartEnableEXT_AddCallback +#define vkCmdSetPrimitiveRestartEnableEXT_IgnoreArg_commandBuffer() vkCmdSetPrimitiveRestartEnableEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetPrimitiveRestartEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetPrimitiveRestartEnableEXT_IgnoreArg_primitiveRestartEnable() vkCmdSetPrimitiveRestartEnableEXT_CMockIgnoreArg_primitiveRestartEnable(__LINE__) +void vkCmdSetPrimitiveRestartEnableEXT_CMockIgnoreArg_primitiveRestartEnable(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetColorWriteEnableEXT_Ignore() vkCmdSetColorWriteEnableEXT_CMockIgnore() +void vkCmdSetColorWriteEnableEXT_CMockIgnore(void); +#define vkCmdSetColorWriteEnableEXT_StopIgnore() vkCmdSetColorWriteEnableEXT_CMockStopIgnore() +void vkCmdSetColorWriteEnableEXT_CMockStopIgnore(void); +#define vkCmdSetColorWriteEnableEXT_ExpectAnyArgs() vkCmdSetColorWriteEnableEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetColorWriteEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetColorWriteEnableEXT_Expect(commandBuffer, attachmentCount, pColorWriteEnables) vkCmdSetColorWriteEnableEXT_CMockExpect(__LINE__, commandBuffer, attachmentCount, pColorWriteEnables) +void vkCmdSetColorWriteEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables); +typedef void (* CMOCK_vkCmdSetColorWriteEnableEXT_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables, int cmock_num_calls); +void vkCmdSetColorWriteEnableEXT_AddCallback(CMOCK_vkCmdSetColorWriteEnableEXT_CALLBACK Callback); +void vkCmdSetColorWriteEnableEXT_Stub(CMOCK_vkCmdSetColorWriteEnableEXT_CALLBACK Callback); +#define vkCmdSetColorWriteEnableEXT_StubWithCallback vkCmdSetColorWriteEnableEXT_AddCallback +#define vkCmdSetColorWriteEnableEXT_IgnoreArg_commandBuffer() vkCmdSetColorWriteEnableEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetColorWriteEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetColorWriteEnableEXT_IgnoreArg_attachmentCount() vkCmdSetColorWriteEnableEXT_CMockIgnoreArg_attachmentCount(__LINE__) +void vkCmdSetColorWriteEnableEXT_CMockIgnoreArg_attachmentCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetColorWriteEnableEXT_IgnoreArg_pColorWriteEnables() vkCmdSetColorWriteEnableEXT_CMockIgnoreArg_pColorWriteEnables(__LINE__) +void vkCmdSetColorWriteEnableEXT_CMockIgnoreArg_pColorWriteEnables(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMultiEXT_Ignore() vkCmdDrawMultiEXT_CMockIgnore() +void vkCmdDrawMultiEXT_CMockIgnore(void); +#define vkCmdDrawMultiEXT_StopIgnore() vkCmdDrawMultiEXT_CMockStopIgnore() +void vkCmdDrawMultiEXT_CMockStopIgnore(void); +#define vkCmdDrawMultiEXT_ExpectAnyArgs() vkCmdDrawMultiEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdDrawMultiEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMultiEXT_Expect(commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride) vkCmdDrawMultiEXT_CMockExpect(__LINE__, commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride) +void vkCmdDrawMultiEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride); +typedef void (* CMOCK_vkCmdDrawMultiEXT_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, int cmock_num_calls); +void vkCmdDrawMultiEXT_AddCallback(CMOCK_vkCmdDrawMultiEXT_CALLBACK Callback); +void vkCmdDrawMultiEXT_Stub(CMOCK_vkCmdDrawMultiEXT_CALLBACK Callback); +#define vkCmdDrawMultiEXT_StubWithCallback vkCmdDrawMultiEXT_AddCallback +#define vkCmdDrawMultiEXT_IgnoreArg_commandBuffer() vkCmdDrawMultiEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDrawMultiEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMultiEXT_IgnoreArg_drawCount() vkCmdDrawMultiEXT_CMockIgnoreArg_drawCount(__LINE__) +void vkCmdDrawMultiEXT_CMockIgnoreArg_drawCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMultiEXT_IgnoreArg_pVertexInfo() vkCmdDrawMultiEXT_CMockIgnoreArg_pVertexInfo(__LINE__) +void vkCmdDrawMultiEXT_CMockIgnoreArg_pVertexInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMultiEXT_IgnoreArg_instanceCount() vkCmdDrawMultiEXT_CMockIgnoreArg_instanceCount(__LINE__) +void vkCmdDrawMultiEXT_CMockIgnoreArg_instanceCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMultiEXT_IgnoreArg_firstInstance() vkCmdDrawMultiEXT_CMockIgnoreArg_firstInstance(__LINE__) +void vkCmdDrawMultiEXT_CMockIgnoreArg_firstInstance(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMultiEXT_IgnoreArg_stride() vkCmdDrawMultiEXT_CMockIgnoreArg_stride(__LINE__) +void vkCmdDrawMultiEXT_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMultiIndexedEXT_Ignore() vkCmdDrawMultiIndexedEXT_CMockIgnore() +void vkCmdDrawMultiIndexedEXT_CMockIgnore(void); +#define vkCmdDrawMultiIndexedEXT_StopIgnore() vkCmdDrawMultiIndexedEXT_CMockStopIgnore() +void vkCmdDrawMultiIndexedEXT_CMockStopIgnore(void); +#define vkCmdDrawMultiIndexedEXT_ExpectAnyArgs() vkCmdDrawMultiIndexedEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdDrawMultiIndexedEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMultiIndexedEXT_Expect(commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset) vkCmdDrawMultiIndexedEXT_CMockExpect(__LINE__, commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset) +void vkCmdDrawMultiIndexedEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset); +typedef void (* CMOCK_vkCmdDrawMultiIndexedEXT_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset, int cmock_num_calls); +void vkCmdDrawMultiIndexedEXT_AddCallback(CMOCK_vkCmdDrawMultiIndexedEXT_CALLBACK Callback); +void vkCmdDrawMultiIndexedEXT_Stub(CMOCK_vkCmdDrawMultiIndexedEXT_CALLBACK Callback); +#define vkCmdDrawMultiIndexedEXT_StubWithCallback vkCmdDrawMultiIndexedEXT_AddCallback +#define vkCmdDrawMultiIndexedEXT_IgnoreArg_commandBuffer() vkCmdDrawMultiIndexedEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDrawMultiIndexedEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMultiIndexedEXT_IgnoreArg_drawCount() vkCmdDrawMultiIndexedEXT_CMockIgnoreArg_drawCount(__LINE__) +void vkCmdDrawMultiIndexedEXT_CMockIgnoreArg_drawCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMultiIndexedEXT_IgnoreArg_pIndexInfo() vkCmdDrawMultiIndexedEXT_CMockIgnoreArg_pIndexInfo(__LINE__) +void vkCmdDrawMultiIndexedEXT_CMockIgnoreArg_pIndexInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMultiIndexedEXT_IgnoreArg_instanceCount() vkCmdDrawMultiIndexedEXT_CMockIgnoreArg_instanceCount(__LINE__) +void vkCmdDrawMultiIndexedEXT_CMockIgnoreArg_instanceCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMultiIndexedEXT_IgnoreArg_firstInstance() vkCmdDrawMultiIndexedEXT_CMockIgnoreArg_firstInstance(__LINE__) +void vkCmdDrawMultiIndexedEXT_CMockIgnoreArg_firstInstance(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMultiIndexedEXT_IgnoreArg_stride() vkCmdDrawMultiIndexedEXT_CMockIgnoreArg_stride(__LINE__) +void vkCmdDrawMultiIndexedEXT_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMultiIndexedEXT_IgnoreArg_pVertexOffset() vkCmdDrawMultiIndexedEXT_CMockIgnoreArg_pVertexOffset(__LINE__) +void vkCmdDrawMultiIndexedEXT_CMockIgnoreArg_pVertexOffset(UNITY_LINE_TYPE cmock_line); +#define vkCreateMicromapEXT_IgnoreAndReturn(cmock_retval) vkCreateMicromapEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateMicromapEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateMicromapEXT_StopIgnore() vkCreateMicromapEXT_CMockStopIgnore() +void vkCreateMicromapEXT_CMockStopIgnore(void); +#define vkCreateMicromapEXT_ExpectAnyArgsAndReturn(cmock_retval) vkCreateMicromapEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateMicromapEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateMicromapEXT_ExpectAndReturn(device, pCreateInfo, pAllocator, pMicromap, cmock_retval) vkCreateMicromapEXT_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pMicromap, cmock_retval) +void vkCreateMicromapEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateMicromapEXT_CALLBACK)(VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap, int cmock_num_calls); +void vkCreateMicromapEXT_AddCallback(CMOCK_vkCreateMicromapEXT_CALLBACK Callback); +void vkCreateMicromapEXT_Stub(CMOCK_vkCreateMicromapEXT_CALLBACK Callback); +#define vkCreateMicromapEXT_StubWithCallback vkCreateMicromapEXT_AddCallback +#define vkCreateMicromapEXT_ReturnThruPtr_pMicromap(pMicromap) vkCreateMicromapEXT_CMockReturnMemThruPtr_pMicromap(__LINE__, pMicromap, sizeof(VkMicromapEXT)) +#define vkCreateMicromapEXT_ReturnArrayThruPtr_pMicromap(pMicromap, cmock_len) vkCreateMicromapEXT_CMockReturnMemThruPtr_pMicromap(__LINE__, pMicromap, cmock_len * sizeof(*pMicromap)) +#define vkCreateMicromapEXT_ReturnMemThruPtr_pMicromap(pMicromap, cmock_size) vkCreateMicromapEXT_CMockReturnMemThruPtr_pMicromap(__LINE__, pMicromap, cmock_size) +void vkCreateMicromapEXT_CMockReturnMemThruPtr_pMicromap(UNITY_LINE_TYPE cmock_line, VkMicromapEXT const* pMicromap, size_t cmock_size); +#define vkCreateMicromapEXT_IgnoreArg_device() vkCreateMicromapEXT_CMockIgnoreArg_device(__LINE__) +void vkCreateMicromapEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateMicromapEXT_IgnoreArg_pCreateInfo() vkCreateMicromapEXT_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateMicromapEXT_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateMicromapEXT_IgnoreArg_pAllocator() vkCreateMicromapEXT_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateMicromapEXT_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateMicromapEXT_IgnoreArg_pMicromap() vkCreateMicromapEXT_CMockIgnoreArg_pMicromap(__LINE__) +void vkCreateMicromapEXT_CMockIgnoreArg_pMicromap(UNITY_LINE_TYPE cmock_line); +#define vkDestroyMicromapEXT_Ignore() vkDestroyMicromapEXT_CMockIgnore() +void vkDestroyMicromapEXT_CMockIgnore(void); +#define vkDestroyMicromapEXT_StopIgnore() vkDestroyMicromapEXT_CMockStopIgnore() +void vkDestroyMicromapEXT_CMockStopIgnore(void); +#define vkDestroyMicromapEXT_ExpectAnyArgs() vkDestroyMicromapEXT_CMockExpectAnyArgs(__LINE__) +void vkDestroyMicromapEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyMicromapEXT_Expect(device, micromap, pAllocator) vkDestroyMicromapEXT_CMockExpect(__LINE__, device, micromap, pAllocator) +void vkDestroyMicromapEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyMicromapEXT_CALLBACK)(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyMicromapEXT_AddCallback(CMOCK_vkDestroyMicromapEXT_CALLBACK Callback); +void vkDestroyMicromapEXT_Stub(CMOCK_vkDestroyMicromapEXT_CALLBACK Callback); +#define vkDestroyMicromapEXT_StubWithCallback vkDestroyMicromapEXT_AddCallback +#define vkDestroyMicromapEXT_IgnoreArg_device() vkDestroyMicromapEXT_CMockIgnoreArg_device(__LINE__) +void vkDestroyMicromapEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyMicromapEXT_IgnoreArg_micromap() vkDestroyMicromapEXT_CMockIgnoreArg_micromap(__LINE__) +void vkDestroyMicromapEXT_CMockIgnoreArg_micromap(UNITY_LINE_TYPE cmock_line); +#define vkDestroyMicromapEXT_IgnoreArg_pAllocator() vkDestroyMicromapEXT_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyMicromapEXT_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCmdBuildMicromapsEXT_Ignore() vkCmdBuildMicromapsEXT_CMockIgnore() +void vkCmdBuildMicromapsEXT_CMockIgnore(void); +#define vkCmdBuildMicromapsEXT_StopIgnore() vkCmdBuildMicromapsEXT_CMockStopIgnore() +void vkCmdBuildMicromapsEXT_CMockStopIgnore(void); +#define vkCmdBuildMicromapsEXT_ExpectAnyArgs() vkCmdBuildMicromapsEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdBuildMicromapsEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBuildMicromapsEXT_Expect(commandBuffer, infoCount, pInfos) vkCmdBuildMicromapsEXT_CMockExpect(__LINE__, commandBuffer, infoCount, pInfos) +void vkCmdBuildMicromapsEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos); +typedef void (* CMOCK_vkCmdBuildMicromapsEXT_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos, int cmock_num_calls); +void vkCmdBuildMicromapsEXT_AddCallback(CMOCK_vkCmdBuildMicromapsEXT_CALLBACK Callback); +void vkCmdBuildMicromapsEXT_Stub(CMOCK_vkCmdBuildMicromapsEXT_CALLBACK Callback); +#define vkCmdBuildMicromapsEXT_StubWithCallback vkCmdBuildMicromapsEXT_AddCallback +#define vkCmdBuildMicromapsEXT_IgnoreArg_commandBuffer() vkCmdBuildMicromapsEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBuildMicromapsEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBuildMicromapsEXT_IgnoreArg_infoCount() vkCmdBuildMicromapsEXT_CMockIgnoreArg_infoCount(__LINE__) +void vkCmdBuildMicromapsEXT_CMockIgnoreArg_infoCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdBuildMicromapsEXT_IgnoreArg_pInfos() vkCmdBuildMicromapsEXT_CMockIgnoreArg_pInfos(__LINE__) +void vkCmdBuildMicromapsEXT_CMockIgnoreArg_pInfos(UNITY_LINE_TYPE cmock_line); +#define vkBuildMicromapsEXT_IgnoreAndReturn(cmock_retval) vkBuildMicromapsEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkBuildMicromapsEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkBuildMicromapsEXT_StopIgnore() vkBuildMicromapsEXT_CMockStopIgnore() +void vkBuildMicromapsEXT_CMockStopIgnore(void); +#define vkBuildMicromapsEXT_ExpectAnyArgsAndReturn(cmock_retval) vkBuildMicromapsEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkBuildMicromapsEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkBuildMicromapsEXT_ExpectAndReturn(device, deferredOperation, infoCount, pInfos, cmock_retval) vkBuildMicromapsEXT_CMockExpectAndReturn(__LINE__, device, deferredOperation, infoCount, pInfos, cmock_retval) +void vkBuildMicromapsEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkBuildMicromapsEXT_CALLBACK)(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos, int cmock_num_calls); +void vkBuildMicromapsEXT_AddCallback(CMOCK_vkBuildMicromapsEXT_CALLBACK Callback); +void vkBuildMicromapsEXT_Stub(CMOCK_vkBuildMicromapsEXT_CALLBACK Callback); +#define vkBuildMicromapsEXT_StubWithCallback vkBuildMicromapsEXT_AddCallback +#define vkBuildMicromapsEXT_IgnoreArg_device() vkBuildMicromapsEXT_CMockIgnoreArg_device(__LINE__) +void vkBuildMicromapsEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkBuildMicromapsEXT_IgnoreArg_deferredOperation() vkBuildMicromapsEXT_CMockIgnoreArg_deferredOperation(__LINE__) +void vkBuildMicromapsEXT_CMockIgnoreArg_deferredOperation(UNITY_LINE_TYPE cmock_line); +#define vkBuildMicromapsEXT_IgnoreArg_infoCount() vkBuildMicromapsEXT_CMockIgnoreArg_infoCount(__LINE__) +void vkBuildMicromapsEXT_CMockIgnoreArg_infoCount(UNITY_LINE_TYPE cmock_line); +#define vkBuildMicromapsEXT_IgnoreArg_pInfos() vkBuildMicromapsEXT_CMockIgnoreArg_pInfos(__LINE__) +void vkBuildMicromapsEXT_CMockIgnoreArg_pInfos(UNITY_LINE_TYPE cmock_line); +#define vkCopyMicromapEXT_IgnoreAndReturn(cmock_retval) vkCopyMicromapEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCopyMicromapEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCopyMicromapEXT_StopIgnore() vkCopyMicromapEXT_CMockStopIgnore() +void vkCopyMicromapEXT_CMockStopIgnore(void); +#define vkCopyMicromapEXT_ExpectAnyArgsAndReturn(cmock_retval) vkCopyMicromapEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCopyMicromapEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCopyMicromapEXT_ExpectAndReturn(device, deferredOperation, pInfo, cmock_retval) vkCopyMicromapEXT_CMockExpectAndReturn(__LINE__, device, deferredOperation, pInfo, cmock_retval) +void vkCopyMicromapEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCopyMicromapEXT_CALLBACK)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo, int cmock_num_calls); +void vkCopyMicromapEXT_AddCallback(CMOCK_vkCopyMicromapEXT_CALLBACK Callback); +void vkCopyMicromapEXT_Stub(CMOCK_vkCopyMicromapEXT_CALLBACK Callback); +#define vkCopyMicromapEXT_StubWithCallback vkCopyMicromapEXT_AddCallback +#define vkCopyMicromapEXT_IgnoreArg_device() vkCopyMicromapEXT_CMockIgnoreArg_device(__LINE__) +void vkCopyMicromapEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCopyMicromapEXT_IgnoreArg_deferredOperation() vkCopyMicromapEXT_CMockIgnoreArg_deferredOperation(__LINE__) +void vkCopyMicromapEXT_CMockIgnoreArg_deferredOperation(UNITY_LINE_TYPE cmock_line); +#define vkCopyMicromapEXT_IgnoreArg_pInfo() vkCopyMicromapEXT_CMockIgnoreArg_pInfo(__LINE__) +void vkCopyMicromapEXT_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkCopyMicromapToMemoryEXT_IgnoreAndReturn(cmock_retval) vkCopyMicromapToMemoryEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCopyMicromapToMemoryEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCopyMicromapToMemoryEXT_StopIgnore() vkCopyMicromapToMemoryEXT_CMockStopIgnore() +void vkCopyMicromapToMemoryEXT_CMockStopIgnore(void); +#define vkCopyMicromapToMemoryEXT_ExpectAnyArgsAndReturn(cmock_retval) vkCopyMicromapToMemoryEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCopyMicromapToMemoryEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCopyMicromapToMemoryEXT_ExpectAndReturn(device, deferredOperation, pInfo, cmock_retval) vkCopyMicromapToMemoryEXT_CMockExpectAndReturn(__LINE__, device, deferredOperation, pInfo, cmock_retval) +void vkCopyMicromapToMemoryEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCopyMicromapToMemoryEXT_CALLBACK)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo, int cmock_num_calls); +void vkCopyMicromapToMemoryEXT_AddCallback(CMOCK_vkCopyMicromapToMemoryEXT_CALLBACK Callback); +void vkCopyMicromapToMemoryEXT_Stub(CMOCK_vkCopyMicromapToMemoryEXT_CALLBACK Callback); +#define vkCopyMicromapToMemoryEXT_StubWithCallback vkCopyMicromapToMemoryEXT_AddCallback +#define vkCopyMicromapToMemoryEXT_IgnoreArg_device() vkCopyMicromapToMemoryEXT_CMockIgnoreArg_device(__LINE__) +void vkCopyMicromapToMemoryEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCopyMicromapToMemoryEXT_IgnoreArg_deferredOperation() vkCopyMicromapToMemoryEXT_CMockIgnoreArg_deferredOperation(__LINE__) +void vkCopyMicromapToMemoryEXT_CMockIgnoreArg_deferredOperation(UNITY_LINE_TYPE cmock_line); +#define vkCopyMicromapToMemoryEXT_IgnoreArg_pInfo() vkCopyMicromapToMemoryEXT_CMockIgnoreArg_pInfo(__LINE__) +void vkCopyMicromapToMemoryEXT_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkCopyMemoryToMicromapEXT_IgnoreAndReturn(cmock_retval) vkCopyMemoryToMicromapEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCopyMemoryToMicromapEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCopyMemoryToMicromapEXT_StopIgnore() vkCopyMemoryToMicromapEXT_CMockStopIgnore() +void vkCopyMemoryToMicromapEXT_CMockStopIgnore(void); +#define vkCopyMemoryToMicromapEXT_ExpectAnyArgsAndReturn(cmock_retval) vkCopyMemoryToMicromapEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCopyMemoryToMicromapEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCopyMemoryToMicromapEXT_ExpectAndReturn(device, deferredOperation, pInfo, cmock_retval) vkCopyMemoryToMicromapEXT_CMockExpectAndReturn(__LINE__, device, deferredOperation, pInfo, cmock_retval) +void vkCopyMemoryToMicromapEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCopyMemoryToMicromapEXT_CALLBACK)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo, int cmock_num_calls); +void vkCopyMemoryToMicromapEXT_AddCallback(CMOCK_vkCopyMemoryToMicromapEXT_CALLBACK Callback); +void vkCopyMemoryToMicromapEXT_Stub(CMOCK_vkCopyMemoryToMicromapEXT_CALLBACK Callback); +#define vkCopyMemoryToMicromapEXT_StubWithCallback vkCopyMemoryToMicromapEXT_AddCallback +#define vkCopyMemoryToMicromapEXT_IgnoreArg_device() vkCopyMemoryToMicromapEXT_CMockIgnoreArg_device(__LINE__) +void vkCopyMemoryToMicromapEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCopyMemoryToMicromapEXT_IgnoreArg_deferredOperation() vkCopyMemoryToMicromapEXT_CMockIgnoreArg_deferredOperation(__LINE__) +void vkCopyMemoryToMicromapEXT_CMockIgnoreArg_deferredOperation(UNITY_LINE_TYPE cmock_line); +#define vkCopyMemoryToMicromapEXT_IgnoreArg_pInfo() vkCopyMemoryToMicromapEXT_CMockIgnoreArg_pInfo(__LINE__) +void vkCopyMemoryToMicromapEXT_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkWriteMicromapsPropertiesEXT_IgnoreAndReturn(cmock_retval) vkWriteMicromapsPropertiesEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkWriteMicromapsPropertiesEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkWriteMicromapsPropertiesEXT_StopIgnore() vkWriteMicromapsPropertiesEXT_CMockStopIgnore() +void vkWriteMicromapsPropertiesEXT_CMockStopIgnore(void); +#define vkWriteMicromapsPropertiesEXT_ExpectAnyArgsAndReturn(cmock_retval) vkWriteMicromapsPropertiesEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkWriteMicromapsPropertiesEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkWriteMicromapsPropertiesEXT_ExpectAndReturn(device, micromapCount, pMicromaps, queryType, dataSize, pData, stride, cmock_retval) vkWriteMicromapsPropertiesEXT_CMockExpectAndReturn(__LINE__, device, micromapCount, pMicromaps, queryType, dataSize, pData, stride, cmock_retval) +void vkWriteMicromapsPropertiesEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, size_t dataSize, void* pData, size_t stride, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkWriteMicromapsPropertiesEXT_CALLBACK)(VkDevice device, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, size_t dataSize, void* pData, size_t stride, int cmock_num_calls); +void vkWriteMicromapsPropertiesEXT_AddCallback(CMOCK_vkWriteMicromapsPropertiesEXT_CALLBACK Callback); +void vkWriteMicromapsPropertiesEXT_Stub(CMOCK_vkWriteMicromapsPropertiesEXT_CALLBACK Callback); +#define vkWriteMicromapsPropertiesEXT_StubWithCallback vkWriteMicromapsPropertiesEXT_AddCallback +#define vkWriteMicromapsPropertiesEXT_ReturnThruPtr_pData(pData) vkWriteMicromapsPropertiesEXT_CMockReturnMemThruPtr_pData(__LINE__, pData, sizeof(*pData)) +#define vkWriteMicromapsPropertiesEXT_ReturnArrayThruPtr_pData(pData, cmock_len) vkWriteMicromapsPropertiesEXT_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_len * sizeof(*pData)) +#define vkWriteMicromapsPropertiesEXT_ReturnMemThruPtr_pData(pData, cmock_size) vkWriteMicromapsPropertiesEXT_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_size) +void vkWriteMicromapsPropertiesEXT_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, void const* pData, size_t cmock_size); +#define vkWriteMicromapsPropertiesEXT_IgnoreArg_device() vkWriteMicromapsPropertiesEXT_CMockIgnoreArg_device(__LINE__) +void vkWriteMicromapsPropertiesEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkWriteMicromapsPropertiesEXT_IgnoreArg_micromapCount() vkWriteMicromapsPropertiesEXT_CMockIgnoreArg_micromapCount(__LINE__) +void vkWriteMicromapsPropertiesEXT_CMockIgnoreArg_micromapCount(UNITY_LINE_TYPE cmock_line); +#define vkWriteMicromapsPropertiesEXT_IgnoreArg_pMicromaps() vkWriteMicromapsPropertiesEXT_CMockIgnoreArg_pMicromaps(__LINE__) +void vkWriteMicromapsPropertiesEXT_CMockIgnoreArg_pMicromaps(UNITY_LINE_TYPE cmock_line); +#define vkWriteMicromapsPropertiesEXT_IgnoreArg_queryType() vkWriteMicromapsPropertiesEXT_CMockIgnoreArg_queryType(__LINE__) +void vkWriteMicromapsPropertiesEXT_CMockIgnoreArg_queryType(UNITY_LINE_TYPE cmock_line); +#define vkWriteMicromapsPropertiesEXT_IgnoreArg_dataSize() vkWriteMicromapsPropertiesEXT_CMockIgnoreArg_dataSize(__LINE__) +void vkWriteMicromapsPropertiesEXT_CMockIgnoreArg_dataSize(UNITY_LINE_TYPE cmock_line); +#define vkWriteMicromapsPropertiesEXT_IgnoreArg_pData() vkWriteMicromapsPropertiesEXT_CMockIgnoreArg_pData(__LINE__) +void vkWriteMicromapsPropertiesEXT_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line); +#define vkWriteMicromapsPropertiesEXT_IgnoreArg_stride() vkWriteMicromapsPropertiesEXT_CMockIgnoreArg_stride(__LINE__) +void vkWriteMicromapsPropertiesEXT_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyMicromapEXT_Ignore() vkCmdCopyMicromapEXT_CMockIgnore() +void vkCmdCopyMicromapEXT_CMockIgnore(void); +#define vkCmdCopyMicromapEXT_StopIgnore() vkCmdCopyMicromapEXT_CMockStopIgnore() +void vkCmdCopyMicromapEXT_CMockStopIgnore(void); +#define vkCmdCopyMicromapEXT_ExpectAnyArgs() vkCmdCopyMicromapEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdCopyMicromapEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyMicromapEXT_Expect(commandBuffer, pInfo) vkCmdCopyMicromapEXT_CMockExpect(__LINE__, commandBuffer, pInfo) +void vkCmdCopyMicromapEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo); +typedef void (* CMOCK_vkCmdCopyMicromapEXT_CALLBACK)(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo, int cmock_num_calls); +void vkCmdCopyMicromapEXT_AddCallback(CMOCK_vkCmdCopyMicromapEXT_CALLBACK Callback); +void vkCmdCopyMicromapEXT_Stub(CMOCK_vkCmdCopyMicromapEXT_CALLBACK Callback); +#define vkCmdCopyMicromapEXT_StubWithCallback vkCmdCopyMicromapEXT_AddCallback +#define vkCmdCopyMicromapEXT_IgnoreArg_commandBuffer() vkCmdCopyMicromapEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdCopyMicromapEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyMicromapEXT_IgnoreArg_pInfo() vkCmdCopyMicromapEXT_CMockIgnoreArg_pInfo(__LINE__) +void vkCmdCopyMicromapEXT_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyMicromapToMemoryEXT_Ignore() vkCmdCopyMicromapToMemoryEXT_CMockIgnore() +void vkCmdCopyMicromapToMemoryEXT_CMockIgnore(void); +#define vkCmdCopyMicromapToMemoryEXT_StopIgnore() vkCmdCopyMicromapToMemoryEXT_CMockStopIgnore() +void vkCmdCopyMicromapToMemoryEXT_CMockStopIgnore(void); +#define vkCmdCopyMicromapToMemoryEXT_ExpectAnyArgs() vkCmdCopyMicromapToMemoryEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdCopyMicromapToMemoryEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyMicromapToMemoryEXT_Expect(commandBuffer, pInfo) vkCmdCopyMicromapToMemoryEXT_CMockExpect(__LINE__, commandBuffer, pInfo) +void vkCmdCopyMicromapToMemoryEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo); +typedef void (* CMOCK_vkCmdCopyMicromapToMemoryEXT_CALLBACK)(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo, int cmock_num_calls); +void vkCmdCopyMicromapToMemoryEXT_AddCallback(CMOCK_vkCmdCopyMicromapToMemoryEXT_CALLBACK Callback); +void vkCmdCopyMicromapToMemoryEXT_Stub(CMOCK_vkCmdCopyMicromapToMemoryEXT_CALLBACK Callback); +#define vkCmdCopyMicromapToMemoryEXT_StubWithCallback vkCmdCopyMicromapToMemoryEXT_AddCallback +#define vkCmdCopyMicromapToMemoryEXT_IgnoreArg_commandBuffer() vkCmdCopyMicromapToMemoryEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdCopyMicromapToMemoryEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyMicromapToMemoryEXT_IgnoreArg_pInfo() vkCmdCopyMicromapToMemoryEXT_CMockIgnoreArg_pInfo(__LINE__) +void vkCmdCopyMicromapToMemoryEXT_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyMemoryToMicromapEXT_Ignore() vkCmdCopyMemoryToMicromapEXT_CMockIgnore() +void vkCmdCopyMemoryToMicromapEXT_CMockIgnore(void); +#define vkCmdCopyMemoryToMicromapEXT_StopIgnore() vkCmdCopyMemoryToMicromapEXT_CMockStopIgnore() +void vkCmdCopyMemoryToMicromapEXT_CMockStopIgnore(void); +#define vkCmdCopyMemoryToMicromapEXT_ExpectAnyArgs() vkCmdCopyMemoryToMicromapEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdCopyMemoryToMicromapEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyMemoryToMicromapEXT_Expect(commandBuffer, pInfo) vkCmdCopyMemoryToMicromapEXT_CMockExpect(__LINE__, commandBuffer, pInfo) +void vkCmdCopyMemoryToMicromapEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo); +typedef void (* CMOCK_vkCmdCopyMemoryToMicromapEXT_CALLBACK)(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo, int cmock_num_calls); +void vkCmdCopyMemoryToMicromapEXT_AddCallback(CMOCK_vkCmdCopyMemoryToMicromapEXT_CALLBACK Callback); +void vkCmdCopyMemoryToMicromapEXT_Stub(CMOCK_vkCmdCopyMemoryToMicromapEXT_CALLBACK Callback); +#define vkCmdCopyMemoryToMicromapEXT_StubWithCallback vkCmdCopyMemoryToMicromapEXT_AddCallback +#define vkCmdCopyMemoryToMicromapEXT_IgnoreArg_commandBuffer() vkCmdCopyMemoryToMicromapEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdCopyMemoryToMicromapEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyMemoryToMicromapEXT_IgnoreArg_pInfo() vkCmdCopyMemoryToMicromapEXT_CMockIgnoreArg_pInfo(__LINE__) +void vkCmdCopyMemoryToMicromapEXT_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteMicromapsPropertiesEXT_Ignore() vkCmdWriteMicromapsPropertiesEXT_CMockIgnore() +void vkCmdWriteMicromapsPropertiesEXT_CMockIgnore(void); +#define vkCmdWriteMicromapsPropertiesEXT_StopIgnore() vkCmdWriteMicromapsPropertiesEXT_CMockStopIgnore() +void vkCmdWriteMicromapsPropertiesEXT_CMockStopIgnore(void); +#define vkCmdWriteMicromapsPropertiesEXT_ExpectAnyArgs() vkCmdWriteMicromapsPropertiesEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdWriteMicromapsPropertiesEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteMicromapsPropertiesEXT_Expect(commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery) vkCmdWriteMicromapsPropertiesEXT_CMockExpect(__LINE__, commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery) +void vkCmdWriteMicromapsPropertiesEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); +typedef void (* CMOCK_vkCmdWriteMicromapsPropertiesEXT_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery, int cmock_num_calls); +void vkCmdWriteMicromapsPropertiesEXT_AddCallback(CMOCK_vkCmdWriteMicromapsPropertiesEXT_CALLBACK Callback); +void vkCmdWriteMicromapsPropertiesEXT_Stub(CMOCK_vkCmdWriteMicromapsPropertiesEXT_CALLBACK Callback); +#define vkCmdWriteMicromapsPropertiesEXT_StubWithCallback vkCmdWriteMicromapsPropertiesEXT_AddCallback +#define vkCmdWriteMicromapsPropertiesEXT_IgnoreArg_commandBuffer() vkCmdWriteMicromapsPropertiesEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdWriteMicromapsPropertiesEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteMicromapsPropertiesEXT_IgnoreArg_micromapCount() vkCmdWriteMicromapsPropertiesEXT_CMockIgnoreArg_micromapCount(__LINE__) +void vkCmdWriteMicromapsPropertiesEXT_CMockIgnoreArg_micromapCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteMicromapsPropertiesEXT_IgnoreArg_pMicromaps() vkCmdWriteMicromapsPropertiesEXT_CMockIgnoreArg_pMicromaps(__LINE__) +void vkCmdWriteMicromapsPropertiesEXT_CMockIgnoreArg_pMicromaps(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteMicromapsPropertiesEXT_IgnoreArg_queryType() vkCmdWriteMicromapsPropertiesEXT_CMockIgnoreArg_queryType(__LINE__) +void vkCmdWriteMicromapsPropertiesEXT_CMockIgnoreArg_queryType(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteMicromapsPropertiesEXT_IgnoreArg_queryPool() vkCmdWriteMicromapsPropertiesEXT_CMockIgnoreArg_queryPool(__LINE__) +void vkCmdWriteMicromapsPropertiesEXT_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteMicromapsPropertiesEXT_IgnoreArg_firstQuery() vkCmdWriteMicromapsPropertiesEXT_CMockIgnoreArg_firstQuery(__LINE__) +void vkCmdWriteMicromapsPropertiesEXT_CMockIgnoreArg_firstQuery(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceMicromapCompatibilityEXT_Ignore() vkGetDeviceMicromapCompatibilityEXT_CMockIgnore() +void vkGetDeviceMicromapCompatibilityEXT_CMockIgnore(void); +#define vkGetDeviceMicromapCompatibilityEXT_StopIgnore() vkGetDeviceMicromapCompatibilityEXT_CMockStopIgnore() +void vkGetDeviceMicromapCompatibilityEXT_CMockStopIgnore(void); +#define vkGetDeviceMicromapCompatibilityEXT_ExpectAnyArgs() vkGetDeviceMicromapCompatibilityEXT_CMockExpectAnyArgs(__LINE__) +void vkGetDeviceMicromapCompatibilityEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceMicromapCompatibilityEXT_Expect(device, pVersionInfo, pCompatibility) vkGetDeviceMicromapCompatibilityEXT_CMockExpect(__LINE__, device, pVersionInfo, pCompatibility) +void vkGetDeviceMicromapCompatibilityEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility); +typedef void (* CMOCK_vkGetDeviceMicromapCompatibilityEXT_CALLBACK)(VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility, int cmock_num_calls); +void vkGetDeviceMicromapCompatibilityEXT_AddCallback(CMOCK_vkGetDeviceMicromapCompatibilityEXT_CALLBACK Callback); +void vkGetDeviceMicromapCompatibilityEXT_Stub(CMOCK_vkGetDeviceMicromapCompatibilityEXT_CALLBACK Callback); +#define vkGetDeviceMicromapCompatibilityEXT_StubWithCallback vkGetDeviceMicromapCompatibilityEXT_AddCallback +#define vkGetDeviceMicromapCompatibilityEXT_ReturnThruPtr_pCompatibility(pCompatibility) vkGetDeviceMicromapCompatibilityEXT_CMockReturnMemThruPtr_pCompatibility(__LINE__, pCompatibility, sizeof(VkAccelerationStructureCompatibilityKHR)) +#define vkGetDeviceMicromapCompatibilityEXT_ReturnArrayThruPtr_pCompatibility(pCompatibility, cmock_len) vkGetDeviceMicromapCompatibilityEXT_CMockReturnMemThruPtr_pCompatibility(__LINE__, pCompatibility, cmock_len * sizeof(*pCompatibility)) +#define vkGetDeviceMicromapCompatibilityEXT_ReturnMemThruPtr_pCompatibility(pCompatibility, cmock_size) vkGetDeviceMicromapCompatibilityEXT_CMockReturnMemThruPtr_pCompatibility(__LINE__, pCompatibility, cmock_size) +void vkGetDeviceMicromapCompatibilityEXT_CMockReturnMemThruPtr_pCompatibility(UNITY_LINE_TYPE cmock_line, VkAccelerationStructureCompatibilityKHR const* pCompatibility, size_t cmock_size); +#define vkGetDeviceMicromapCompatibilityEXT_IgnoreArg_device() vkGetDeviceMicromapCompatibilityEXT_CMockIgnoreArg_device(__LINE__) +void vkGetDeviceMicromapCompatibilityEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceMicromapCompatibilityEXT_IgnoreArg_pVersionInfo() vkGetDeviceMicromapCompatibilityEXT_CMockIgnoreArg_pVersionInfo(__LINE__) +void vkGetDeviceMicromapCompatibilityEXT_CMockIgnoreArg_pVersionInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceMicromapCompatibilityEXT_IgnoreArg_pCompatibility() vkGetDeviceMicromapCompatibilityEXT_CMockIgnoreArg_pCompatibility(__LINE__) +void vkGetDeviceMicromapCompatibilityEXT_CMockIgnoreArg_pCompatibility(UNITY_LINE_TYPE cmock_line); +#define vkGetMicromapBuildSizesEXT_Ignore() vkGetMicromapBuildSizesEXT_CMockIgnore() +void vkGetMicromapBuildSizesEXT_CMockIgnore(void); +#define vkGetMicromapBuildSizesEXT_StopIgnore() vkGetMicromapBuildSizesEXT_CMockStopIgnore() +void vkGetMicromapBuildSizesEXT_CMockStopIgnore(void); +#define vkGetMicromapBuildSizesEXT_ExpectAnyArgs() vkGetMicromapBuildSizesEXT_CMockExpectAnyArgs(__LINE__) +void vkGetMicromapBuildSizesEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetMicromapBuildSizesEXT_Expect(device, buildType, pBuildInfo, pSizeInfo) vkGetMicromapBuildSizesEXT_CMockExpect(__LINE__, device, buildType, pBuildInfo, pSizeInfo) +void vkGetMicromapBuildSizesEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo); +typedef void (* CMOCK_vkGetMicromapBuildSizesEXT_CALLBACK)(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo, int cmock_num_calls); +void vkGetMicromapBuildSizesEXT_AddCallback(CMOCK_vkGetMicromapBuildSizesEXT_CALLBACK Callback); +void vkGetMicromapBuildSizesEXT_Stub(CMOCK_vkGetMicromapBuildSizesEXT_CALLBACK Callback); +#define vkGetMicromapBuildSizesEXT_StubWithCallback vkGetMicromapBuildSizesEXT_AddCallback +#define vkGetMicromapBuildSizesEXT_ReturnThruPtr_pSizeInfo(pSizeInfo) vkGetMicromapBuildSizesEXT_CMockReturnMemThruPtr_pSizeInfo(__LINE__, pSizeInfo, sizeof(VkMicromapBuildSizesInfoEXT)) +#define vkGetMicromapBuildSizesEXT_ReturnArrayThruPtr_pSizeInfo(pSizeInfo, cmock_len) vkGetMicromapBuildSizesEXT_CMockReturnMemThruPtr_pSizeInfo(__LINE__, pSizeInfo, cmock_len * sizeof(*pSizeInfo)) +#define vkGetMicromapBuildSizesEXT_ReturnMemThruPtr_pSizeInfo(pSizeInfo, cmock_size) vkGetMicromapBuildSizesEXT_CMockReturnMemThruPtr_pSizeInfo(__LINE__, pSizeInfo, cmock_size) +void vkGetMicromapBuildSizesEXT_CMockReturnMemThruPtr_pSizeInfo(UNITY_LINE_TYPE cmock_line, VkMicromapBuildSizesInfoEXT const* pSizeInfo, size_t cmock_size); +#define vkGetMicromapBuildSizesEXT_IgnoreArg_device() vkGetMicromapBuildSizesEXT_CMockIgnoreArg_device(__LINE__) +void vkGetMicromapBuildSizesEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetMicromapBuildSizesEXT_IgnoreArg_buildType() vkGetMicromapBuildSizesEXT_CMockIgnoreArg_buildType(__LINE__) +void vkGetMicromapBuildSizesEXT_CMockIgnoreArg_buildType(UNITY_LINE_TYPE cmock_line); +#define vkGetMicromapBuildSizesEXT_IgnoreArg_pBuildInfo() vkGetMicromapBuildSizesEXT_CMockIgnoreArg_pBuildInfo(__LINE__) +void vkGetMicromapBuildSizesEXT_CMockIgnoreArg_pBuildInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetMicromapBuildSizesEXT_IgnoreArg_pSizeInfo() vkGetMicromapBuildSizesEXT_CMockIgnoreArg_pSizeInfo(__LINE__) +void vkGetMicromapBuildSizesEXT_CMockIgnoreArg_pSizeInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawClusterHUAWEI_Ignore() vkCmdDrawClusterHUAWEI_CMockIgnore() +void vkCmdDrawClusterHUAWEI_CMockIgnore(void); +#define vkCmdDrawClusterHUAWEI_StopIgnore() vkCmdDrawClusterHUAWEI_CMockStopIgnore() +void vkCmdDrawClusterHUAWEI_CMockStopIgnore(void); +#define vkCmdDrawClusterHUAWEI_ExpectAnyArgs() vkCmdDrawClusterHUAWEI_CMockExpectAnyArgs(__LINE__) +void vkCmdDrawClusterHUAWEI_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawClusterHUAWEI_Expect(commandBuffer, groupCountX, groupCountY, groupCountZ) vkCmdDrawClusterHUAWEI_CMockExpect(__LINE__, commandBuffer, groupCountX, groupCountY, groupCountZ) +void vkCmdDrawClusterHUAWEI_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef void (* CMOCK_vkCmdDrawClusterHUAWEI_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, int cmock_num_calls); +void vkCmdDrawClusterHUAWEI_AddCallback(CMOCK_vkCmdDrawClusterHUAWEI_CALLBACK Callback); +void vkCmdDrawClusterHUAWEI_Stub(CMOCK_vkCmdDrawClusterHUAWEI_CALLBACK Callback); +#define vkCmdDrawClusterHUAWEI_StubWithCallback vkCmdDrawClusterHUAWEI_AddCallback +#define vkCmdDrawClusterHUAWEI_IgnoreArg_commandBuffer() vkCmdDrawClusterHUAWEI_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDrawClusterHUAWEI_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawClusterHUAWEI_IgnoreArg_groupCountX() vkCmdDrawClusterHUAWEI_CMockIgnoreArg_groupCountX(__LINE__) +void vkCmdDrawClusterHUAWEI_CMockIgnoreArg_groupCountX(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawClusterHUAWEI_IgnoreArg_groupCountY() vkCmdDrawClusterHUAWEI_CMockIgnoreArg_groupCountY(__LINE__) +void vkCmdDrawClusterHUAWEI_CMockIgnoreArg_groupCountY(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawClusterHUAWEI_IgnoreArg_groupCountZ() vkCmdDrawClusterHUAWEI_CMockIgnoreArg_groupCountZ(__LINE__) +void vkCmdDrawClusterHUAWEI_CMockIgnoreArg_groupCountZ(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawClusterIndirectHUAWEI_Ignore() vkCmdDrawClusterIndirectHUAWEI_CMockIgnore() +void vkCmdDrawClusterIndirectHUAWEI_CMockIgnore(void); +#define vkCmdDrawClusterIndirectHUAWEI_StopIgnore() vkCmdDrawClusterIndirectHUAWEI_CMockStopIgnore() +void vkCmdDrawClusterIndirectHUAWEI_CMockStopIgnore(void); +#define vkCmdDrawClusterIndirectHUAWEI_ExpectAnyArgs() vkCmdDrawClusterIndirectHUAWEI_CMockExpectAnyArgs(__LINE__) +void vkCmdDrawClusterIndirectHUAWEI_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawClusterIndirectHUAWEI_Expect(commandBuffer, buffer, offset) vkCmdDrawClusterIndirectHUAWEI_CMockExpect(__LINE__, commandBuffer, buffer, offset) +void vkCmdDrawClusterIndirectHUAWEI_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); +typedef void (* CMOCK_vkCmdDrawClusterIndirectHUAWEI_CALLBACK)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, int cmock_num_calls); +void vkCmdDrawClusterIndirectHUAWEI_AddCallback(CMOCK_vkCmdDrawClusterIndirectHUAWEI_CALLBACK Callback); +void vkCmdDrawClusterIndirectHUAWEI_Stub(CMOCK_vkCmdDrawClusterIndirectHUAWEI_CALLBACK Callback); +#define vkCmdDrawClusterIndirectHUAWEI_StubWithCallback vkCmdDrawClusterIndirectHUAWEI_AddCallback +#define vkCmdDrawClusterIndirectHUAWEI_IgnoreArg_commandBuffer() vkCmdDrawClusterIndirectHUAWEI_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDrawClusterIndirectHUAWEI_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawClusterIndirectHUAWEI_IgnoreArg_buffer() vkCmdDrawClusterIndirectHUAWEI_CMockIgnoreArg_buffer(__LINE__) +void vkCmdDrawClusterIndirectHUAWEI_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawClusterIndirectHUAWEI_IgnoreArg_offset() vkCmdDrawClusterIndirectHUAWEI_CMockIgnoreArg_offset(__LINE__) +void vkCmdDrawClusterIndirectHUAWEI_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line); +#define vkSetDeviceMemoryPriorityEXT_Ignore() vkSetDeviceMemoryPriorityEXT_CMockIgnore() +void vkSetDeviceMemoryPriorityEXT_CMockIgnore(void); +#define vkSetDeviceMemoryPriorityEXT_StopIgnore() vkSetDeviceMemoryPriorityEXT_CMockStopIgnore() +void vkSetDeviceMemoryPriorityEXT_CMockStopIgnore(void); +#define vkSetDeviceMemoryPriorityEXT_ExpectAnyArgs() vkSetDeviceMemoryPriorityEXT_CMockExpectAnyArgs(__LINE__) +void vkSetDeviceMemoryPriorityEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkSetDeviceMemoryPriorityEXT_Expect(device, memory, priority) vkSetDeviceMemoryPriorityEXT_CMockExpect(__LINE__, device, memory, priority) +void vkSetDeviceMemoryPriorityEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeviceMemory memory, float priority); +typedef void (* CMOCK_vkSetDeviceMemoryPriorityEXT_CALLBACK)(VkDevice device, VkDeviceMemory memory, float priority, int cmock_num_calls); +void vkSetDeviceMemoryPriorityEXT_AddCallback(CMOCK_vkSetDeviceMemoryPriorityEXT_CALLBACK Callback); +void vkSetDeviceMemoryPriorityEXT_Stub(CMOCK_vkSetDeviceMemoryPriorityEXT_CALLBACK Callback); +#define vkSetDeviceMemoryPriorityEXT_StubWithCallback vkSetDeviceMemoryPriorityEXT_AddCallback +#define vkSetDeviceMemoryPriorityEXT_IgnoreArg_device() vkSetDeviceMemoryPriorityEXT_CMockIgnoreArg_device(__LINE__) +void vkSetDeviceMemoryPriorityEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkSetDeviceMemoryPriorityEXT_IgnoreArg_memory() vkSetDeviceMemoryPriorityEXT_CMockIgnoreArg_memory(__LINE__) +void vkSetDeviceMemoryPriorityEXT_CMockIgnoreArg_memory(UNITY_LINE_TYPE cmock_line); +#define vkSetDeviceMemoryPriorityEXT_IgnoreArg_priority() vkSetDeviceMemoryPriorityEXT_CMockIgnoreArg_priority(__LINE__) +void vkSetDeviceMemoryPriorityEXT_CMockIgnoreArg_priority(UNITY_LINE_TYPE cmock_line); +#define vkGetDescriptorSetLayoutHostMappingInfoVALVE_Ignore() vkGetDescriptorSetLayoutHostMappingInfoVALVE_CMockIgnore() +void vkGetDescriptorSetLayoutHostMappingInfoVALVE_CMockIgnore(void); +#define vkGetDescriptorSetLayoutHostMappingInfoVALVE_StopIgnore() vkGetDescriptorSetLayoutHostMappingInfoVALVE_CMockStopIgnore() +void vkGetDescriptorSetLayoutHostMappingInfoVALVE_CMockStopIgnore(void); +#define vkGetDescriptorSetLayoutHostMappingInfoVALVE_ExpectAnyArgs() vkGetDescriptorSetLayoutHostMappingInfoVALVE_CMockExpectAnyArgs(__LINE__) +void vkGetDescriptorSetLayoutHostMappingInfoVALVE_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetDescriptorSetLayoutHostMappingInfoVALVE_Expect(device, pBindingReference, pHostMapping) vkGetDescriptorSetLayoutHostMappingInfoVALVE_CMockExpect(__LINE__, device, pBindingReference, pHostMapping) +void vkGetDescriptorSetLayoutHostMappingInfoVALVE_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping); +typedef void (* CMOCK_vkGetDescriptorSetLayoutHostMappingInfoVALVE_CALLBACK)(VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping, int cmock_num_calls); +void vkGetDescriptorSetLayoutHostMappingInfoVALVE_AddCallback(CMOCK_vkGetDescriptorSetLayoutHostMappingInfoVALVE_CALLBACK Callback); +void vkGetDescriptorSetLayoutHostMappingInfoVALVE_Stub(CMOCK_vkGetDescriptorSetLayoutHostMappingInfoVALVE_CALLBACK Callback); +#define vkGetDescriptorSetLayoutHostMappingInfoVALVE_StubWithCallback vkGetDescriptorSetLayoutHostMappingInfoVALVE_AddCallback +#define vkGetDescriptorSetLayoutHostMappingInfoVALVE_ReturnThruPtr_pHostMapping(pHostMapping) vkGetDescriptorSetLayoutHostMappingInfoVALVE_CMockReturnMemThruPtr_pHostMapping(__LINE__, pHostMapping, sizeof(VkDescriptorSetLayoutHostMappingInfoVALVE)) +#define vkGetDescriptorSetLayoutHostMappingInfoVALVE_ReturnArrayThruPtr_pHostMapping(pHostMapping, cmock_len) vkGetDescriptorSetLayoutHostMappingInfoVALVE_CMockReturnMemThruPtr_pHostMapping(__LINE__, pHostMapping, cmock_len * sizeof(*pHostMapping)) +#define vkGetDescriptorSetLayoutHostMappingInfoVALVE_ReturnMemThruPtr_pHostMapping(pHostMapping, cmock_size) vkGetDescriptorSetLayoutHostMappingInfoVALVE_CMockReturnMemThruPtr_pHostMapping(__LINE__, pHostMapping, cmock_size) +void vkGetDescriptorSetLayoutHostMappingInfoVALVE_CMockReturnMemThruPtr_pHostMapping(UNITY_LINE_TYPE cmock_line, VkDescriptorSetLayoutHostMappingInfoVALVE const* pHostMapping, size_t cmock_size); +#define vkGetDescriptorSetLayoutHostMappingInfoVALVE_IgnoreArg_device() vkGetDescriptorSetLayoutHostMappingInfoVALVE_CMockIgnoreArg_device(__LINE__) +void vkGetDescriptorSetLayoutHostMappingInfoVALVE_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetDescriptorSetLayoutHostMappingInfoVALVE_IgnoreArg_pBindingReference() vkGetDescriptorSetLayoutHostMappingInfoVALVE_CMockIgnoreArg_pBindingReference(__LINE__) +void vkGetDescriptorSetLayoutHostMappingInfoVALVE_CMockIgnoreArg_pBindingReference(UNITY_LINE_TYPE cmock_line); +#define vkGetDescriptorSetLayoutHostMappingInfoVALVE_IgnoreArg_pHostMapping() vkGetDescriptorSetLayoutHostMappingInfoVALVE_CMockIgnoreArg_pHostMapping(__LINE__) +void vkGetDescriptorSetLayoutHostMappingInfoVALVE_CMockIgnoreArg_pHostMapping(UNITY_LINE_TYPE cmock_line); +#define vkGetDescriptorSetHostMappingVALVE_Ignore() vkGetDescriptorSetHostMappingVALVE_CMockIgnore() +void vkGetDescriptorSetHostMappingVALVE_CMockIgnore(void); +#define vkGetDescriptorSetHostMappingVALVE_StopIgnore() vkGetDescriptorSetHostMappingVALVE_CMockStopIgnore() +void vkGetDescriptorSetHostMappingVALVE_CMockStopIgnore(void); +#define vkGetDescriptorSetHostMappingVALVE_ExpectAnyArgs() vkGetDescriptorSetHostMappingVALVE_CMockExpectAnyArgs(__LINE__) +void vkGetDescriptorSetHostMappingVALVE_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetDescriptorSetHostMappingVALVE_Expect(device, descriptorSet, ppData) vkGetDescriptorSetHostMappingVALVE_CMockExpect(__LINE__, device, descriptorSet, ppData) +void vkGetDescriptorSetHostMappingVALVE_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDescriptorSet descriptorSet, void** ppData); +typedef void (* CMOCK_vkGetDescriptorSetHostMappingVALVE_CALLBACK)(VkDevice device, VkDescriptorSet descriptorSet, void** ppData, int cmock_num_calls); +void vkGetDescriptorSetHostMappingVALVE_AddCallback(CMOCK_vkGetDescriptorSetHostMappingVALVE_CALLBACK Callback); +void vkGetDescriptorSetHostMappingVALVE_Stub(CMOCK_vkGetDescriptorSetHostMappingVALVE_CALLBACK Callback); +#define vkGetDescriptorSetHostMappingVALVE_StubWithCallback vkGetDescriptorSetHostMappingVALVE_AddCallback +#define vkGetDescriptorSetHostMappingVALVE_ReturnThruPtr_ppData(ppData) vkGetDescriptorSetHostMappingVALVE_CMockReturnMemThruPtr_ppData(__LINE__, ppData, sizeof(void*)) +#define vkGetDescriptorSetHostMappingVALVE_ReturnArrayThruPtr_ppData(ppData, cmock_len) vkGetDescriptorSetHostMappingVALVE_CMockReturnMemThruPtr_ppData(__LINE__, ppData, cmock_len * sizeof(*ppData)) +#define vkGetDescriptorSetHostMappingVALVE_ReturnMemThruPtr_ppData(ppData, cmock_size) vkGetDescriptorSetHostMappingVALVE_CMockReturnMemThruPtr_ppData(__LINE__, ppData, cmock_size) +void vkGetDescriptorSetHostMappingVALVE_CMockReturnMemThruPtr_ppData(UNITY_LINE_TYPE cmock_line, void* const* ppData, size_t cmock_size); +#define vkGetDescriptorSetHostMappingVALVE_IgnoreArg_device() vkGetDescriptorSetHostMappingVALVE_CMockIgnoreArg_device(__LINE__) +void vkGetDescriptorSetHostMappingVALVE_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetDescriptorSetHostMappingVALVE_IgnoreArg_descriptorSet() vkGetDescriptorSetHostMappingVALVE_CMockIgnoreArg_descriptorSet(__LINE__) +void vkGetDescriptorSetHostMappingVALVE_CMockIgnoreArg_descriptorSet(UNITY_LINE_TYPE cmock_line); +#define vkGetDescriptorSetHostMappingVALVE_IgnoreArg_ppData() vkGetDescriptorSetHostMappingVALVE_CMockIgnoreArg_ppData(__LINE__) +void vkGetDescriptorSetHostMappingVALVE_CMockIgnoreArg_ppData(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyMemoryIndirectNV_Ignore() vkCmdCopyMemoryIndirectNV_CMockIgnore() +void vkCmdCopyMemoryIndirectNV_CMockIgnore(void); +#define vkCmdCopyMemoryIndirectNV_StopIgnore() vkCmdCopyMemoryIndirectNV_CMockStopIgnore() +void vkCmdCopyMemoryIndirectNV_CMockStopIgnore(void); +#define vkCmdCopyMemoryIndirectNV_ExpectAnyArgs() vkCmdCopyMemoryIndirectNV_CMockExpectAnyArgs(__LINE__) +void vkCmdCopyMemoryIndirectNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyMemoryIndirectNV_Expect(commandBuffer, copyBufferAddress, copyCount, stride) vkCmdCopyMemoryIndirectNV_CMockExpect(__LINE__, commandBuffer, copyBufferAddress, copyCount, stride) +void vkCmdCopyMemoryIndirectNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride); +typedef void (* CMOCK_vkCmdCopyMemoryIndirectNV_CALLBACK)(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, int cmock_num_calls); +void vkCmdCopyMemoryIndirectNV_AddCallback(CMOCK_vkCmdCopyMemoryIndirectNV_CALLBACK Callback); +void vkCmdCopyMemoryIndirectNV_Stub(CMOCK_vkCmdCopyMemoryIndirectNV_CALLBACK Callback); +#define vkCmdCopyMemoryIndirectNV_StubWithCallback vkCmdCopyMemoryIndirectNV_AddCallback +#define vkCmdCopyMemoryIndirectNV_IgnoreArg_commandBuffer() vkCmdCopyMemoryIndirectNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdCopyMemoryIndirectNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyMemoryIndirectNV_IgnoreArg_copyBufferAddress() vkCmdCopyMemoryIndirectNV_CMockIgnoreArg_copyBufferAddress(__LINE__) +void vkCmdCopyMemoryIndirectNV_CMockIgnoreArg_copyBufferAddress(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyMemoryIndirectNV_IgnoreArg_copyCount() vkCmdCopyMemoryIndirectNV_CMockIgnoreArg_copyCount(__LINE__) +void vkCmdCopyMemoryIndirectNV_CMockIgnoreArg_copyCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyMemoryIndirectNV_IgnoreArg_stride() vkCmdCopyMemoryIndirectNV_CMockIgnoreArg_stride(__LINE__) +void vkCmdCopyMemoryIndirectNV_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyMemoryToImageIndirectNV_Ignore() vkCmdCopyMemoryToImageIndirectNV_CMockIgnore() +void vkCmdCopyMemoryToImageIndirectNV_CMockIgnore(void); +#define vkCmdCopyMemoryToImageIndirectNV_StopIgnore() vkCmdCopyMemoryToImageIndirectNV_CMockStopIgnore() +void vkCmdCopyMemoryToImageIndirectNV_CMockStopIgnore(void); +#define vkCmdCopyMemoryToImageIndirectNV_ExpectAnyArgs() vkCmdCopyMemoryToImageIndirectNV_CMockExpectAnyArgs(__LINE__) +void vkCmdCopyMemoryToImageIndirectNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyMemoryToImageIndirectNV_Expect(commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources) vkCmdCopyMemoryToImageIndirectNV_CMockExpect(__LINE__, commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources) +void vkCmdCopyMemoryToImageIndirectNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers* pImageSubresources); +typedef void (* CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALLBACK)(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers* pImageSubresources, int cmock_num_calls); +void vkCmdCopyMemoryToImageIndirectNV_AddCallback(CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALLBACK Callback); +void vkCmdCopyMemoryToImageIndirectNV_Stub(CMOCK_vkCmdCopyMemoryToImageIndirectNV_CALLBACK Callback); +#define vkCmdCopyMemoryToImageIndirectNV_StubWithCallback vkCmdCopyMemoryToImageIndirectNV_AddCallback +#define vkCmdCopyMemoryToImageIndirectNV_IgnoreArg_commandBuffer() vkCmdCopyMemoryToImageIndirectNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdCopyMemoryToImageIndirectNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyMemoryToImageIndirectNV_IgnoreArg_copyBufferAddress() vkCmdCopyMemoryToImageIndirectNV_CMockIgnoreArg_copyBufferAddress(__LINE__) +void vkCmdCopyMemoryToImageIndirectNV_CMockIgnoreArg_copyBufferAddress(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyMemoryToImageIndirectNV_IgnoreArg_copyCount() vkCmdCopyMemoryToImageIndirectNV_CMockIgnoreArg_copyCount(__LINE__) +void vkCmdCopyMemoryToImageIndirectNV_CMockIgnoreArg_copyCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyMemoryToImageIndirectNV_IgnoreArg_stride() vkCmdCopyMemoryToImageIndirectNV_CMockIgnoreArg_stride(__LINE__) +void vkCmdCopyMemoryToImageIndirectNV_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyMemoryToImageIndirectNV_IgnoreArg_dstImage() vkCmdCopyMemoryToImageIndirectNV_CMockIgnoreArg_dstImage(__LINE__) +void vkCmdCopyMemoryToImageIndirectNV_CMockIgnoreArg_dstImage(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyMemoryToImageIndirectNV_IgnoreArg_dstImageLayout() vkCmdCopyMemoryToImageIndirectNV_CMockIgnoreArg_dstImageLayout(__LINE__) +void vkCmdCopyMemoryToImageIndirectNV_CMockIgnoreArg_dstImageLayout(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyMemoryToImageIndirectNV_IgnoreArg_pImageSubresources() vkCmdCopyMemoryToImageIndirectNV_CMockIgnoreArg_pImageSubresources(__LINE__) +void vkCmdCopyMemoryToImageIndirectNV_CMockIgnoreArg_pImageSubresources(UNITY_LINE_TYPE cmock_line); +#define vkCmdDecompressMemoryNV_Ignore() vkCmdDecompressMemoryNV_CMockIgnore() +void vkCmdDecompressMemoryNV_CMockIgnore(void); +#define vkCmdDecompressMemoryNV_StopIgnore() vkCmdDecompressMemoryNV_CMockStopIgnore() +void vkCmdDecompressMemoryNV_CMockStopIgnore(void); +#define vkCmdDecompressMemoryNV_ExpectAnyArgs() vkCmdDecompressMemoryNV_CMockExpectAnyArgs(__LINE__) +void vkCmdDecompressMemoryNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDecompressMemoryNV_Expect(commandBuffer, decompressRegionCount, pDecompressMemoryRegions) vkCmdDecompressMemoryNV_CMockExpect(__LINE__, commandBuffer, decompressRegionCount, pDecompressMemoryRegions) +void vkCmdDecompressMemoryNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV* pDecompressMemoryRegions); +typedef void (* CMOCK_vkCmdDecompressMemoryNV_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV* pDecompressMemoryRegions, int cmock_num_calls); +void vkCmdDecompressMemoryNV_AddCallback(CMOCK_vkCmdDecompressMemoryNV_CALLBACK Callback); +void vkCmdDecompressMemoryNV_Stub(CMOCK_vkCmdDecompressMemoryNV_CALLBACK Callback); +#define vkCmdDecompressMemoryNV_StubWithCallback vkCmdDecompressMemoryNV_AddCallback +#define vkCmdDecompressMemoryNV_IgnoreArg_commandBuffer() vkCmdDecompressMemoryNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDecompressMemoryNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDecompressMemoryNV_IgnoreArg_decompressRegionCount() vkCmdDecompressMemoryNV_CMockIgnoreArg_decompressRegionCount(__LINE__) +void vkCmdDecompressMemoryNV_CMockIgnoreArg_decompressRegionCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdDecompressMemoryNV_IgnoreArg_pDecompressMemoryRegions() vkCmdDecompressMemoryNV_CMockIgnoreArg_pDecompressMemoryRegions(__LINE__) +void vkCmdDecompressMemoryNV_CMockIgnoreArg_pDecompressMemoryRegions(UNITY_LINE_TYPE cmock_line); +#define vkCmdDecompressMemoryIndirectCountNV_Ignore() vkCmdDecompressMemoryIndirectCountNV_CMockIgnore() +void vkCmdDecompressMemoryIndirectCountNV_CMockIgnore(void); +#define vkCmdDecompressMemoryIndirectCountNV_StopIgnore() vkCmdDecompressMemoryIndirectCountNV_CMockStopIgnore() +void vkCmdDecompressMemoryIndirectCountNV_CMockStopIgnore(void); +#define vkCmdDecompressMemoryIndirectCountNV_ExpectAnyArgs() vkCmdDecompressMemoryIndirectCountNV_CMockExpectAnyArgs(__LINE__) +void vkCmdDecompressMemoryIndirectCountNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDecompressMemoryIndirectCountNV_Expect(commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride) vkCmdDecompressMemoryIndirectCountNV_CMockExpect(__LINE__, commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride) +void vkCmdDecompressMemoryIndirectCountNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride); +typedef void (* CMOCK_vkCmdDecompressMemoryIndirectCountNV_CALLBACK)(VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride, int cmock_num_calls); +void vkCmdDecompressMemoryIndirectCountNV_AddCallback(CMOCK_vkCmdDecompressMemoryIndirectCountNV_CALLBACK Callback); +void vkCmdDecompressMemoryIndirectCountNV_Stub(CMOCK_vkCmdDecompressMemoryIndirectCountNV_CALLBACK Callback); +#define vkCmdDecompressMemoryIndirectCountNV_StubWithCallback vkCmdDecompressMemoryIndirectCountNV_AddCallback +#define vkCmdDecompressMemoryIndirectCountNV_IgnoreArg_commandBuffer() vkCmdDecompressMemoryIndirectCountNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDecompressMemoryIndirectCountNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDecompressMemoryIndirectCountNV_IgnoreArg_indirectCommandsAddress() vkCmdDecompressMemoryIndirectCountNV_CMockIgnoreArg_indirectCommandsAddress(__LINE__) +void vkCmdDecompressMemoryIndirectCountNV_CMockIgnoreArg_indirectCommandsAddress(UNITY_LINE_TYPE cmock_line); +#define vkCmdDecompressMemoryIndirectCountNV_IgnoreArg_indirectCommandsCountAddress() vkCmdDecompressMemoryIndirectCountNV_CMockIgnoreArg_indirectCommandsCountAddress(__LINE__) +void vkCmdDecompressMemoryIndirectCountNV_CMockIgnoreArg_indirectCommandsCountAddress(UNITY_LINE_TYPE cmock_line); +#define vkCmdDecompressMemoryIndirectCountNV_IgnoreArg_stride() vkCmdDecompressMemoryIndirectCountNV_CMockIgnoreArg_stride(__LINE__) +void vkCmdDecompressMemoryIndirectCountNV_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetTessellationDomainOriginEXT_Ignore() vkCmdSetTessellationDomainOriginEXT_CMockIgnore() +void vkCmdSetTessellationDomainOriginEXT_CMockIgnore(void); +#define vkCmdSetTessellationDomainOriginEXT_StopIgnore() vkCmdSetTessellationDomainOriginEXT_CMockStopIgnore() +void vkCmdSetTessellationDomainOriginEXT_CMockStopIgnore(void); +#define vkCmdSetTessellationDomainOriginEXT_ExpectAnyArgs() vkCmdSetTessellationDomainOriginEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetTessellationDomainOriginEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetTessellationDomainOriginEXT_Expect(commandBuffer, domainOrigin) vkCmdSetTessellationDomainOriginEXT_CMockExpect(__LINE__, commandBuffer, domainOrigin) +void vkCmdSetTessellationDomainOriginEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin); +typedef void (* CMOCK_vkCmdSetTessellationDomainOriginEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin, int cmock_num_calls); +void vkCmdSetTessellationDomainOriginEXT_AddCallback(CMOCK_vkCmdSetTessellationDomainOriginEXT_CALLBACK Callback); +void vkCmdSetTessellationDomainOriginEXT_Stub(CMOCK_vkCmdSetTessellationDomainOriginEXT_CALLBACK Callback); +#define vkCmdSetTessellationDomainOriginEXT_StubWithCallback vkCmdSetTessellationDomainOriginEXT_AddCallback +#define vkCmdSetTessellationDomainOriginEXT_IgnoreArg_commandBuffer() vkCmdSetTessellationDomainOriginEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetTessellationDomainOriginEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetTessellationDomainOriginEXT_IgnoreArg_domainOrigin() vkCmdSetTessellationDomainOriginEXT_CMockIgnoreArg_domainOrigin(__LINE__) +void vkCmdSetTessellationDomainOriginEXT_CMockIgnoreArg_domainOrigin(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthClampEnableEXT_Ignore() vkCmdSetDepthClampEnableEXT_CMockIgnore() +void vkCmdSetDepthClampEnableEXT_CMockIgnore(void); +#define vkCmdSetDepthClampEnableEXT_StopIgnore() vkCmdSetDepthClampEnableEXT_CMockStopIgnore() +void vkCmdSetDepthClampEnableEXT_CMockStopIgnore(void); +#define vkCmdSetDepthClampEnableEXT_ExpectAnyArgs() vkCmdSetDepthClampEnableEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetDepthClampEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthClampEnableEXT_Expect(commandBuffer, depthClampEnable) vkCmdSetDepthClampEnableEXT_CMockExpect(__LINE__, commandBuffer, depthClampEnable) +void vkCmdSetDepthClampEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 depthClampEnable); +typedef void (* CMOCK_vkCmdSetDepthClampEnableEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable, int cmock_num_calls); +void vkCmdSetDepthClampEnableEXT_AddCallback(CMOCK_vkCmdSetDepthClampEnableEXT_CALLBACK Callback); +void vkCmdSetDepthClampEnableEXT_Stub(CMOCK_vkCmdSetDepthClampEnableEXT_CALLBACK Callback); +#define vkCmdSetDepthClampEnableEXT_StubWithCallback vkCmdSetDepthClampEnableEXT_AddCallback +#define vkCmdSetDepthClampEnableEXT_IgnoreArg_commandBuffer() vkCmdSetDepthClampEnableEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetDepthClampEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthClampEnableEXT_IgnoreArg_depthClampEnable() vkCmdSetDepthClampEnableEXT_CMockIgnoreArg_depthClampEnable(__LINE__) +void vkCmdSetDepthClampEnableEXT_CMockIgnoreArg_depthClampEnable(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetPolygonModeEXT_Ignore() vkCmdSetPolygonModeEXT_CMockIgnore() +void vkCmdSetPolygonModeEXT_CMockIgnore(void); +#define vkCmdSetPolygonModeEXT_StopIgnore() vkCmdSetPolygonModeEXT_CMockStopIgnore() +void vkCmdSetPolygonModeEXT_CMockStopIgnore(void); +#define vkCmdSetPolygonModeEXT_ExpectAnyArgs() vkCmdSetPolygonModeEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetPolygonModeEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetPolygonModeEXT_Expect(commandBuffer, polygonMode) vkCmdSetPolygonModeEXT_CMockExpect(__LINE__, commandBuffer, polygonMode) +void vkCmdSetPolygonModeEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkPolygonMode polygonMode); +typedef void (* CMOCK_vkCmdSetPolygonModeEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode, int cmock_num_calls); +void vkCmdSetPolygonModeEXT_AddCallback(CMOCK_vkCmdSetPolygonModeEXT_CALLBACK Callback); +void vkCmdSetPolygonModeEXT_Stub(CMOCK_vkCmdSetPolygonModeEXT_CALLBACK Callback); +#define vkCmdSetPolygonModeEXT_StubWithCallback vkCmdSetPolygonModeEXT_AddCallback +#define vkCmdSetPolygonModeEXT_IgnoreArg_commandBuffer() vkCmdSetPolygonModeEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetPolygonModeEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetPolygonModeEXT_IgnoreArg_polygonMode() vkCmdSetPolygonModeEXT_CMockIgnoreArg_polygonMode(__LINE__) +void vkCmdSetPolygonModeEXT_CMockIgnoreArg_polygonMode(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetRasterizationSamplesEXT_Ignore() vkCmdSetRasterizationSamplesEXT_CMockIgnore() +void vkCmdSetRasterizationSamplesEXT_CMockIgnore(void); +#define vkCmdSetRasterizationSamplesEXT_StopIgnore() vkCmdSetRasterizationSamplesEXT_CMockStopIgnore() +void vkCmdSetRasterizationSamplesEXT_CMockStopIgnore(void); +#define vkCmdSetRasterizationSamplesEXT_ExpectAnyArgs() vkCmdSetRasterizationSamplesEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetRasterizationSamplesEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetRasterizationSamplesEXT_Expect(commandBuffer, rasterizationSamples) vkCmdSetRasterizationSamplesEXT_CMockExpect(__LINE__, commandBuffer, rasterizationSamples) +void vkCmdSetRasterizationSamplesEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples); +typedef void (* CMOCK_vkCmdSetRasterizationSamplesEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples, int cmock_num_calls); +void vkCmdSetRasterizationSamplesEXT_AddCallback(CMOCK_vkCmdSetRasterizationSamplesEXT_CALLBACK Callback); +void vkCmdSetRasterizationSamplesEXT_Stub(CMOCK_vkCmdSetRasterizationSamplesEXT_CALLBACK Callback); +#define vkCmdSetRasterizationSamplesEXT_StubWithCallback vkCmdSetRasterizationSamplesEXT_AddCallback +#define vkCmdSetRasterizationSamplesEXT_IgnoreArg_commandBuffer() vkCmdSetRasterizationSamplesEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetRasterizationSamplesEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetRasterizationSamplesEXT_IgnoreArg_rasterizationSamples() vkCmdSetRasterizationSamplesEXT_CMockIgnoreArg_rasterizationSamples(__LINE__) +void vkCmdSetRasterizationSamplesEXT_CMockIgnoreArg_rasterizationSamples(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetSampleMaskEXT_Ignore() vkCmdSetSampleMaskEXT_CMockIgnore() +void vkCmdSetSampleMaskEXT_CMockIgnore(void); +#define vkCmdSetSampleMaskEXT_StopIgnore() vkCmdSetSampleMaskEXT_CMockStopIgnore() +void vkCmdSetSampleMaskEXT_CMockStopIgnore(void); +#define vkCmdSetSampleMaskEXT_ExpectAnyArgs() vkCmdSetSampleMaskEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetSampleMaskEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetSampleMaskEXT_Expect(commandBuffer, samples, pSampleMask) vkCmdSetSampleMaskEXT_CMockExpect(__LINE__, commandBuffer, samples, pSampleMask) +void vkCmdSetSampleMaskEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask); +typedef void (* CMOCK_vkCmdSetSampleMaskEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask, int cmock_num_calls); +void vkCmdSetSampleMaskEXT_AddCallback(CMOCK_vkCmdSetSampleMaskEXT_CALLBACK Callback); +void vkCmdSetSampleMaskEXT_Stub(CMOCK_vkCmdSetSampleMaskEXT_CALLBACK Callback); +#define vkCmdSetSampleMaskEXT_StubWithCallback vkCmdSetSampleMaskEXT_AddCallback +#define vkCmdSetSampleMaskEXT_IgnoreArg_commandBuffer() vkCmdSetSampleMaskEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetSampleMaskEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetSampleMaskEXT_IgnoreArg_samples() vkCmdSetSampleMaskEXT_CMockIgnoreArg_samples(__LINE__) +void vkCmdSetSampleMaskEXT_CMockIgnoreArg_samples(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetSampleMaskEXT_IgnoreArg_pSampleMask() vkCmdSetSampleMaskEXT_CMockIgnoreArg_pSampleMask(__LINE__) +void vkCmdSetSampleMaskEXT_CMockIgnoreArg_pSampleMask(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetAlphaToCoverageEnableEXT_Ignore() vkCmdSetAlphaToCoverageEnableEXT_CMockIgnore() +void vkCmdSetAlphaToCoverageEnableEXT_CMockIgnore(void); +#define vkCmdSetAlphaToCoverageEnableEXT_StopIgnore() vkCmdSetAlphaToCoverageEnableEXT_CMockStopIgnore() +void vkCmdSetAlphaToCoverageEnableEXT_CMockStopIgnore(void); +#define vkCmdSetAlphaToCoverageEnableEXT_ExpectAnyArgs() vkCmdSetAlphaToCoverageEnableEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetAlphaToCoverageEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetAlphaToCoverageEnableEXT_Expect(commandBuffer, alphaToCoverageEnable) vkCmdSetAlphaToCoverageEnableEXT_CMockExpect(__LINE__, commandBuffer, alphaToCoverageEnable) +void vkCmdSetAlphaToCoverageEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable); +typedef void (* CMOCK_vkCmdSetAlphaToCoverageEnableEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable, int cmock_num_calls); +void vkCmdSetAlphaToCoverageEnableEXT_AddCallback(CMOCK_vkCmdSetAlphaToCoverageEnableEXT_CALLBACK Callback); +void vkCmdSetAlphaToCoverageEnableEXT_Stub(CMOCK_vkCmdSetAlphaToCoverageEnableEXT_CALLBACK Callback); +#define vkCmdSetAlphaToCoverageEnableEXT_StubWithCallback vkCmdSetAlphaToCoverageEnableEXT_AddCallback +#define vkCmdSetAlphaToCoverageEnableEXT_IgnoreArg_commandBuffer() vkCmdSetAlphaToCoverageEnableEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetAlphaToCoverageEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetAlphaToCoverageEnableEXT_IgnoreArg_alphaToCoverageEnable() vkCmdSetAlphaToCoverageEnableEXT_CMockIgnoreArg_alphaToCoverageEnable(__LINE__) +void vkCmdSetAlphaToCoverageEnableEXT_CMockIgnoreArg_alphaToCoverageEnable(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetAlphaToOneEnableEXT_Ignore() vkCmdSetAlphaToOneEnableEXT_CMockIgnore() +void vkCmdSetAlphaToOneEnableEXT_CMockIgnore(void); +#define vkCmdSetAlphaToOneEnableEXT_StopIgnore() vkCmdSetAlphaToOneEnableEXT_CMockStopIgnore() +void vkCmdSetAlphaToOneEnableEXT_CMockStopIgnore(void); +#define vkCmdSetAlphaToOneEnableEXT_ExpectAnyArgs() vkCmdSetAlphaToOneEnableEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetAlphaToOneEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetAlphaToOneEnableEXT_Expect(commandBuffer, alphaToOneEnable) vkCmdSetAlphaToOneEnableEXT_CMockExpect(__LINE__, commandBuffer, alphaToOneEnable) +void vkCmdSetAlphaToOneEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable); +typedef void (* CMOCK_vkCmdSetAlphaToOneEnableEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable, int cmock_num_calls); +void vkCmdSetAlphaToOneEnableEXT_AddCallback(CMOCK_vkCmdSetAlphaToOneEnableEXT_CALLBACK Callback); +void vkCmdSetAlphaToOneEnableEXT_Stub(CMOCK_vkCmdSetAlphaToOneEnableEXT_CALLBACK Callback); +#define vkCmdSetAlphaToOneEnableEXT_StubWithCallback vkCmdSetAlphaToOneEnableEXT_AddCallback +#define vkCmdSetAlphaToOneEnableEXT_IgnoreArg_commandBuffer() vkCmdSetAlphaToOneEnableEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetAlphaToOneEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetAlphaToOneEnableEXT_IgnoreArg_alphaToOneEnable() vkCmdSetAlphaToOneEnableEXT_CMockIgnoreArg_alphaToOneEnable(__LINE__) +void vkCmdSetAlphaToOneEnableEXT_CMockIgnoreArg_alphaToOneEnable(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetLogicOpEnableEXT_Ignore() vkCmdSetLogicOpEnableEXT_CMockIgnore() +void vkCmdSetLogicOpEnableEXT_CMockIgnore(void); +#define vkCmdSetLogicOpEnableEXT_StopIgnore() vkCmdSetLogicOpEnableEXT_CMockStopIgnore() +void vkCmdSetLogicOpEnableEXT_CMockStopIgnore(void); +#define vkCmdSetLogicOpEnableEXT_ExpectAnyArgs() vkCmdSetLogicOpEnableEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetLogicOpEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetLogicOpEnableEXT_Expect(commandBuffer, logicOpEnable) vkCmdSetLogicOpEnableEXT_CMockExpect(__LINE__, commandBuffer, logicOpEnable) +void vkCmdSetLogicOpEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 logicOpEnable); +typedef void (* CMOCK_vkCmdSetLogicOpEnableEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable, int cmock_num_calls); +void vkCmdSetLogicOpEnableEXT_AddCallback(CMOCK_vkCmdSetLogicOpEnableEXT_CALLBACK Callback); +void vkCmdSetLogicOpEnableEXT_Stub(CMOCK_vkCmdSetLogicOpEnableEXT_CALLBACK Callback); +#define vkCmdSetLogicOpEnableEXT_StubWithCallback vkCmdSetLogicOpEnableEXT_AddCallback +#define vkCmdSetLogicOpEnableEXT_IgnoreArg_commandBuffer() vkCmdSetLogicOpEnableEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetLogicOpEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetLogicOpEnableEXT_IgnoreArg_logicOpEnable() vkCmdSetLogicOpEnableEXT_CMockIgnoreArg_logicOpEnable(__LINE__) +void vkCmdSetLogicOpEnableEXT_CMockIgnoreArg_logicOpEnable(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetColorBlendEnableEXT_Ignore() vkCmdSetColorBlendEnableEXT_CMockIgnore() +void vkCmdSetColorBlendEnableEXT_CMockIgnore(void); +#define vkCmdSetColorBlendEnableEXT_StopIgnore() vkCmdSetColorBlendEnableEXT_CMockStopIgnore() +void vkCmdSetColorBlendEnableEXT_CMockStopIgnore(void); +#define vkCmdSetColorBlendEnableEXT_ExpectAnyArgs() vkCmdSetColorBlendEnableEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetColorBlendEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetColorBlendEnableEXT_Expect(commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables) vkCmdSetColorBlendEnableEXT_CMockExpect(__LINE__, commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables) +void vkCmdSetColorBlendEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables); +typedef void (* CMOCK_vkCmdSetColorBlendEnableEXT_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables, int cmock_num_calls); +void vkCmdSetColorBlendEnableEXT_AddCallback(CMOCK_vkCmdSetColorBlendEnableEXT_CALLBACK Callback); +void vkCmdSetColorBlendEnableEXT_Stub(CMOCK_vkCmdSetColorBlendEnableEXT_CALLBACK Callback); +#define vkCmdSetColorBlendEnableEXT_StubWithCallback vkCmdSetColorBlendEnableEXT_AddCallback +#define vkCmdSetColorBlendEnableEXT_IgnoreArg_commandBuffer() vkCmdSetColorBlendEnableEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetColorBlendEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetColorBlendEnableEXT_IgnoreArg_firstAttachment() vkCmdSetColorBlendEnableEXT_CMockIgnoreArg_firstAttachment(__LINE__) +void vkCmdSetColorBlendEnableEXT_CMockIgnoreArg_firstAttachment(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetColorBlendEnableEXT_IgnoreArg_attachmentCount() vkCmdSetColorBlendEnableEXT_CMockIgnoreArg_attachmentCount(__LINE__) +void vkCmdSetColorBlendEnableEXT_CMockIgnoreArg_attachmentCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetColorBlendEnableEXT_IgnoreArg_pColorBlendEnables() vkCmdSetColorBlendEnableEXT_CMockIgnoreArg_pColorBlendEnables(__LINE__) +void vkCmdSetColorBlendEnableEXT_CMockIgnoreArg_pColorBlendEnables(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetColorBlendEquationEXT_Ignore() vkCmdSetColorBlendEquationEXT_CMockIgnore() +void vkCmdSetColorBlendEquationEXT_CMockIgnore(void); +#define vkCmdSetColorBlendEquationEXT_StopIgnore() vkCmdSetColorBlendEquationEXT_CMockStopIgnore() +void vkCmdSetColorBlendEquationEXT_CMockStopIgnore(void); +#define vkCmdSetColorBlendEquationEXT_ExpectAnyArgs() vkCmdSetColorBlendEquationEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetColorBlendEquationEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetColorBlendEquationEXT_Expect(commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations) vkCmdSetColorBlendEquationEXT_CMockExpect(__LINE__, commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations) +void vkCmdSetColorBlendEquationEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations); +typedef void (* CMOCK_vkCmdSetColorBlendEquationEXT_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations, int cmock_num_calls); +void vkCmdSetColorBlendEquationEXT_AddCallback(CMOCK_vkCmdSetColorBlendEquationEXT_CALLBACK Callback); +void vkCmdSetColorBlendEquationEXT_Stub(CMOCK_vkCmdSetColorBlendEquationEXT_CALLBACK Callback); +#define vkCmdSetColorBlendEquationEXT_StubWithCallback vkCmdSetColorBlendEquationEXT_AddCallback +#define vkCmdSetColorBlendEquationEXT_IgnoreArg_commandBuffer() vkCmdSetColorBlendEquationEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetColorBlendEquationEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetColorBlendEquationEXT_IgnoreArg_firstAttachment() vkCmdSetColorBlendEquationEXT_CMockIgnoreArg_firstAttachment(__LINE__) +void vkCmdSetColorBlendEquationEXT_CMockIgnoreArg_firstAttachment(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetColorBlendEquationEXT_IgnoreArg_attachmentCount() vkCmdSetColorBlendEquationEXT_CMockIgnoreArg_attachmentCount(__LINE__) +void vkCmdSetColorBlendEquationEXT_CMockIgnoreArg_attachmentCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetColorBlendEquationEXT_IgnoreArg_pColorBlendEquations() vkCmdSetColorBlendEquationEXT_CMockIgnoreArg_pColorBlendEquations(__LINE__) +void vkCmdSetColorBlendEquationEXT_CMockIgnoreArg_pColorBlendEquations(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetColorWriteMaskEXT_Ignore() vkCmdSetColorWriteMaskEXT_CMockIgnore() +void vkCmdSetColorWriteMaskEXT_CMockIgnore(void); +#define vkCmdSetColorWriteMaskEXT_StopIgnore() vkCmdSetColorWriteMaskEXT_CMockStopIgnore() +void vkCmdSetColorWriteMaskEXT_CMockStopIgnore(void); +#define vkCmdSetColorWriteMaskEXT_ExpectAnyArgs() vkCmdSetColorWriteMaskEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetColorWriteMaskEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetColorWriteMaskEXT_Expect(commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks) vkCmdSetColorWriteMaskEXT_CMockExpect(__LINE__, commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks) +void vkCmdSetColorWriteMaskEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks); +typedef void (* CMOCK_vkCmdSetColorWriteMaskEXT_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks, int cmock_num_calls); +void vkCmdSetColorWriteMaskEXT_AddCallback(CMOCK_vkCmdSetColorWriteMaskEXT_CALLBACK Callback); +void vkCmdSetColorWriteMaskEXT_Stub(CMOCK_vkCmdSetColorWriteMaskEXT_CALLBACK Callback); +#define vkCmdSetColorWriteMaskEXT_StubWithCallback vkCmdSetColorWriteMaskEXT_AddCallback +#define vkCmdSetColorWriteMaskEXT_IgnoreArg_commandBuffer() vkCmdSetColorWriteMaskEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetColorWriteMaskEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetColorWriteMaskEXT_IgnoreArg_firstAttachment() vkCmdSetColorWriteMaskEXT_CMockIgnoreArg_firstAttachment(__LINE__) +void vkCmdSetColorWriteMaskEXT_CMockIgnoreArg_firstAttachment(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetColorWriteMaskEXT_IgnoreArg_attachmentCount() vkCmdSetColorWriteMaskEXT_CMockIgnoreArg_attachmentCount(__LINE__) +void vkCmdSetColorWriteMaskEXT_CMockIgnoreArg_attachmentCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetColorWriteMaskEXT_IgnoreArg_pColorWriteMasks() vkCmdSetColorWriteMaskEXT_CMockIgnoreArg_pColorWriteMasks(__LINE__) +void vkCmdSetColorWriteMaskEXT_CMockIgnoreArg_pColorWriteMasks(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetRasterizationStreamEXT_Ignore() vkCmdSetRasterizationStreamEXT_CMockIgnore() +void vkCmdSetRasterizationStreamEXT_CMockIgnore(void); +#define vkCmdSetRasterizationStreamEXT_StopIgnore() vkCmdSetRasterizationStreamEXT_CMockStopIgnore() +void vkCmdSetRasterizationStreamEXT_CMockStopIgnore(void); +#define vkCmdSetRasterizationStreamEXT_ExpectAnyArgs() vkCmdSetRasterizationStreamEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetRasterizationStreamEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetRasterizationStreamEXT_Expect(commandBuffer, rasterizationStream) vkCmdSetRasterizationStreamEXT_CMockExpect(__LINE__, commandBuffer, rasterizationStream) +void vkCmdSetRasterizationStreamEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t rasterizationStream); +typedef void (* CMOCK_vkCmdSetRasterizationStreamEXT_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t rasterizationStream, int cmock_num_calls); +void vkCmdSetRasterizationStreamEXT_AddCallback(CMOCK_vkCmdSetRasterizationStreamEXT_CALLBACK Callback); +void vkCmdSetRasterizationStreamEXT_Stub(CMOCK_vkCmdSetRasterizationStreamEXT_CALLBACK Callback); +#define vkCmdSetRasterizationStreamEXT_StubWithCallback vkCmdSetRasterizationStreamEXT_AddCallback +#define vkCmdSetRasterizationStreamEXT_IgnoreArg_commandBuffer() vkCmdSetRasterizationStreamEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetRasterizationStreamEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetRasterizationStreamEXT_IgnoreArg_rasterizationStream() vkCmdSetRasterizationStreamEXT_CMockIgnoreArg_rasterizationStream(__LINE__) +void vkCmdSetRasterizationStreamEXT_CMockIgnoreArg_rasterizationStream(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetConservativeRasterizationModeEXT_Ignore() vkCmdSetConservativeRasterizationModeEXT_CMockIgnore() +void vkCmdSetConservativeRasterizationModeEXT_CMockIgnore(void); +#define vkCmdSetConservativeRasterizationModeEXT_StopIgnore() vkCmdSetConservativeRasterizationModeEXT_CMockStopIgnore() +void vkCmdSetConservativeRasterizationModeEXT_CMockStopIgnore(void); +#define vkCmdSetConservativeRasterizationModeEXT_ExpectAnyArgs() vkCmdSetConservativeRasterizationModeEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetConservativeRasterizationModeEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetConservativeRasterizationModeEXT_Expect(commandBuffer, conservativeRasterizationMode) vkCmdSetConservativeRasterizationModeEXT_CMockExpect(__LINE__, commandBuffer, conservativeRasterizationMode) +void vkCmdSetConservativeRasterizationModeEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode); +typedef void (* CMOCK_vkCmdSetConservativeRasterizationModeEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode, int cmock_num_calls); +void vkCmdSetConservativeRasterizationModeEXT_AddCallback(CMOCK_vkCmdSetConservativeRasterizationModeEXT_CALLBACK Callback); +void vkCmdSetConservativeRasterizationModeEXT_Stub(CMOCK_vkCmdSetConservativeRasterizationModeEXT_CALLBACK Callback); +#define vkCmdSetConservativeRasterizationModeEXT_StubWithCallback vkCmdSetConservativeRasterizationModeEXT_AddCallback +#define vkCmdSetConservativeRasterizationModeEXT_IgnoreArg_commandBuffer() vkCmdSetConservativeRasterizationModeEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetConservativeRasterizationModeEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetConservativeRasterizationModeEXT_IgnoreArg_conservativeRasterizationMode() vkCmdSetConservativeRasterizationModeEXT_CMockIgnoreArg_conservativeRasterizationMode(__LINE__) +void vkCmdSetConservativeRasterizationModeEXT_CMockIgnoreArg_conservativeRasterizationMode(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetExtraPrimitiveOverestimationSizeEXT_Ignore() vkCmdSetExtraPrimitiveOverestimationSizeEXT_CMockIgnore() +void vkCmdSetExtraPrimitiveOverestimationSizeEXT_CMockIgnore(void); +#define vkCmdSetExtraPrimitiveOverestimationSizeEXT_StopIgnore() vkCmdSetExtraPrimitiveOverestimationSizeEXT_CMockStopIgnore() +void vkCmdSetExtraPrimitiveOverestimationSizeEXT_CMockStopIgnore(void); +#define vkCmdSetExtraPrimitiveOverestimationSizeEXT_ExpectAnyArgs() vkCmdSetExtraPrimitiveOverestimationSizeEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetExtraPrimitiveOverestimationSizeEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetExtraPrimitiveOverestimationSizeEXT_Expect(commandBuffer, extraPrimitiveOverestimationSize) vkCmdSetExtraPrimitiveOverestimationSizeEXT_CMockExpect(__LINE__, commandBuffer, extraPrimitiveOverestimationSize) +void vkCmdSetExtraPrimitiveOverestimationSizeEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize); +typedef void (* CMOCK_vkCmdSetExtraPrimitiveOverestimationSizeEXT_CALLBACK)(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize, int cmock_num_calls); +void vkCmdSetExtraPrimitiveOverestimationSizeEXT_AddCallback(CMOCK_vkCmdSetExtraPrimitiveOverestimationSizeEXT_CALLBACK Callback); +void vkCmdSetExtraPrimitiveOverestimationSizeEXT_Stub(CMOCK_vkCmdSetExtraPrimitiveOverestimationSizeEXT_CALLBACK Callback); +#define vkCmdSetExtraPrimitiveOverestimationSizeEXT_StubWithCallback vkCmdSetExtraPrimitiveOverestimationSizeEXT_AddCallback +#define vkCmdSetExtraPrimitiveOverestimationSizeEXT_IgnoreArg_commandBuffer() vkCmdSetExtraPrimitiveOverestimationSizeEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetExtraPrimitiveOverestimationSizeEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetExtraPrimitiveOverestimationSizeEXT_IgnoreArg_extraPrimitiveOverestimationSize() vkCmdSetExtraPrimitiveOverestimationSizeEXT_CMockIgnoreArg_extraPrimitiveOverestimationSize(__LINE__) +void vkCmdSetExtraPrimitiveOverestimationSizeEXT_CMockIgnoreArg_extraPrimitiveOverestimationSize(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthClipEnableEXT_Ignore() vkCmdSetDepthClipEnableEXT_CMockIgnore() +void vkCmdSetDepthClipEnableEXT_CMockIgnore(void); +#define vkCmdSetDepthClipEnableEXT_StopIgnore() vkCmdSetDepthClipEnableEXT_CMockStopIgnore() +void vkCmdSetDepthClipEnableEXT_CMockStopIgnore(void); +#define vkCmdSetDepthClipEnableEXT_ExpectAnyArgs() vkCmdSetDepthClipEnableEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetDepthClipEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthClipEnableEXT_Expect(commandBuffer, depthClipEnable) vkCmdSetDepthClipEnableEXT_CMockExpect(__LINE__, commandBuffer, depthClipEnable) +void vkCmdSetDepthClipEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 depthClipEnable); +typedef void (* CMOCK_vkCmdSetDepthClipEnableEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable, int cmock_num_calls); +void vkCmdSetDepthClipEnableEXT_AddCallback(CMOCK_vkCmdSetDepthClipEnableEXT_CALLBACK Callback); +void vkCmdSetDepthClipEnableEXT_Stub(CMOCK_vkCmdSetDepthClipEnableEXT_CALLBACK Callback); +#define vkCmdSetDepthClipEnableEXT_StubWithCallback vkCmdSetDepthClipEnableEXT_AddCallback +#define vkCmdSetDepthClipEnableEXT_IgnoreArg_commandBuffer() vkCmdSetDepthClipEnableEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetDepthClipEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthClipEnableEXT_IgnoreArg_depthClipEnable() vkCmdSetDepthClipEnableEXT_CMockIgnoreArg_depthClipEnable(__LINE__) +void vkCmdSetDepthClipEnableEXT_CMockIgnoreArg_depthClipEnable(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetSampleLocationsEnableEXT_Ignore() vkCmdSetSampleLocationsEnableEXT_CMockIgnore() +void vkCmdSetSampleLocationsEnableEXT_CMockIgnore(void); +#define vkCmdSetSampleLocationsEnableEXT_StopIgnore() vkCmdSetSampleLocationsEnableEXT_CMockStopIgnore() +void vkCmdSetSampleLocationsEnableEXT_CMockStopIgnore(void); +#define vkCmdSetSampleLocationsEnableEXT_ExpectAnyArgs() vkCmdSetSampleLocationsEnableEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetSampleLocationsEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetSampleLocationsEnableEXT_Expect(commandBuffer, sampleLocationsEnable) vkCmdSetSampleLocationsEnableEXT_CMockExpect(__LINE__, commandBuffer, sampleLocationsEnable) +void vkCmdSetSampleLocationsEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable); +typedef void (* CMOCK_vkCmdSetSampleLocationsEnableEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable, int cmock_num_calls); +void vkCmdSetSampleLocationsEnableEXT_AddCallback(CMOCK_vkCmdSetSampleLocationsEnableEXT_CALLBACK Callback); +void vkCmdSetSampleLocationsEnableEXT_Stub(CMOCK_vkCmdSetSampleLocationsEnableEXT_CALLBACK Callback); +#define vkCmdSetSampleLocationsEnableEXT_StubWithCallback vkCmdSetSampleLocationsEnableEXT_AddCallback +#define vkCmdSetSampleLocationsEnableEXT_IgnoreArg_commandBuffer() vkCmdSetSampleLocationsEnableEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetSampleLocationsEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetSampleLocationsEnableEXT_IgnoreArg_sampleLocationsEnable() vkCmdSetSampleLocationsEnableEXT_CMockIgnoreArg_sampleLocationsEnable(__LINE__) +void vkCmdSetSampleLocationsEnableEXT_CMockIgnoreArg_sampleLocationsEnable(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetColorBlendAdvancedEXT_Ignore() vkCmdSetColorBlendAdvancedEXT_CMockIgnore() +void vkCmdSetColorBlendAdvancedEXT_CMockIgnore(void); +#define vkCmdSetColorBlendAdvancedEXT_StopIgnore() vkCmdSetColorBlendAdvancedEXT_CMockStopIgnore() +void vkCmdSetColorBlendAdvancedEXT_CMockStopIgnore(void); +#define vkCmdSetColorBlendAdvancedEXT_ExpectAnyArgs() vkCmdSetColorBlendAdvancedEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetColorBlendAdvancedEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetColorBlendAdvancedEXT_Expect(commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced) vkCmdSetColorBlendAdvancedEXT_CMockExpect(__LINE__, commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced) +void vkCmdSetColorBlendAdvancedEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced); +typedef void (* CMOCK_vkCmdSetColorBlendAdvancedEXT_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced, int cmock_num_calls); +void vkCmdSetColorBlendAdvancedEXT_AddCallback(CMOCK_vkCmdSetColorBlendAdvancedEXT_CALLBACK Callback); +void vkCmdSetColorBlendAdvancedEXT_Stub(CMOCK_vkCmdSetColorBlendAdvancedEXT_CALLBACK Callback); +#define vkCmdSetColorBlendAdvancedEXT_StubWithCallback vkCmdSetColorBlendAdvancedEXT_AddCallback +#define vkCmdSetColorBlendAdvancedEXT_IgnoreArg_commandBuffer() vkCmdSetColorBlendAdvancedEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetColorBlendAdvancedEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetColorBlendAdvancedEXT_IgnoreArg_firstAttachment() vkCmdSetColorBlendAdvancedEXT_CMockIgnoreArg_firstAttachment(__LINE__) +void vkCmdSetColorBlendAdvancedEXT_CMockIgnoreArg_firstAttachment(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetColorBlendAdvancedEXT_IgnoreArg_attachmentCount() vkCmdSetColorBlendAdvancedEXT_CMockIgnoreArg_attachmentCount(__LINE__) +void vkCmdSetColorBlendAdvancedEXT_CMockIgnoreArg_attachmentCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetColorBlendAdvancedEXT_IgnoreArg_pColorBlendAdvanced() vkCmdSetColorBlendAdvancedEXT_CMockIgnoreArg_pColorBlendAdvanced(__LINE__) +void vkCmdSetColorBlendAdvancedEXT_CMockIgnoreArg_pColorBlendAdvanced(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetProvokingVertexModeEXT_Ignore() vkCmdSetProvokingVertexModeEXT_CMockIgnore() +void vkCmdSetProvokingVertexModeEXT_CMockIgnore(void); +#define vkCmdSetProvokingVertexModeEXT_StopIgnore() vkCmdSetProvokingVertexModeEXT_CMockStopIgnore() +void vkCmdSetProvokingVertexModeEXT_CMockStopIgnore(void); +#define vkCmdSetProvokingVertexModeEXT_ExpectAnyArgs() vkCmdSetProvokingVertexModeEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetProvokingVertexModeEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetProvokingVertexModeEXT_Expect(commandBuffer, provokingVertexMode) vkCmdSetProvokingVertexModeEXT_CMockExpect(__LINE__, commandBuffer, provokingVertexMode) +void vkCmdSetProvokingVertexModeEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode); +typedef void (* CMOCK_vkCmdSetProvokingVertexModeEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode, int cmock_num_calls); +void vkCmdSetProvokingVertexModeEXT_AddCallback(CMOCK_vkCmdSetProvokingVertexModeEXT_CALLBACK Callback); +void vkCmdSetProvokingVertexModeEXT_Stub(CMOCK_vkCmdSetProvokingVertexModeEXT_CALLBACK Callback); +#define vkCmdSetProvokingVertexModeEXT_StubWithCallback vkCmdSetProvokingVertexModeEXT_AddCallback +#define vkCmdSetProvokingVertexModeEXT_IgnoreArg_commandBuffer() vkCmdSetProvokingVertexModeEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetProvokingVertexModeEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetProvokingVertexModeEXT_IgnoreArg_provokingVertexMode() vkCmdSetProvokingVertexModeEXT_CMockIgnoreArg_provokingVertexMode(__LINE__) +void vkCmdSetProvokingVertexModeEXT_CMockIgnoreArg_provokingVertexMode(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetLineRasterizationModeEXT_Ignore() vkCmdSetLineRasterizationModeEXT_CMockIgnore() +void vkCmdSetLineRasterizationModeEXT_CMockIgnore(void); +#define vkCmdSetLineRasterizationModeEXT_StopIgnore() vkCmdSetLineRasterizationModeEXT_CMockStopIgnore() +void vkCmdSetLineRasterizationModeEXT_CMockStopIgnore(void); +#define vkCmdSetLineRasterizationModeEXT_ExpectAnyArgs() vkCmdSetLineRasterizationModeEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetLineRasterizationModeEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetLineRasterizationModeEXT_Expect(commandBuffer, lineRasterizationMode) vkCmdSetLineRasterizationModeEXT_CMockExpect(__LINE__, commandBuffer, lineRasterizationMode) +void vkCmdSetLineRasterizationModeEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode); +typedef void (* CMOCK_vkCmdSetLineRasterizationModeEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode, int cmock_num_calls); +void vkCmdSetLineRasterizationModeEXT_AddCallback(CMOCK_vkCmdSetLineRasterizationModeEXT_CALLBACK Callback); +void vkCmdSetLineRasterizationModeEXT_Stub(CMOCK_vkCmdSetLineRasterizationModeEXT_CALLBACK Callback); +#define vkCmdSetLineRasterizationModeEXT_StubWithCallback vkCmdSetLineRasterizationModeEXT_AddCallback +#define vkCmdSetLineRasterizationModeEXT_IgnoreArg_commandBuffer() vkCmdSetLineRasterizationModeEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetLineRasterizationModeEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetLineRasterizationModeEXT_IgnoreArg_lineRasterizationMode() vkCmdSetLineRasterizationModeEXT_CMockIgnoreArg_lineRasterizationMode(__LINE__) +void vkCmdSetLineRasterizationModeEXT_CMockIgnoreArg_lineRasterizationMode(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetLineStippleEnableEXT_Ignore() vkCmdSetLineStippleEnableEXT_CMockIgnore() +void vkCmdSetLineStippleEnableEXT_CMockIgnore(void); +#define vkCmdSetLineStippleEnableEXT_StopIgnore() vkCmdSetLineStippleEnableEXT_CMockStopIgnore() +void vkCmdSetLineStippleEnableEXT_CMockStopIgnore(void); +#define vkCmdSetLineStippleEnableEXT_ExpectAnyArgs() vkCmdSetLineStippleEnableEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetLineStippleEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetLineStippleEnableEXT_Expect(commandBuffer, stippledLineEnable) vkCmdSetLineStippleEnableEXT_CMockExpect(__LINE__, commandBuffer, stippledLineEnable) +void vkCmdSetLineStippleEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable); +typedef void (* CMOCK_vkCmdSetLineStippleEnableEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable, int cmock_num_calls); +void vkCmdSetLineStippleEnableEXT_AddCallback(CMOCK_vkCmdSetLineStippleEnableEXT_CALLBACK Callback); +void vkCmdSetLineStippleEnableEXT_Stub(CMOCK_vkCmdSetLineStippleEnableEXT_CALLBACK Callback); +#define vkCmdSetLineStippleEnableEXT_StubWithCallback vkCmdSetLineStippleEnableEXT_AddCallback +#define vkCmdSetLineStippleEnableEXT_IgnoreArg_commandBuffer() vkCmdSetLineStippleEnableEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetLineStippleEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetLineStippleEnableEXT_IgnoreArg_stippledLineEnable() vkCmdSetLineStippleEnableEXT_CMockIgnoreArg_stippledLineEnable(__LINE__) +void vkCmdSetLineStippleEnableEXT_CMockIgnoreArg_stippledLineEnable(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthClipNegativeOneToOneEXT_Ignore() vkCmdSetDepthClipNegativeOneToOneEXT_CMockIgnore() +void vkCmdSetDepthClipNegativeOneToOneEXT_CMockIgnore(void); +#define vkCmdSetDepthClipNegativeOneToOneEXT_StopIgnore() vkCmdSetDepthClipNegativeOneToOneEXT_CMockStopIgnore() +void vkCmdSetDepthClipNegativeOneToOneEXT_CMockStopIgnore(void); +#define vkCmdSetDepthClipNegativeOneToOneEXT_ExpectAnyArgs() vkCmdSetDepthClipNegativeOneToOneEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetDepthClipNegativeOneToOneEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthClipNegativeOneToOneEXT_Expect(commandBuffer, negativeOneToOne) vkCmdSetDepthClipNegativeOneToOneEXT_CMockExpect(__LINE__, commandBuffer, negativeOneToOne) +void vkCmdSetDepthClipNegativeOneToOneEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne); +typedef void (* CMOCK_vkCmdSetDepthClipNegativeOneToOneEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne, int cmock_num_calls); +void vkCmdSetDepthClipNegativeOneToOneEXT_AddCallback(CMOCK_vkCmdSetDepthClipNegativeOneToOneEXT_CALLBACK Callback); +void vkCmdSetDepthClipNegativeOneToOneEXT_Stub(CMOCK_vkCmdSetDepthClipNegativeOneToOneEXT_CALLBACK Callback); +#define vkCmdSetDepthClipNegativeOneToOneEXT_StubWithCallback vkCmdSetDepthClipNegativeOneToOneEXT_AddCallback +#define vkCmdSetDepthClipNegativeOneToOneEXT_IgnoreArg_commandBuffer() vkCmdSetDepthClipNegativeOneToOneEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetDepthClipNegativeOneToOneEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetDepthClipNegativeOneToOneEXT_IgnoreArg_negativeOneToOne() vkCmdSetDepthClipNegativeOneToOneEXT_CMockIgnoreArg_negativeOneToOne(__LINE__) +void vkCmdSetDepthClipNegativeOneToOneEXT_CMockIgnoreArg_negativeOneToOne(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewportWScalingEnableNV_Ignore() vkCmdSetViewportWScalingEnableNV_CMockIgnore() +void vkCmdSetViewportWScalingEnableNV_CMockIgnore(void); +#define vkCmdSetViewportWScalingEnableNV_StopIgnore() vkCmdSetViewportWScalingEnableNV_CMockStopIgnore() +void vkCmdSetViewportWScalingEnableNV_CMockStopIgnore(void); +#define vkCmdSetViewportWScalingEnableNV_ExpectAnyArgs() vkCmdSetViewportWScalingEnableNV_CMockExpectAnyArgs(__LINE__) +void vkCmdSetViewportWScalingEnableNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewportWScalingEnableNV_Expect(commandBuffer, viewportWScalingEnable) vkCmdSetViewportWScalingEnableNV_CMockExpect(__LINE__, commandBuffer, viewportWScalingEnable) +void vkCmdSetViewportWScalingEnableNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable); +typedef void (* CMOCK_vkCmdSetViewportWScalingEnableNV_CALLBACK)(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable, int cmock_num_calls); +void vkCmdSetViewportWScalingEnableNV_AddCallback(CMOCK_vkCmdSetViewportWScalingEnableNV_CALLBACK Callback); +void vkCmdSetViewportWScalingEnableNV_Stub(CMOCK_vkCmdSetViewportWScalingEnableNV_CALLBACK Callback); +#define vkCmdSetViewportWScalingEnableNV_StubWithCallback vkCmdSetViewportWScalingEnableNV_AddCallback +#define vkCmdSetViewportWScalingEnableNV_IgnoreArg_commandBuffer() vkCmdSetViewportWScalingEnableNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetViewportWScalingEnableNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewportWScalingEnableNV_IgnoreArg_viewportWScalingEnable() vkCmdSetViewportWScalingEnableNV_CMockIgnoreArg_viewportWScalingEnable(__LINE__) +void vkCmdSetViewportWScalingEnableNV_CMockIgnoreArg_viewportWScalingEnable(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewportSwizzleNV_Ignore() vkCmdSetViewportSwizzleNV_CMockIgnore() +void vkCmdSetViewportSwizzleNV_CMockIgnore(void); +#define vkCmdSetViewportSwizzleNV_StopIgnore() vkCmdSetViewportSwizzleNV_CMockStopIgnore() +void vkCmdSetViewportSwizzleNV_CMockStopIgnore(void); +#define vkCmdSetViewportSwizzleNV_ExpectAnyArgs() vkCmdSetViewportSwizzleNV_CMockExpectAnyArgs(__LINE__) +void vkCmdSetViewportSwizzleNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewportSwizzleNV_Expect(commandBuffer, firstViewport, viewportCount, pViewportSwizzles) vkCmdSetViewportSwizzleNV_CMockExpect(__LINE__, commandBuffer, firstViewport, viewportCount, pViewportSwizzles) +void vkCmdSetViewportSwizzleNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles); +typedef void (* CMOCK_vkCmdSetViewportSwizzleNV_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles, int cmock_num_calls); +void vkCmdSetViewportSwizzleNV_AddCallback(CMOCK_vkCmdSetViewportSwizzleNV_CALLBACK Callback); +void vkCmdSetViewportSwizzleNV_Stub(CMOCK_vkCmdSetViewportSwizzleNV_CALLBACK Callback); +#define vkCmdSetViewportSwizzleNV_StubWithCallback vkCmdSetViewportSwizzleNV_AddCallback +#define vkCmdSetViewportSwizzleNV_IgnoreArg_commandBuffer() vkCmdSetViewportSwizzleNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetViewportSwizzleNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewportSwizzleNV_IgnoreArg_firstViewport() vkCmdSetViewportSwizzleNV_CMockIgnoreArg_firstViewport(__LINE__) +void vkCmdSetViewportSwizzleNV_CMockIgnoreArg_firstViewport(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewportSwizzleNV_IgnoreArg_viewportCount() vkCmdSetViewportSwizzleNV_CMockIgnoreArg_viewportCount(__LINE__) +void vkCmdSetViewportSwizzleNV_CMockIgnoreArg_viewportCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetViewportSwizzleNV_IgnoreArg_pViewportSwizzles() vkCmdSetViewportSwizzleNV_CMockIgnoreArg_pViewportSwizzles(__LINE__) +void vkCmdSetViewportSwizzleNV_CMockIgnoreArg_pViewportSwizzles(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCoverageToColorEnableNV_Ignore() vkCmdSetCoverageToColorEnableNV_CMockIgnore() +void vkCmdSetCoverageToColorEnableNV_CMockIgnore(void); +#define vkCmdSetCoverageToColorEnableNV_StopIgnore() vkCmdSetCoverageToColorEnableNV_CMockStopIgnore() +void vkCmdSetCoverageToColorEnableNV_CMockStopIgnore(void); +#define vkCmdSetCoverageToColorEnableNV_ExpectAnyArgs() vkCmdSetCoverageToColorEnableNV_CMockExpectAnyArgs(__LINE__) +void vkCmdSetCoverageToColorEnableNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCoverageToColorEnableNV_Expect(commandBuffer, coverageToColorEnable) vkCmdSetCoverageToColorEnableNV_CMockExpect(__LINE__, commandBuffer, coverageToColorEnable) +void vkCmdSetCoverageToColorEnableNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable); +typedef void (* CMOCK_vkCmdSetCoverageToColorEnableNV_CALLBACK)(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable, int cmock_num_calls); +void vkCmdSetCoverageToColorEnableNV_AddCallback(CMOCK_vkCmdSetCoverageToColorEnableNV_CALLBACK Callback); +void vkCmdSetCoverageToColorEnableNV_Stub(CMOCK_vkCmdSetCoverageToColorEnableNV_CALLBACK Callback); +#define vkCmdSetCoverageToColorEnableNV_StubWithCallback vkCmdSetCoverageToColorEnableNV_AddCallback +#define vkCmdSetCoverageToColorEnableNV_IgnoreArg_commandBuffer() vkCmdSetCoverageToColorEnableNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetCoverageToColorEnableNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCoverageToColorEnableNV_IgnoreArg_coverageToColorEnable() vkCmdSetCoverageToColorEnableNV_CMockIgnoreArg_coverageToColorEnable(__LINE__) +void vkCmdSetCoverageToColorEnableNV_CMockIgnoreArg_coverageToColorEnable(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCoverageToColorLocationNV_Ignore() vkCmdSetCoverageToColorLocationNV_CMockIgnore() +void vkCmdSetCoverageToColorLocationNV_CMockIgnore(void); +#define vkCmdSetCoverageToColorLocationNV_StopIgnore() vkCmdSetCoverageToColorLocationNV_CMockStopIgnore() +void vkCmdSetCoverageToColorLocationNV_CMockStopIgnore(void); +#define vkCmdSetCoverageToColorLocationNV_ExpectAnyArgs() vkCmdSetCoverageToColorLocationNV_CMockExpectAnyArgs(__LINE__) +void vkCmdSetCoverageToColorLocationNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCoverageToColorLocationNV_Expect(commandBuffer, coverageToColorLocation) vkCmdSetCoverageToColorLocationNV_CMockExpect(__LINE__, commandBuffer, coverageToColorLocation) +void vkCmdSetCoverageToColorLocationNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation); +typedef void (* CMOCK_vkCmdSetCoverageToColorLocationNV_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation, int cmock_num_calls); +void vkCmdSetCoverageToColorLocationNV_AddCallback(CMOCK_vkCmdSetCoverageToColorLocationNV_CALLBACK Callback); +void vkCmdSetCoverageToColorLocationNV_Stub(CMOCK_vkCmdSetCoverageToColorLocationNV_CALLBACK Callback); +#define vkCmdSetCoverageToColorLocationNV_StubWithCallback vkCmdSetCoverageToColorLocationNV_AddCallback +#define vkCmdSetCoverageToColorLocationNV_IgnoreArg_commandBuffer() vkCmdSetCoverageToColorLocationNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetCoverageToColorLocationNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCoverageToColorLocationNV_IgnoreArg_coverageToColorLocation() vkCmdSetCoverageToColorLocationNV_CMockIgnoreArg_coverageToColorLocation(__LINE__) +void vkCmdSetCoverageToColorLocationNV_CMockIgnoreArg_coverageToColorLocation(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCoverageModulationModeNV_Ignore() vkCmdSetCoverageModulationModeNV_CMockIgnore() +void vkCmdSetCoverageModulationModeNV_CMockIgnore(void); +#define vkCmdSetCoverageModulationModeNV_StopIgnore() vkCmdSetCoverageModulationModeNV_CMockStopIgnore() +void vkCmdSetCoverageModulationModeNV_CMockStopIgnore(void); +#define vkCmdSetCoverageModulationModeNV_ExpectAnyArgs() vkCmdSetCoverageModulationModeNV_CMockExpectAnyArgs(__LINE__) +void vkCmdSetCoverageModulationModeNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCoverageModulationModeNV_Expect(commandBuffer, coverageModulationMode) vkCmdSetCoverageModulationModeNV_CMockExpect(__LINE__, commandBuffer, coverageModulationMode) +void vkCmdSetCoverageModulationModeNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode); +typedef void (* CMOCK_vkCmdSetCoverageModulationModeNV_CALLBACK)(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode, int cmock_num_calls); +void vkCmdSetCoverageModulationModeNV_AddCallback(CMOCK_vkCmdSetCoverageModulationModeNV_CALLBACK Callback); +void vkCmdSetCoverageModulationModeNV_Stub(CMOCK_vkCmdSetCoverageModulationModeNV_CALLBACK Callback); +#define vkCmdSetCoverageModulationModeNV_StubWithCallback vkCmdSetCoverageModulationModeNV_AddCallback +#define vkCmdSetCoverageModulationModeNV_IgnoreArg_commandBuffer() vkCmdSetCoverageModulationModeNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetCoverageModulationModeNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCoverageModulationModeNV_IgnoreArg_coverageModulationMode() vkCmdSetCoverageModulationModeNV_CMockIgnoreArg_coverageModulationMode(__LINE__) +void vkCmdSetCoverageModulationModeNV_CMockIgnoreArg_coverageModulationMode(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCoverageModulationTableEnableNV_Ignore() vkCmdSetCoverageModulationTableEnableNV_CMockIgnore() +void vkCmdSetCoverageModulationTableEnableNV_CMockIgnore(void); +#define vkCmdSetCoverageModulationTableEnableNV_StopIgnore() vkCmdSetCoverageModulationTableEnableNV_CMockStopIgnore() +void vkCmdSetCoverageModulationTableEnableNV_CMockStopIgnore(void); +#define vkCmdSetCoverageModulationTableEnableNV_ExpectAnyArgs() vkCmdSetCoverageModulationTableEnableNV_CMockExpectAnyArgs(__LINE__) +void vkCmdSetCoverageModulationTableEnableNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCoverageModulationTableEnableNV_Expect(commandBuffer, coverageModulationTableEnable) vkCmdSetCoverageModulationTableEnableNV_CMockExpect(__LINE__, commandBuffer, coverageModulationTableEnable) +void vkCmdSetCoverageModulationTableEnableNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable); +typedef void (* CMOCK_vkCmdSetCoverageModulationTableEnableNV_CALLBACK)(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable, int cmock_num_calls); +void vkCmdSetCoverageModulationTableEnableNV_AddCallback(CMOCK_vkCmdSetCoverageModulationTableEnableNV_CALLBACK Callback); +void vkCmdSetCoverageModulationTableEnableNV_Stub(CMOCK_vkCmdSetCoverageModulationTableEnableNV_CALLBACK Callback); +#define vkCmdSetCoverageModulationTableEnableNV_StubWithCallback vkCmdSetCoverageModulationTableEnableNV_AddCallback +#define vkCmdSetCoverageModulationTableEnableNV_IgnoreArg_commandBuffer() vkCmdSetCoverageModulationTableEnableNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetCoverageModulationTableEnableNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCoverageModulationTableEnableNV_IgnoreArg_coverageModulationTableEnable() vkCmdSetCoverageModulationTableEnableNV_CMockIgnoreArg_coverageModulationTableEnable(__LINE__) +void vkCmdSetCoverageModulationTableEnableNV_CMockIgnoreArg_coverageModulationTableEnable(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCoverageModulationTableNV_Ignore() vkCmdSetCoverageModulationTableNV_CMockIgnore() +void vkCmdSetCoverageModulationTableNV_CMockIgnore(void); +#define vkCmdSetCoverageModulationTableNV_StopIgnore() vkCmdSetCoverageModulationTableNV_CMockStopIgnore() +void vkCmdSetCoverageModulationTableNV_CMockStopIgnore(void); +#define vkCmdSetCoverageModulationTableNV_ExpectAnyArgs() vkCmdSetCoverageModulationTableNV_CMockExpectAnyArgs(__LINE__) +void vkCmdSetCoverageModulationTableNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCoverageModulationTableNV_Expect(commandBuffer, coverageModulationTableCount, pCoverageModulationTable) vkCmdSetCoverageModulationTableNV_CMockExpect(__LINE__, commandBuffer, coverageModulationTableCount, pCoverageModulationTable) +void vkCmdSetCoverageModulationTableNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable); +typedef void (* CMOCK_vkCmdSetCoverageModulationTableNV_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable, int cmock_num_calls); +void vkCmdSetCoverageModulationTableNV_AddCallback(CMOCK_vkCmdSetCoverageModulationTableNV_CALLBACK Callback); +void vkCmdSetCoverageModulationTableNV_Stub(CMOCK_vkCmdSetCoverageModulationTableNV_CALLBACK Callback); +#define vkCmdSetCoverageModulationTableNV_StubWithCallback vkCmdSetCoverageModulationTableNV_AddCallback +#define vkCmdSetCoverageModulationTableNV_IgnoreArg_commandBuffer() vkCmdSetCoverageModulationTableNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetCoverageModulationTableNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCoverageModulationTableNV_IgnoreArg_coverageModulationTableCount() vkCmdSetCoverageModulationTableNV_CMockIgnoreArg_coverageModulationTableCount(__LINE__) +void vkCmdSetCoverageModulationTableNV_CMockIgnoreArg_coverageModulationTableCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCoverageModulationTableNV_IgnoreArg_pCoverageModulationTable() vkCmdSetCoverageModulationTableNV_CMockIgnoreArg_pCoverageModulationTable(__LINE__) +void vkCmdSetCoverageModulationTableNV_CMockIgnoreArg_pCoverageModulationTable(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetShadingRateImageEnableNV_Ignore() vkCmdSetShadingRateImageEnableNV_CMockIgnore() +void vkCmdSetShadingRateImageEnableNV_CMockIgnore(void); +#define vkCmdSetShadingRateImageEnableNV_StopIgnore() vkCmdSetShadingRateImageEnableNV_CMockStopIgnore() +void vkCmdSetShadingRateImageEnableNV_CMockStopIgnore(void); +#define vkCmdSetShadingRateImageEnableNV_ExpectAnyArgs() vkCmdSetShadingRateImageEnableNV_CMockExpectAnyArgs(__LINE__) +void vkCmdSetShadingRateImageEnableNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetShadingRateImageEnableNV_Expect(commandBuffer, shadingRateImageEnable) vkCmdSetShadingRateImageEnableNV_CMockExpect(__LINE__, commandBuffer, shadingRateImageEnable) +void vkCmdSetShadingRateImageEnableNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable); +typedef void (* CMOCK_vkCmdSetShadingRateImageEnableNV_CALLBACK)(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable, int cmock_num_calls); +void vkCmdSetShadingRateImageEnableNV_AddCallback(CMOCK_vkCmdSetShadingRateImageEnableNV_CALLBACK Callback); +void vkCmdSetShadingRateImageEnableNV_Stub(CMOCK_vkCmdSetShadingRateImageEnableNV_CALLBACK Callback); +#define vkCmdSetShadingRateImageEnableNV_StubWithCallback vkCmdSetShadingRateImageEnableNV_AddCallback +#define vkCmdSetShadingRateImageEnableNV_IgnoreArg_commandBuffer() vkCmdSetShadingRateImageEnableNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetShadingRateImageEnableNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetShadingRateImageEnableNV_IgnoreArg_shadingRateImageEnable() vkCmdSetShadingRateImageEnableNV_CMockIgnoreArg_shadingRateImageEnable(__LINE__) +void vkCmdSetShadingRateImageEnableNV_CMockIgnoreArg_shadingRateImageEnable(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetRepresentativeFragmentTestEnableNV_Ignore() vkCmdSetRepresentativeFragmentTestEnableNV_CMockIgnore() +void vkCmdSetRepresentativeFragmentTestEnableNV_CMockIgnore(void); +#define vkCmdSetRepresentativeFragmentTestEnableNV_StopIgnore() vkCmdSetRepresentativeFragmentTestEnableNV_CMockStopIgnore() +void vkCmdSetRepresentativeFragmentTestEnableNV_CMockStopIgnore(void); +#define vkCmdSetRepresentativeFragmentTestEnableNV_ExpectAnyArgs() vkCmdSetRepresentativeFragmentTestEnableNV_CMockExpectAnyArgs(__LINE__) +void vkCmdSetRepresentativeFragmentTestEnableNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetRepresentativeFragmentTestEnableNV_Expect(commandBuffer, representativeFragmentTestEnable) vkCmdSetRepresentativeFragmentTestEnableNV_CMockExpect(__LINE__, commandBuffer, representativeFragmentTestEnable) +void vkCmdSetRepresentativeFragmentTestEnableNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable); +typedef void (* CMOCK_vkCmdSetRepresentativeFragmentTestEnableNV_CALLBACK)(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable, int cmock_num_calls); +void vkCmdSetRepresentativeFragmentTestEnableNV_AddCallback(CMOCK_vkCmdSetRepresentativeFragmentTestEnableNV_CALLBACK Callback); +void vkCmdSetRepresentativeFragmentTestEnableNV_Stub(CMOCK_vkCmdSetRepresentativeFragmentTestEnableNV_CALLBACK Callback); +#define vkCmdSetRepresentativeFragmentTestEnableNV_StubWithCallback vkCmdSetRepresentativeFragmentTestEnableNV_AddCallback +#define vkCmdSetRepresentativeFragmentTestEnableNV_IgnoreArg_commandBuffer() vkCmdSetRepresentativeFragmentTestEnableNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetRepresentativeFragmentTestEnableNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetRepresentativeFragmentTestEnableNV_IgnoreArg_representativeFragmentTestEnable() vkCmdSetRepresentativeFragmentTestEnableNV_CMockIgnoreArg_representativeFragmentTestEnable(__LINE__) +void vkCmdSetRepresentativeFragmentTestEnableNV_CMockIgnoreArg_representativeFragmentTestEnable(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCoverageReductionModeNV_Ignore() vkCmdSetCoverageReductionModeNV_CMockIgnore() +void vkCmdSetCoverageReductionModeNV_CMockIgnore(void); +#define vkCmdSetCoverageReductionModeNV_StopIgnore() vkCmdSetCoverageReductionModeNV_CMockStopIgnore() +void vkCmdSetCoverageReductionModeNV_CMockStopIgnore(void); +#define vkCmdSetCoverageReductionModeNV_ExpectAnyArgs() vkCmdSetCoverageReductionModeNV_CMockExpectAnyArgs(__LINE__) +void vkCmdSetCoverageReductionModeNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCoverageReductionModeNV_Expect(commandBuffer, coverageReductionMode) vkCmdSetCoverageReductionModeNV_CMockExpect(__LINE__, commandBuffer, coverageReductionMode) +void vkCmdSetCoverageReductionModeNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode); +typedef void (* CMOCK_vkCmdSetCoverageReductionModeNV_CALLBACK)(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode, int cmock_num_calls); +void vkCmdSetCoverageReductionModeNV_AddCallback(CMOCK_vkCmdSetCoverageReductionModeNV_CALLBACK Callback); +void vkCmdSetCoverageReductionModeNV_Stub(CMOCK_vkCmdSetCoverageReductionModeNV_CALLBACK Callback); +#define vkCmdSetCoverageReductionModeNV_StubWithCallback vkCmdSetCoverageReductionModeNV_AddCallback +#define vkCmdSetCoverageReductionModeNV_IgnoreArg_commandBuffer() vkCmdSetCoverageReductionModeNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetCoverageReductionModeNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetCoverageReductionModeNV_IgnoreArg_coverageReductionMode() vkCmdSetCoverageReductionModeNV_CMockIgnoreArg_coverageReductionMode(__LINE__) +void vkCmdSetCoverageReductionModeNV_CMockIgnoreArg_coverageReductionMode(UNITY_LINE_TYPE cmock_line); +#define vkGetShaderModuleIdentifierEXT_Ignore() vkGetShaderModuleIdentifierEXT_CMockIgnore() +void vkGetShaderModuleIdentifierEXT_CMockIgnore(void); +#define vkGetShaderModuleIdentifierEXT_StopIgnore() vkGetShaderModuleIdentifierEXT_CMockStopIgnore() +void vkGetShaderModuleIdentifierEXT_CMockStopIgnore(void); +#define vkGetShaderModuleIdentifierEXT_ExpectAnyArgs() vkGetShaderModuleIdentifierEXT_CMockExpectAnyArgs(__LINE__) +void vkGetShaderModuleIdentifierEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetShaderModuleIdentifierEXT_Expect(device, shaderModule, pIdentifier) vkGetShaderModuleIdentifierEXT_CMockExpect(__LINE__, device, shaderModule, pIdentifier) +void vkGetShaderModuleIdentifierEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier); +typedef void (* CMOCK_vkGetShaderModuleIdentifierEXT_CALLBACK)(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier, int cmock_num_calls); +void vkGetShaderModuleIdentifierEXT_AddCallback(CMOCK_vkGetShaderModuleIdentifierEXT_CALLBACK Callback); +void vkGetShaderModuleIdentifierEXT_Stub(CMOCK_vkGetShaderModuleIdentifierEXT_CALLBACK Callback); +#define vkGetShaderModuleIdentifierEXT_StubWithCallback vkGetShaderModuleIdentifierEXT_AddCallback +#define vkGetShaderModuleIdentifierEXT_ReturnThruPtr_pIdentifier(pIdentifier) vkGetShaderModuleIdentifierEXT_CMockReturnMemThruPtr_pIdentifier(__LINE__, pIdentifier, sizeof(VkShaderModuleIdentifierEXT)) +#define vkGetShaderModuleIdentifierEXT_ReturnArrayThruPtr_pIdentifier(pIdentifier, cmock_len) vkGetShaderModuleIdentifierEXT_CMockReturnMemThruPtr_pIdentifier(__LINE__, pIdentifier, cmock_len * sizeof(*pIdentifier)) +#define vkGetShaderModuleIdentifierEXT_ReturnMemThruPtr_pIdentifier(pIdentifier, cmock_size) vkGetShaderModuleIdentifierEXT_CMockReturnMemThruPtr_pIdentifier(__LINE__, pIdentifier, cmock_size) +void vkGetShaderModuleIdentifierEXT_CMockReturnMemThruPtr_pIdentifier(UNITY_LINE_TYPE cmock_line, VkShaderModuleIdentifierEXT const* pIdentifier, size_t cmock_size); +#define vkGetShaderModuleIdentifierEXT_IgnoreArg_device() vkGetShaderModuleIdentifierEXT_CMockIgnoreArg_device(__LINE__) +void vkGetShaderModuleIdentifierEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetShaderModuleIdentifierEXT_IgnoreArg_shaderModule() vkGetShaderModuleIdentifierEXT_CMockIgnoreArg_shaderModule(__LINE__) +void vkGetShaderModuleIdentifierEXT_CMockIgnoreArg_shaderModule(UNITY_LINE_TYPE cmock_line); +#define vkGetShaderModuleIdentifierEXT_IgnoreArg_pIdentifier() vkGetShaderModuleIdentifierEXT_CMockIgnoreArg_pIdentifier(__LINE__) +void vkGetShaderModuleIdentifierEXT_CMockIgnoreArg_pIdentifier(UNITY_LINE_TYPE cmock_line); +#define vkGetShaderModuleCreateInfoIdentifierEXT_Ignore() vkGetShaderModuleCreateInfoIdentifierEXT_CMockIgnore() +void vkGetShaderModuleCreateInfoIdentifierEXT_CMockIgnore(void); +#define vkGetShaderModuleCreateInfoIdentifierEXT_StopIgnore() vkGetShaderModuleCreateInfoIdentifierEXT_CMockStopIgnore() +void vkGetShaderModuleCreateInfoIdentifierEXT_CMockStopIgnore(void); +#define vkGetShaderModuleCreateInfoIdentifierEXT_ExpectAnyArgs() vkGetShaderModuleCreateInfoIdentifierEXT_CMockExpectAnyArgs(__LINE__) +void vkGetShaderModuleCreateInfoIdentifierEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetShaderModuleCreateInfoIdentifierEXT_Expect(device, pCreateInfo, pIdentifier) vkGetShaderModuleCreateInfoIdentifierEXT_CMockExpect(__LINE__, device, pCreateInfo, pIdentifier) +void vkGetShaderModuleCreateInfoIdentifierEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier); +typedef void (* CMOCK_vkGetShaderModuleCreateInfoIdentifierEXT_CALLBACK)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier, int cmock_num_calls); +void vkGetShaderModuleCreateInfoIdentifierEXT_AddCallback(CMOCK_vkGetShaderModuleCreateInfoIdentifierEXT_CALLBACK Callback); +void vkGetShaderModuleCreateInfoIdentifierEXT_Stub(CMOCK_vkGetShaderModuleCreateInfoIdentifierEXT_CALLBACK Callback); +#define vkGetShaderModuleCreateInfoIdentifierEXT_StubWithCallback vkGetShaderModuleCreateInfoIdentifierEXT_AddCallback +#define vkGetShaderModuleCreateInfoIdentifierEXT_ReturnThruPtr_pIdentifier(pIdentifier) vkGetShaderModuleCreateInfoIdentifierEXT_CMockReturnMemThruPtr_pIdentifier(__LINE__, pIdentifier, sizeof(VkShaderModuleIdentifierEXT)) +#define vkGetShaderModuleCreateInfoIdentifierEXT_ReturnArrayThruPtr_pIdentifier(pIdentifier, cmock_len) vkGetShaderModuleCreateInfoIdentifierEXT_CMockReturnMemThruPtr_pIdentifier(__LINE__, pIdentifier, cmock_len * sizeof(*pIdentifier)) +#define vkGetShaderModuleCreateInfoIdentifierEXT_ReturnMemThruPtr_pIdentifier(pIdentifier, cmock_size) vkGetShaderModuleCreateInfoIdentifierEXT_CMockReturnMemThruPtr_pIdentifier(__LINE__, pIdentifier, cmock_size) +void vkGetShaderModuleCreateInfoIdentifierEXT_CMockReturnMemThruPtr_pIdentifier(UNITY_LINE_TYPE cmock_line, VkShaderModuleIdentifierEXT const* pIdentifier, size_t cmock_size); +#define vkGetShaderModuleCreateInfoIdentifierEXT_IgnoreArg_device() vkGetShaderModuleCreateInfoIdentifierEXT_CMockIgnoreArg_device(__LINE__) +void vkGetShaderModuleCreateInfoIdentifierEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetShaderModuleCreateInfoIdentifierEXT_IgnoreArg_pCreateInfo() vkGetShaderModuleCreateInfoIdentifierEXT_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkGetShaderModuleCreateInfoIdentifierEXT_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetShaderModuleCreateInfoIdentifierEXT_IgnoreArg_pIdentifier() vkGetShaderModuleCreateInfoIdentifierEXT_CMockIgnoreArg_pIdentifier(__LINE__) +void vkGetShaderModuleCreateInfoIdentifierEXT_CMockIgnoreArg_pIdentifier(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceOpticalFlowImageFormatsNV_IgnoreAndReturn(cmock_retval) vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceOpticalFlowImageFormatsNV_StopIgnore() vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockStopIgnore() +void vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockStopIgnore(void); +#define vkGetPhysicalDeviceOpticalFlowImageFormatsNV_ExpectAnyArgsAndReturn(cmock_retval) vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetPhysicalDeviceOpticalFlowImageFormatsNV_ExpectAndReturn(physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties, cmock_retval) vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockExpectAndReturn(__LINE__, physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties, cmock_retval) +void vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALLBACK)(VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties, int cmock_num_calls); +void vkGetPhysicalDeviceOpticalFlowImageFormatsNV_AddCallback(CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALLBACK Callback); +void vkGetPhysicalDeviceOpticalFlowImageFormatsNV_Stub(CMOCK_vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CALLBACK Callback); +#define vkGetPhysicalDeviceOpticalFlowImageFormatsNV_StubWithCallback vkGetPhysicalDeviceOpticalFlowImageFormatsNV_AddCallback +#define vkGetPhysicalDeviceOpticalFlowImageFormatsNV_ReturnThruPtr_pFormatCount(pFormatCount) vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockReturnMemThruPtr_pFormatCount(__LINE__, pFormatCount, sizeof(uint32_t)) +#define vkGetPhysicalDeviceOpticalFlowImageFormatsNV_ReturnArrayThruPtr_pFormatCount(pFormatCount, cmock_len) vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockReturnMemThruPtr_pFormatCount(__LINE__, pFormatCount, cmock_len * sizeof(*pFormatCount)) +#define vkGetPhysicalDeviceOpticalFlowImageFormatsNV_ReturnMemThruPtr_pFormatCount(pFormatCount, cmock_size) vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockReturnMemThruPtr_pFormatCount(__LINE__, pFormatCount, cmock_size) +void vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockReturnMemThruPtr_pFormatCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pFormatCount, size_t cmock_size); +#define vkGetPhysicalDeviceOpticalFlowImageFormatsNV_ReturnThruPtr_pImageFormatProperties(pImageFormatProperties) vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockReturnMemThruPtr_pImageFormatProperties(__LINE__, pImageFormatProperties, sizeof(VkOpticalFlowImageFormatPropertiesNV)) +#define vkGetPhysicalDeviceOpticalFlowImageFormatsNV_ReturnArrayThruPtr_pImageFormatProperties(pImageFormatProperties, cmock_len) vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockReturnMemThruPtr_pImageFormatProperties(__LINE__, pImageFormatProperties, cmock_len * sizeof(*pImageFormatProperties)) +#define vkGetPhysicalDeviceOpticalFlowImageFormatsNV_ReturnMemThruPtr_pImageFormatProperties(pImageFormatProperties, cmock_size) vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockReturnMemThruPtr_pImageFormatProperties(__LINE__, pImageFormatProperties, cmock_size) +void vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockReturnMemThruPtr_pImageFormatProperties(UNITY_LINE_TYPE cmock_line, VkOpticalFlowImageFormatPropertiesNV const* pImageFormatProperties, size_t cmock_size); +#define vkGetPhysicalDeviceOpticalFlowImageFormatsNV_IgnoreArg_physicalDevice() vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockIgnoreArg_physicalDevice(__LINE__) +void vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockIgnoreArg_physicalDevice(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceOpticalFlowImageFormatsNV_IgnoreArg_pOpticalFlowImageFormatInfo() vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockIgnoreArg_pOpticalFlowImageFormatInfo(__LINE__) +void vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockIgnoreArg_pOpticalFlowImageFormatInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceOpticalFlowImageFormatsNV_IgnoreArg_pFormatCount() vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockIgnoreArg_pFormatCount(__LINE__) +void vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockIgnoreArg_pFormatCount(UNITY_LINE_TYPE cmock_line); +#define vkGetPhysicalDeviceOpticalFlowImageFormatsNV_IgnoreArg_pImageFormatProperties() vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockIgnoreArg_pImageFormatProperties(__LINE__) +void vkGetPhysicalDeviceOpticalFlowImageFormatsNV_CMockIgnoreArg_pImageFormatProperties(UNITY_LINE_TYPE cmock_line); +#define vkCreateOpticalFlowSessionNV_IgnoreAndReturn(cmock_retval) vkCreateOpticalFlowSessionNV_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateOpticalFlowSessionNV_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateOpticalFlowSessionNV_StopIgnore() vkCreateOpticalFlowSessionNV_CMockStopIgnore() +void vkCreateOpticalFlowSessionNV_CMockStopIgnore(void); +#define vkCreateOpticalFlowSessionNV_ExpectAnyArgsAndReturn(cmock_retval) vkCreateOpticalFlowSessionNV_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateOpticalFlowSessionNV_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateOpticalFlowSessionNV_ExpectAndReturn(device, pCreateInfo, pAllocator, pSession, cmock_retval) vkCreateOpticalFlowSessionNV_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pSession, cmock_retval) +void vkCreateOpticalFlowSessionNV_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkOpticalFlowSessionNV* pSession, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateOpticalFlowSessionNV_CALLBACK)(VkDevice device, const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkOpticalFlowSessionNV* pSession, int cmock_num_calls); +void vkCreateOpticalFlowSessionNV_AddCallback(CMOCK_vkCreateOpticalFlowSessionNV_CALLBACK Callback); +void vkCreateOpticalFlowSessionNV_Stub(CMOCK_vkCreateOpticalFlowSessionNV_CALLBACK Callback); +#define vkCreateOpticalFlowSessionNV_StubWithCallback vkCreateOpticalFlowSessionNV_AddCallback +#define vkCreateOpticalFlowSessionNV_ReturnThruPtr_pSession(pSession) vkCreateOpticalFlowSessionNV_CMockReturnMemThruPtr_pSession(__LINE__, pSession, sizeof(VkOpticalFlowSessionNV)) +#define vkCreateOpticalFlowSessionNV_ReturnArrayThruPtr_pSession(pSession, cmock_len) vkCreateOpticalFlowSessionNV_CMockReturnMemThruPtr_pSession(__LINE__, pSession, cmock_len * sizeof(*pSession)) +#define vkCreateOpticalFlowSessionNV_ReturnMemThruPtr_pSession(pSession, cmock_size) vkCreateOpticalFlowSessionNV_CMockReturnMemThruPtr_pSession(__LINE__, pSession, cmock_size) +void vkCreateOpticalFlowSessionNV_CMockReturnMemThruPtr_pSession(UNITY_LINE_TYPE cmock_line, VkOpticalFlowSessionNV const* pSession, size_t cmock_size); +#define vkCreateOpticalFlowSessionNV_IgnoreArg_device() vkCreateOpticalFlowSessionNV_CMockIgnoreArg_device(__LINE__) +void vkCreateOpticalFlowSessionNV_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateOpticalFlowSessionNV_IgnoreArg_pCreateInfo() vkCreateOpticalFlowSessionNV_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateOpticalFlowSessionNV_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateOpticalFlowSessionNV_IgnoreArg_pAllocator() vkCreateOpticalFlowSessionNV_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateOpticalFlowSessionNV_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateOpticalFlowSessionNV_IgnoreArg_pSession() vkCreateOpticalFlowSessionNV_CMockIgnoreArg_pSession(__LINE__) +void vkCreateOpticalFlowSessionNV_CMockIgnoreArg_pSession(UNITY_LINE_TYPE cmock_line); +#define vkDestroyOpticalFlowSessionNV_Ignore() vkDestroyOpticalFlowSessionNV_CMockIgnore() +void vkDestroyOpticalFlowSessionNV_CMockIgnore(void); +#define vkDestroyOpticalFlowSessionNV_StopIgnore() vkDestroyOpticalFlowSessionNV_CMockStopIgnore() +void vkDestroyOpticalFlowSessionNV_CMockStopIgnore(void); +#define vkDestroyOpticalFlowSessionNV_ExpectAnyArgs() vkDestroyOpticalFlowSessionNV_CMockExpectAnyArgs(__LINE__) +void vkDestroyOpticalFlowSessionNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyOpticalFlowSessionNV_Expect(device, session, pAllocator) vkDestroyOpticalFlowSessionNV_CMockExpect(__LINE__, device, session, pAllocator) +void vkDestroyOpticalFlowSessionNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyOpticalFlowSessionNV_CALLBACK)(VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyOpticalFlowSessionNV_AddCallback(CMOCK_vkDestroyOpticalFlowSessionNV_CALLBACK Callback); +void vkDestroyOpticalFlowSessionNV_Stub(CMOCK_vkDestroyOpticalFlowSessionNV_CALLBACK Callback); +#define vkDestroyOpticalFlowSessionNV_StubWithCallback vkDestroyOpticalFlowSessionNV_AddCallback +#define vkDestroyOpticalFlowSessionNV_IgnoreArg_device() vkDestroyOpticalFlowSessionNV_CMockIgnoreArg_device(__LINE__) +void vkDestroyOpticalFlowSessionNV_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyOpticalFlowSessionNV_IgnoreArg_session() vkDestroyOpticalFlowSessionNV_CMockIgnoreArg_session(__LINE__) +void vkDestroyOpticalFlowSessionNV_CMockIgnoreArg_session(UNITY_LINE_TYPE cmock_line); +#define vkDestroyOpticalFlowSessionNV_IgnoreArg_pAllocator() vkDestroyOpticalFlowSessionNV_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyOpticalFlowSessionNV_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkBindOpticalFlowSessionImageNV_IgnoreAndReturn(cmock_retval) vkBindOpticalFlowSessionImageNV_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkBindOpticalFlowSessionImageNV_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkBindOpticalFlowSessionImageNV_StopIgnore() vkBindOpticalFlowSessionImageNV_CMockStopIgnore() +void vkBindOpticalFlowSessionImageNV_CMockStopIgnore(void); +#define vkBindOpticalFlowSessionImageNV_ExpectAnyArgsAndReturn(cmock_retval) vkBindOpticalFlowSessionImageNV_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkBindOpticalFlowSessionImageNV_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkBindOpticalFlowSessionImageNV_ExpectAndReturn(device, session, bindingPoint, view, layout, cmock_retval) vkBindOpticalFlowSessionImageNV_CMockExpectAndReturn(__LINE__, device, session, bindingPoint, view, layout, cmock_retval) +void vkBindOpticalFlowSessionImageNV_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkBindOpticalFlowSessionImageNV_CALLBACK)(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout, int cmock_num_calls); +void vkBindOpticalFlowSessionImageNV_AddCallback(CMOCK_vkBindOpticalFlowSessionImageNV_CALLBACK Callback); +void vkBindOpticalFlowSessionImageNV_Stub(CMOCK_vkBindOpticalFlowSessionImageNV_CALLBACK Callback); +#define vkBindOpticalFlowSessionImageNV_StubWithCallback vkBindOpticalFlowSessionImageNV_AddCallback +#define vkBindOpticalFlowSessionImageNV_IgnoreArg_device() vkBindOpticalFlowSessionImageNV_CMockIgnoreArg_device(__LINE__) +void vkBindOpticalFlowSessionImageNV_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkBindOpticalFlowSessionImageNV_IgnoreArg_session() vkBindOpticalFlowSessionImageNV_CMockIgnoreArg_session(__LINE__) +void vkBindOpticalFlowSessionImageNV_CMockIgnoreArg_session(UNITY_LINE_TYPE cmock_line); +#define vkBindOpticalFlowSessionImageNV_IgnoreArg_bindingPoint() vkBindOpticalFlowSessionImageNV_CMockIgnoreArg_bindingPoint(__LINE__) +void vkBindOpticalFlowSessionImageNV_CMockIgnoreArg_bindingPoint(UNITY_LINE_TYPE cmock_line); +#define vkBindOpticalFlowSessionImageNV_IgnoreArg_view() vkBindOpticalFlowSessionImageNV_CMockIgnoreArg_view(__LINE__) +void vkBindOpticalFlowSessionImageNV_CMockIgnoreArg_view(UNITY_LINE_TYPE cmock_line); +#define vkBindOpticalFlowSessionImageNV_IgnoreArg_layout() vkBindOpticalFlowSessionImageNV_CMockIgnoreArg_layout(__LINE__) +void vkBindOpticalFlowSessionImageNV_CMockIgnoreArg_layout(UNITY_LINE_TYPE cmock_line); +#define vkCmdOpticalFlowExecuteNV_Ignore() vkCmdOpticalFlowExecuteNV_CMockIgnore() +void vkCmdOpticalFlowExecuteNV_CMockIgnore(void); +#define vkCmdOpticalFlowExecuteNV_StopIgnore() vkCmdOpticalFlowExecuteNV_CMockStopIgnore() +void vkCmdOpticalFlowExecuteNV_CMockStopIgnore(void); +#define vkCmdOpticalFlowExecuteNV_ExpectAnyArgs() vkCmdOpticalFlowExecuteNV_CMockExpectAnyArgs(__LINE__) +void vkCmdOpticalFlowExecuteNV_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdOpticalFlowExecuteNV_Expect(commandBuffer, session, pExecuteInfo) vkCmdOpticalFlowExecuteNV_CMockExpect(__LINE__, commandBuffer, session, pExecuteInfo) +void vkCmdOpticalFlowExecuteNV_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo); +typedef void (* CMOCK_vkCmdOpticalFlowExecuteNV_CALLBACK)(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo, int cmock_num_calls); +void vkCmdOpticalFlowExecuteNV_AddCallback(CMOCK_vkCmdOpticalFlowExecuteNV_CALLBACK Callback); +void vkCmdOpticalFlowExecuteNV_Stub(CMOCK_vkCmdOpticalFlowExecuteNV_CALLBACK Callback); +#define vkCmdOpticalFlowExecuteNV_StubWithCallback vkCmdOpticalFlowExecuteNV_AddCallback +#define vkCmdOpticalFlowExecuteNV_IgnoreArg_commandBuffer() vkCmdOpticalFlowExecuteNV_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdOpticalFlowExecuteNV_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdOpticalFlowExecuteNV_IgnoreArg_session() vkCmdOpticalFlowExecuteNV_CMockIgnoreArg_session(__LINE__) +void vkCmdOpticalFlowExecuteNV_CMockIgnoreArg_session(UNITY_LINE_TYPE cmock_line); +#define vkCmdOpticalFlowExecuteNV_IgnoreArg_pExecuteInfo() vkCmdOpticalFlowExecuteNV_CMockIgnoreArg_pExecuteInfo(__LINE__) +void vkCmdOpticalFlowExecuteNV_CMockIgnoreArg_pExecuteInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateShadersEXT_IgnoreAndReturn(cmock_retval) vkCreateShadersEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateShadersEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateShadersEXT_StopIgnore() vkCreateShadersEXT_CMockStopIgnore() +void vkCreateShadersEXT_CMockStopIgnore(void); +#define vkCreateShadersEXT_ExpectAnyArgsAndReturn(cmock_retval) vkCreateShadersEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateShadersEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateShadersEXT_ExpectAndReturn(device, createInfoCount, pCreateInfos, pAllocator, pShaders, cmock_retval) vkCreateShadersEXT_CMockExpectAndReturn(__LINE__, device, createInfoCount, pCreateInfos, pAllocator, pShaders, cmock_retval) +void vkCreateShadersEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateShadersEXT_CALLBACK)(VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders, int cmock_num_calls); +void vkCreateShadersEXT_AddCallback(CMOCK_vkCreateShadersEXT_CALLBACK Callback); +void vkCreateShadersEXT_Stub(CMOCK_vkCreateShadersEXT_CALLBACK Callback); +#define vkCreateShadersEXT_StubWithCallback vkCreateShadersEXT_AddCallback +#define vkCreateShadersEXT_ReturnThruPtr_pShaders(pShaders) vkCreateShadersEXT_CMockReturnMemThruPtr_pShaders(__LINE__, pShaders, sizeof(VkShaderEXT)) +#define vkCreateShadersEXT_ReturnArrayThruPtr_pShaders(pShaders, cmock_len) vkCreateShadersEXT_CMockReturnMemThruPtr_pShaders(__LINE__, pShaders, cmock_len * sizeof(*pShaders)) +#define vkCreateShadersEXT_ReturnMemThruPtr_pShaders(pShaders, cmock_size) vkCreateShadersEXT_CMockReturnMemThruPtr_pShaders(__LINE__, pShaders, cmock_size) +void vkCreateShadersEXT_CMockReturnMemThruPtr_pShaders(UNITY_LINE_TYPE cmock_line, VkShaderEXT const* pShaders, size_t cmock_size); +#define vkCreateShadersEXT_IgnoreArg_device() vkCreateShadersEXT_CMockIgnoreArg_device(__LINE__) +void vkCreateShadersEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateShadersEXT_IgnoreArg_createInfoCount() vkCreateShadersEXT_CMockIgnoreArg_createInfoCount(__LINE__) +void vkCreateShadersEXT_CMockIgnoreArg_createInfoCount(UNITY_LINE_TYPE cmock_line); +#define vkCreateShadersEXT_IgnoreArg_pCreateInfos() vkCreateShadersEXT_CMockIgnoreArg_pCreateInfos(__LINE__) +void vkCreateShadersEXT_CMockIgnoreArg_pCreateInfos(UNITY_LINE_TYPE cmock_line); +#define vkCreateShadersEXT_IgnoreArg_pAllocator() vkCreateShadersEXT_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateShadersEXT_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateShadersEXT_IgnoreArg_pShaders() vkCreateShadersEXT_CMockIgnoreArg_pShaders(__LINE__) +void vkCreateShadersEXT_CMockIgnoreArg_pShaders(UNITY_LINE_TYPE cmock_line); +#define vkDestroyShaderEXT_Ignore() vkDestroyShaderEXT_CMockIgnore() +void vkDestroyShaderEXT_CMockIgnore(void); +#define vkDestroyShaderEXT_StopIgnore() vkDestroyShaderEXT_CMockStopIgnore() +void vkDestroyShaderEXT_CMockStopIgnore(void); +#define vkDestroyShaderEXT_ExpectAnyArgs() vkDestroyShaderEXT_CMockExpectAnyArgs(__LINE__) +void vkDestroyShaderEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyShaderEXT_Expect(device, shader, pAllocator) vkDestroyShaderEXT_CMockExpect(__LINE__, device, shader, pAllocator) +void vkDestroyShaderEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyShaderEXT_CALLBACK)(VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyShaderEXT_AddCallback(CMOCK_vkDestroyShaderEXT_CALLBACK Callback); +void vkDestroyShaderEXT_Stub(CMOCK_vkDestroyShaderEXT_CALLBACK Callback); +#define vkDestroyShaderEXT_StubWithCallback vkDestroyShaderEXT_AddCallback +#define vkDestroyShaderEXT_IgnoreArg_device() vkDestroyShaderEXT_CMockIgnoreArg_device(__LINE__) +void vkDestroyShaderEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyShaderEXT_IgnoreArg_shader() vkDestroyShaderEXT_CMockIgnoreArg_shader(__LINE__) +void vkDestroyShaderEXT_CMockIgnoreArg_shader(UNITY_LINE_TYPE cmock_line); +#define vkDestroyShaderEXT_IgnoreArg_pAllocator() vkDestroyShaderEXT_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyShaderEXT_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkGetShaderBinaryDataEXT_IgnoreAndReturn(cmock_retval) vkGetShaderBinaryDataEXT_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetShaderBinaryDataEXT_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetShaderBinaryDataEXT_StopIgnore() vkGetShaderBinaryDataEXT_CMockStopIgnore() +void vkGetShaderBinaryDataEXT_CMockStopIgnore(void); +#define vkGetShaderBinaryDataEXT_ExpectAnyArgsAndReturn(cmock_retval) vkGetShaderBinaryDataEXT_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetShaderBinaryDataEXT_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetShaderBinaryDataEXT_ExpectAndReturn(device, shader, pDataSize, pData, cmock_retval) vkGetShaderBinaryDataEXT_CMockExpectAndReturn(__LINE__, device, shader, pDataSize, pData, cmock_retval) +void vkGetShaderBinaryDataEXT_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetShaderBinaryDataEXT_CALLBACK)(VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData, int cmock_num_calls); +void vkGetShaderBinaryDataEXT_AddCallback(CMOCK_vkGetShaderBinaryDataEXT_CALLBACK Callback); +void vkGetShaderBinaryDataEXT_Stub(CMOCK_vkGetShaderBinaryDataEXT_CALLBACK Callback); +#define vkGetShaderBinaryDataEXT_StubWithCallback vkGetShaderBinaryDataEXT_AddCallback +#define vkGetShaderBinaryDataEXT_ReturnThruPtr_pDataSize(pDataSize) vkGetShaderBinaryDataEXT_CMockReturnMemThruPtr_pDataSize(__LINE__, pDataSize, sizeof(size_t)) +#define vkGetShaderBinaryDataEXT_ReturnArrayThruPtr_pDataSize(pDataSize, cmock_len) vkGetShaderBinaryDataEXT_CMockReturnMemThruPtr_pDataSize(__LINE__, pDataSize, cmock_len * sizeof(*pDataSize)) +#define vkGetShaderBinaryDataEXT_ReturnMemThruPtr_pDataSize(pDataSize, cmock_size) vkGetShaderBinaryDataEXT_CMockReturnMemThruPtr_pDataSize(__LINE__, pDataSize, cmock_size) +void vkGetShaderBinaryDataEXT_CMockReturnMemThruPtr_pDataSize(UNITY_LINE_TYPE cmock_line, size_t const* pDataSize, size_t cmock_size); +#define vkGetShaderBinaryDataEXT_ReturnThruPtr_pData(pData) vkGetShaderBinaryDataEXT_CMockReturnMemThruPtr_pData(__LINE__, pData, sizeof(*pData)) +#define vkGetShaderBinaryDataEXT_ReturnArrayThruPtr_pData(pData, cmock_len) vkGetShaderBinaryDataEXT_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_len * sizeof(*pData)) +#define vkGetShaderBinaryDataEXT_ReturnMemThruPtr_pData(pData, cmock_size) vkGetShaderBinaryDataEXT_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_size) +void vkGetShaderBinaryDataEXT_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, void const* pData, size_t cmock_size); +#define vkGetShaderBinaryDataEXT_IgnoreArg_device() vkGetShaderBinaryDataEXT_CMockIgnoreArg_device(__LINE__) +void vkGetShaderBinaryDataEXT_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetShaderBinaryDataEXT_IgnoreArg_shader() vkGetShaderBinaryDataEXT_CMockIgnoreArg_shader(__LINE__) +void vkGetShaderBinaryDataEXT_CMockIgnoreArg_shader(UNITY_LINE_TYPE cmock_line); +#define vkGetShaderBinaryDataEXT_IgnoreArg_pDataSize() vkGetShaderBinaryDataEXT_CMockIgnoreArg_pDataSize(__LINE__) +void vkGetShaderBinaryDataEXT_CMockIgnoreArg_pDataSize(UNITY_LINE_TYPE cmock_line); +#define vkGetShaderBinaryDataEXT_IgnoreArg_pData() vkGetShaderBinaryDataEXT_CMockIgnoreArg_pData(__LINE__) +void vkGetShaderBinaryDataEXT_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindShadersEXT_Ignore() vkCmdBindShadersEXT_CMockIgnore() +void vkCmdBindShadersEXT_CMockIgnore(void); +#define vkCmdBindShadersEXT_StopIgnore() vkCmdBindShadersEXT_CMockStopIgnore() +void vkCmdBindShadersEXT_CMockStopIgnore(void); +#define vkCmdBindShadersEXT_ExpectAnyArgs() vkCmdBindShadersEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdBindShadersEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindShadersEXT_Expect(commandBuffer, stageCount, pStages, pShaders) vkCmdBindShadersEXT_CMockExpect(__LINE__, commandBuffer, stageCount, pStages, pShaders) +void vkCmdBindShadersEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t stageCount, const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders); +typedef void (* CMOCK_vkCmdBindShadersEXT_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t stageCount, const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders, int cmock_num_calls); +void vkCmdBindShadersEXT_AddCallback(CMOCK_vkCmdBindShadersEXT_CALLBACK Callback); +void vkCmdBindShadersEXT_Stub(CMOCK_vkCmdBindShadersEXT_CALLBACK Callback); +#define vkCmdBindShadersEXT_StubWithCallback vkCmdBindShadersEXT_AddCallback +#define vkCmdBindShadersEXT_IgnoreArg_commandBuffer() vkCmdBindShadersEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBindShadersEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindShadersEXT_IgnoreArg_stageCount() vkCmdBindShadersEXT_CMockIgnoreArg_stageCount(__LINE__) +void vkCmdBindShadersEXT_CMockIgnoreArg_stageCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindShadersEXT_IgnoreArg_pStages() vkCmdBindShadersEXT_CMockIgnoreArg_pStages(__LINE__) +void vkCmdBindShadersEXT_CMockIgnoreArg_pStages(UNITY_LINE_TYPE cmock_line); +#define vkCmdBindShadersEXT_IgnoreArg_pShaders() vkCmdBindShadersEXT_CMockIgnoreArg_pShaders(__LINE__) +void vkCmdBindShadersEXT_CMockIgnoreArg_pShaders(UNITY_LINE_TYPE cmock_line); +#define vkGetFramebufferTilePropertiesQCOM_IgnoreAndReturn(cmock_retval) vkGetFramebufferTilePropertiesQCOM_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetFramebufferTilePropertiesQCOM_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetFramebufferTilePropertiesQCOM_StopIgnore() vkGetFramebufferTilePropertiesQCOM_CMockStopIgnore() +void vkGetFramebufferTilePropertiesQCOM_CMockStopIgnore(void); +#define vkGetFramebufferTilePropertiesQCOM_ExpectAnyArgsAndReturn(cmock_retval) vkGetFramebufferTilePropertiesQCOM_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetFramebufferTilePropertiesQCOM_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetFramebufferTilePropertiesQCOM_ExpectAndReturn(device, framebuffer, pPropertiesCount, pProperties, cmock_retval) vkGetFramebufferTilePropertiesQCOM_CMockExpectAndReturn(__LINE__, device, framebuffer, pPropertiesCount, pProperties, cmock_retval) +void vkGetFramebufferTilePropertiesQCOM_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetFramebufferTilePropertiesQCOM_CALLBACK)(VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties, int cmock_num_calls); +void vkGetFramebufferTilePropertiesQCOM_AddCallback(CMOCK_vkGetFramebufferTilePropertiesQCOM_CALLBACK Callback); +void vkGetFramebufferTilePropertiesQCOM_Stub(CMOCK_vkGetFramebufferTilePropertiesQCOM_CALLBACK Callback); +#define vkGetFramebufferTilePropertiesQCOM_StubWithCallback vkGetFramebufferTilePropertiesQCOM_AddCallback +#define vkGetFramebufferTilePropertiesQCOM_ReturnThruPtr_pPropertiesCount(pPropertiesCount) vkGetFramebufferTilePropertiesQCOM_CMockReturnMemThruPtr_pPropertiesCount(__LINE__, pPropertiesCount, sizeof(uint32_t)) +#define vkGetFramebufferTilePropertiesQCOM_ReturnArrayThruPtr_pPropertiesCount(pPropertiesCount, cmock_len) vkGetFramebufferTilePropertiesQCOM_CMockReturnMemThruPtr_pPropertiesCount(__LINE__, pPropertiesCount, cmock_len * sizeof(*pPropertiesCount)) +#define vkGetFramebufferTilePropertiesQCOM_ReturnMemThruPtr_pPropertiesCount(pPropertiesCount, cmock_size) vkGetFramebufferTilePropertiesQCOM_CMockReturnMemThruPtr_pPropertiesCount(__LINE__, pPropertiesCount, cmock_size) +void vkGetFramebufferTilePropertiesQCOM_CMockReturnMemThruPtr_pPropertiesCount(UNITY_LINE_TYPE cmock_line, uint32_t const* pPropertiesCount, size_t cmock_size); +#define vkGetFramebufferTilePropertiesQCOM_ReturnThruPtr_pProperties(pProperties) vkGetFramebufferTilePropertiesQCOM_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, sizeof(VkTilePropertiesQCOM)) +#define vkGetFramebufferTilePropertiesQCOM_ReturnArrayThruPtr_pProperties(pProperties, cmock_len) vkGetFramebufferTilePropertiesQCOM_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_len * sizeof(*pProperties)) +#define vkGetFramebufferTilePropertiesQCOM_ReturnMemThruPtr_pProperties(pProperties, cmock_size) vkGetFramebufferTilePropertiesQCOM_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_size) +void vkGetFramebufferTilePropertiesQCOM_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkTilePropertiesQCOM const* pProperties, size_t cmock_size); +#define vkGetFramebufferTilePropertiesQCOM_IgnoreArg_device() vkGetFramebufferTilePropertiesQCOM_CMockIgnoreArg_device(__LINE__) +void vkGetFramebufferTilePropertiesQCOM_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetFramebufferTilePropertiesQCOM_IgnoreArg_framebuffer() vkGetFramebufferTilePropertiesQCOM_CMockIgnoreArg_framebuffer(__LINE__) +void vkGetFramebufferTilePropertiesQCOM_CMockIgnoreArg_framebuffer(UNITY_LINE_TYPE cmock_line); +#define vkGetFramebufferTilePropertiesQCOM_IgnoreArg_pPropertiesCount() vkGetFramebufferTilePropertiesQCOM_CMockIgnoreArg_pPropertiesCount(__LINE__) +void vkGetFramebufferTilePropertiesQCOM_CMockIgnoreArg_pPropertiesCount(UNITY_LINE_TYPE cmock_line); +#define vkGetFramebufferTilePropertiesQCOM_IgnoreArg_pProperties() vkGetFramebufferTilePropertiesQCOM_CMockIgnoreArg_pProperties(__LINE__) +void vkGetFramebufferTilePropertiesQCOM_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line); +#define vkGetDynamicRenderingTilePropertiesQCOM_IgnoreAndReturn(cmock_retval) vkGetDynamicRenderingTilePropertiesQCOM_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetDynamicRenderingTilePropertiesQCOM_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetDynamicRenderingTilePropertiesQCOM_StopIgnore() vkGetDynamicRenderingTilePropertiesQCOM_CMockStopIgnore() +void vkGetDynamicRenderingTilePropertiesQCOM_CMockStopIgnore(void); +#define vkGetDynamicRenderingTilePropertiesQCOM_ExpectAnyArgsAndReturn(cmock_retval) vkGetDynamicRenderingTilePropertiesQCOM_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetDynamicRenderingTilePropertiesQCOM_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetDynamicRenderingTilePropertiesQCOM_ExpectAndReturn(device, pRenderingInfo, pProperties, cmock_retval) vkGetDynamicRenderingTilePropertiesQCOM_CMockExpectAndReturn(__LINE__, device, pRenderingInfo, pProperties, cmock_retval) +void vkGetDynamicRenderingTilePropertiesQCOM_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetDynamicRenderingTilePropertiesQCOM_CALLBACK)(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties, int cmock_num_calls); +void vkGetDynamicRenderingTilePropertiesQCOM_AddCallback(CMOCK_vkGetDynamicRenderingTilePropertiesQCOM_CALLBACK Callback); +void vkGetDynamicRenderingTilePropertiesQCOM_Stub(CMOCK_vkGetDynamicRenderingTilePropertiesQCOM_CALLBACK Callback); +#define vkGetDynamicRenderingTilePropertiesQCOM_StubWithCallback vkGetDynamicRenderingTilePropertiesQCOM_AddCallback +#define vkGetDynamicRenderingTilePropertiesQCOM_ReturnThruPtr_pProperties(pProperties) vkGetDynamicRenderingTilePropertiesQCOM_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, sizeof(VkTilePropertiesQCOM)) +#define vkGetDynamicRenderingTilePropertiesQCOM_ReturnArrayThruPtr_pProperties(pProperties, cmock_len) vkGetDynamicRenderingTilePropertiesQCOM_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_len * sizeof(*pProperties)) +#define vkGetDynamicRenderingTilePropertiesQCOM_ReturnMemThruPtr_pProperties(pProperties, cmock_size) vkGetDynamicRenderingTilePropertiesQCOM_CMockReturnMemThruPtr_pProperties(__LINE__, pProperties, cmock_size) +void vkGetDynamicRenderingTilePropertiesQCOM_CMockReturnMemThruPtr_pProperties(UNITY_LINE_TYPE cmock_line, VkTilePropertiesQCOM const* pProperties, size_t cmock_size); +#define vkGetDynamicRenderingTilePropertiesQCOM_IgnoreArg_device() vkGetDynamicRenderingTilePropertiesQCOM_CMockIgnoreArg_device(__LINE__) +void vkGetDynamicRenderingTilePropertiesQCOM_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetDynamicRenderingTilePropertiesQCOM_IgnoreArg_pRenderingInfo() vkGetDynamicRenderingTilePropertiesQCOM_CMockIgnoreArg_pRenderingInfo(__LINE__) +void vkGetDynamicRenderingTilePropertiesQCOM_CMockIgnoreArg_pRenderingInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetDynamicRenderingTilePropertiesQCOM_IgnoreArg_pProperties() vkGetDynamicRenderingTilePropertiesQCOM_CMockIgnoreArg_pProperties(__LINE__) +void vkGetDynamicRenderingTilePropertiesQCOM_CMockIgnoreArg_pProperties(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetAttachmentFeedbackLoopEnableEXT_Ignore() vkCmdSetAttachmentFeedbackLoopEnableEXT_CMockIgnore() +void vkCmdSetAttachmentFeedbackLoopEnableEXT_CMockIgnore(void); +#define vkCmdSetAttachmentFeedbackLoopEnableEXT_StopIgnore() vkCmdSetAttachmentFeedbackLoopEnableEXT_CMockStopIgnore() +void vkCmdSetAttachmentFeedbackLoopEnableEXT_CMockStopIgnore(void); +#define vkCmdSetAttachmentFeedbackLoopEnableEXT_ExpectAnyArgs() vkCmdSetAttachmentFeedbackLoopEnableEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdSetAttachmentFeedbackLoopEnableEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetAttachmentFeedbackLoopEnableEXT_Expect(commandBuffer, aspectMask) vkCmdSetAttachmentFeedbackLoopEnableEXT_CMockExpect(__LINE__, commandBuffer, aspectMask) +void vkCmdSetAttachmentFeedbackLoopEnableEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask); +typedef void (* CMOCK_vkCmdSetAttachmentFeedbackLoopEnableEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask, int cmock_num_calls); +void vkCmdSetAttachmentFeedbackLoopEnableEXT_AddCallback(CMOCK_vkCmdSetAttachmentFeedbackLoopEnableEXT_CALLBACK Callback); +void vkCmdSetAttachmentFeedbackLoopEnableEXT_Stub(CMOCK_vkCmdSetAttachmentFeedbackLoopEnableEXT_CALLBACK Callback); +#define vkCmdSetAttachmentFeedbackLoopEnableEXT_StubWithCallback vkCmdSetAttachmentFeedbackLoopEnableEXT_AddCallback +#define vkCmdSetAttachmentFeedbackLoopEnableEXT_IgnoreArg_commandBuffer() vkCmdSetAttachmentFeedbackLoopEnableEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetAttachmentFeedbackLoopEnableEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetAttachmentFeedbackLoopEnableEXT_IgnoreArg_aspectMask() vkCmdSetAttachmentFeedbackLoopEnableEXT_CMockIgnoreArg_aspectMask(__LINE__) +void vkCmdSetAttachmentFeedbackLoopEnableEXT_CMockIgnoreArg_aspectMask(UNITY_LINE_TYPE cmock_line); +#define vkCreateAccelerationStructureKHR_IgnoreAndReturn(cmock_retval) vkCreateAccelerationStructureKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateAccelerationStructureKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateAccelerationStructureKHR_StopIgnore() vkCreateAccelerationStructureKHR_CMockStopIgnore() +void vkCreateAccelerationStructureKHR_CMockStopIgnore(void); +#define vkCreateAccelerationStructureKHR_ExpectAnyArgsAndReturn(cmock_retval) vkCreateAccelerationStructureKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateAccelerationStructureKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateAccelerationStructureKHR_ExpectAndReturn(device, pCreateInfo, pAllocator, pAccelerationStructure, cmock_retval) vkCreateAccelerationStructureKHR_CMockExpectAndReturn(__LINE__, device, pCreateInfo, pAllocator, pAccelerationStructure, cmock_retval) +void vkCreateAccelerationStructureKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateAccelerationStructureKHR_CALLBACK)(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure, int cmock_num_calls); +void vkCreateAccelerationStructureKHR_AddCallback(CMOCK_vkCreateAccelerationStructureKHR_CALLBACK Callback); +void vkCreateAccelerationStructureKHR_Stub(CMOCK_vkCreateAccelerationStructureKHR_CALLBACK Callback); +#define vkCreateAccelerationStructureKHR_StubWithCallback vkCreateAccelerationStructureKHR_AddCallback +#define vkCreateAccelerationStructureKHR_ReturnThruPtr_pAccelerationStructure(pAccelerationStructure) vkCreateAccelerationStructureKHR_CMockReturnMemThruPtr_pAccelerationStructure(__LINE__, pAccelerationStructure, sizeof(VkAccelerationStructureKHR)) +#define vkCreateAccelerationStructureKHR_ReturnArrayThruPtr_pAccelerationStructure(pAccelerationStructure, cmock_len) vkCreateAccelerationStructureKHR_CMockReturnMemThruPtr_pAccelerationStructure(__LINE__, pAccelerationStructure, cmock_len * sizeof(*pAccelerationStructure)) +#define vkCreateAccelerationStructureKHR_ReturnMemThruPtr_pAccelerationStructure(pAccelerationStructure, cmock_size) vkCreateAccelerationStructureKHR_CMockReturnMemThruPtr_pAccelerationStructure(__LINE__, pAccelerationStructure, cmock_size) +void vkCreateAccelerationStructureKHR_CMockReturnMemThruPtr_pAccelerationStructure(UNITY_LINE_TYPE cmock_line, VkAccelerationStructureKHR const* pAccelerationStructure, size_t cmock_size); +#define vkCreateAccelerationStructureKHR_IgnoreArg_device() vkCreateAccelerationStructureKHR_CMockIgnoreArg_device(__LINE__) +void vkCreateAccelerationStructureKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateAccelerationStructureKHR_IgnoreArg_pCreateInfo() vkCreateAccelerationStructureKHR_CMockIgnoreArg_pCreateInfo(__LINE__) +void vkCreateAccelerationStructureKHR_CMockIgnoreArg_pCreateInfo(UNITY_LINE_TYPE cmock_line); +#define vkCreateAccelerationStructureKHR_IgnoreArg_pAllocator() vkCreateAccelerationStructureKHR_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateAccelerationStructureKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateAccelerationStructureKHR_IgnoreArg_pAccelerationStructure() vkCreateAccelerationStructureKHR_CMockIgnoreArg_pAccelerationStructure(__LINE__) +void vkCreateAccelerationStructureKHR_CMockIgnoreArg_pAccelerationStructure(UNITY_LINE_TYPE cmock_line); +#define vkDestroyAccelerationStructureKHR_Ignore() vkDestroyAccelerationStructureKHR_CMockIgnore() +void vkDestroyAccelerationStructureKHR_CMockIgnore(void); +#define vkDestroyAccelerationStructureKHR_StopIgnore() vkDestroyAccelerationStructureKHR_CMockStopIgnore() +void vkDestroyAccelerationStructureKHR_CMockStopIgnore(void); +#define vkDestroyAccelerationStructureKHR_ExpectAnyArgs() vkDestroyAccelerationStructureKHR_CMockExpectAnyArgs(__LINE__) +void vkDestroyAccelerationStructureKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkDestroyAccelerationStructureKHR_Expect(device, accelerationStructure, pAllocator) vkDestroyAccelerationStructureKHR_CMockExpect(__LINE__, device, accelerationStructure, pAllocator) +void vkDestroyAccelerationStructureKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator); +typedef void (* CMOCK_vkDestroyAccelerationStructureKHR_CALLBACK)(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator, int cmock_num_calls); +void vkDestroyAccelerationStructureKHR_AddCallback(CMOCK_vkDestroyAccelerationStructureKHR_CALLBACK Callback); +void vkDestroyAccelerationStructureKHR_Stub(CMOCK_vkDestroyAccelerationStructureKHR_CALLBACK Callback); +#define vkDestroyAccelerationStructureKHR_StubWithCallback vkDestroyAccelerationStructureKHR_AddCallback +#define vkDestroyAccelerationStructureKHR_IgnoreArg_device() vkDestroyAccelerationStructureKHR_CMockIgnoreArg_device(__LINE__) +void vkDestroyAccelerationStructureKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkDestroyAccelerationStructureKHR_IgnoreArg_accelerationStructure() vkDestroyAccelerationStructureKHR_CMockIgnoreArg_accelerationStructure(__LINE__) +void vkDestroyAccelerationStructureKHR_CMockIgnoreArg_accelerationStructure(UNITY_LINE_TYPE cmock_line); +#define vkDestroyAccelerationStructureKHR_IgnoreArg_pAllocator() vkDestroyAccelerationStructureKHR_CMockIgnoreArg_pAllocator(__LINE__) +void vkDestroyAccelerationStructureKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCmdBuildAccelerationStructuresKHR_Ignore() vkCmdBuildAccelerationStructuresKHR_CMockIgnore() +void vkCmdBuildAccelerationStructuresKHR_CMockIgnore(void); +#define vkCmdBuildAccelerationStructuresKHR_StopIgnore() vkCmdBuildAccelerationStructuresKHR_CMockStopIgnore() +void vkCmdBuildAccelerationStructuresKHR_CMockStopIgnore(void); +#define vkCmdBuildAccelerationStructuresKHR_ExpectAnyArgs() vkCmdBuildAccelerationStructuresKHR_CMockExpectAnyArgs(__LINE__) +void vkCmdBuildAccelerationStructuresKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBuildAccelerationStructuresKHR_Expect(commandBuffer, infoCount, pInfos, ppBuildRangeInfos) vkCmdBuildAccelerationStructuresKHR_CMockExpect(__LINE__, commandBuffer, infoCount, pInfos, ppBuildRangeInfos) +void vkCmdBuildAccelerationStructuresKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); +typedef void (* CMOCK_vkCmdBuildAccelerationStructuresKHR_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos, int cmock_num_calls); +void vkCmdBuildAccelerationStructuresKHR_AddCallback(CMOCK_vkCmdBuildAccelerationStructuresKHR_CALLBACK Callback); +void vkCmdBuildAccelerationStructuresKHR_Stub(CMOCK_vkCmdBuildAccelerationStructuresKHR_CALLBACK Callback); +#define vkCmdBuildAccelerationStructuresKHR_StubWithCallback vkCmdBuildAccelerationStructuresKHR_AddCallback +#define vkCmdBuildAccelerationStructuresKHR_IgnoreArg_commandBuffer() vkCmdBuildAccelerationStructuresKHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBuildAccelerationStructuresKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBuildAccelerationStructuresKHR_IgnoreArg_infoCount() vkCmdBuildAccelerationStructuresKHR_CMockIgnoreArg_infoCount(__LINE__) +void vkCmdBuildAccelerationStructuresKHR_CMockIgnoreArg_infoCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdBuildAccelerationStructuresKHR_IgnoreArg_pInfos() vkCmdBuildAccelerationStructuresKHR_CMockIgnoreArg_pInfos(__LINE__) +void vkCmdBuildAccelerationStructuresKHR_CMockIgnoreArg_pInfos(UNITY_LINE_TYPE cmock_line); +#define vkCmdBuildAccelerationStructuresKHR_IgnoreArg_ppBuildRangeInfos() vkCmdBuildAccelerationStructuresKHR_CMockIgnoreArg_ppBuildRangeInfos(__LINE__) +void vkCmdBuildAccelerationStructuresKHR_CMockIgnoreArg_ppBuildRangeInfos(UNITY_LINE_TYPE cmock_line); +#define vkCmdBuildAccelerationStructuresIndirectKHR_Ignore() vkCmdBuildAccelerationStructuresIndirectKHR_CMockIgnore() +void vkCmdBuildAccelerationStructuresIndirectKHR_CMockIgnore(void); +#define vkCmdBuildAccelerationStructuresIndirectKHR_StopIgnore() vkCmdBuildAccelerationStructuresIndirectKHR_CMockStopIgnore() +void vkCmdBuildAccelerationStructuresIndirectKHR_CMockStopIgnore(void); +#define vkCmdBuildAccelerationStructuresIndirectKHR_ExpectAnyArgs() vkCmdBuildAccelerationStructuresIndirectKHR_CMockExpectAnyArgs(__LINE__) +void vkCmdBuildAccelerationStructuresIndirectKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdBuildAccelerationStructuresIndirectKHR_Expect(commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts) vkCmdBuildAccelerationStructuresIndirectKHR_CMockExpect(__LINE__, commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts) +void vkCmdBuildAccelerationStructuresIndirectKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts); +typedef void (* CMOCK_vkCmdBuildAccelerationStructuresIndirectKHR_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts, int cmock_num_calls); +void vkCmdBuildAccelerationStructuresIndirectKHR_AddCallback(CMOCK_vkCmdBuildAccelerationStructuresIndirectKHR_CALLBACK Callback); +void vkCmdBuildAccelerationStructuresIndirectKHR_Stub(CMOCK_vkCmdBuildAccelerationStructuresIndirectKHR_CALLBACK Callback); +#define vkCmdBuildAccelerationStructuresIndirectKHR_StubWithCallback vkCmdBuildAccelerationStructuresIndirectKHR_AddCallback +#define vkCmdBuildAccelerationStructuresIndirectKHR_IgnoreArg_commandBuffer() vkCmdBuildAccelerationStructuresIndirectKHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdBuildAccelerationStructuresIndirectKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdBuildAccelerationStructuresIndirectKHR_IgnoreArg_infoCount() vkCmdBuildAccelerationStructuresIndirectKHR_CMockIgnoreArg_infoCount(__LINE__) +void vkCmdBuildAccelerationStructuresIndirectKHR_CMockIgnoreArg_infoCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdBuildAccelerationStructuresIndirectKHR_IgnoreArg_pInfos() vkCmdBuildAccelerationStructuresIndirectKHR_CMockIgnoreArg_pInfos(__LINE__) +void vkCmdBuildAccelerationStructuresIndirectKHR_CMockIgnoreArg_pInfos(UNITY_LINE_TYPE cmock_line); +#define vkCmdBuildAccelerationStructuresIndirectKHR_IgnoreArg_pIndirectDeviceAddresses() vkCmdBuildAccelerationStructuresIndirectKHR_CMockIgnoreArg_pIndirectDeviceAddresses(__LINE__) +void vkCmdBuildAccelerationStructuresIndirectKHR_CMockIgnoreArg_pIndirectDeviceAddresses(UNITY_LINE_TYPE cmock_line); +#define vkCmdBuildAccelerationStructuresIndirectKHR_IgnoreArg_pIndirectStrides() vkCmdBuildAccelerationStructuresIndirectKHR_CMockIgnoreArg_pIndirectStrides(__LINE__) +void vkCmdBuildAccelerationStructuresIndirectKHR_CMockIgnoreArg_pIndirectStrides(UNITY_LINE_TYPE cmock_line); +#define vkCmdBuildAccelerationStructuresIndirectKHR_IgnoreArg_ppMaxPrimitiveCounts() vkCmdBuildAccelerationStructuresIndirectKHR_CMockIgnoreArg_ppMaxPrimitiveCounts(__LINE__) +void vkCmdBuildAccelerationStructuresIndirectKHR_CMockIgnoreArg_ppMaxPrimitiveCounts(UNITY_LINE_TYPE cmock_line); +#define vkBuildAccelerationStructuresKHR_IgnoreAndReturn(cmock_retval) vkBuildAccelerationStructuresKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkBuildAccelerationStructuresKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkBuildAccelerationStructuresKHR_StopIgnore() vkBuildAccelerationStructuresKHR_CMockStopIgnore() +void vkBuildAccelerationStructuresKHR_CMockStopIgnore(void); +#define vkBuildAccelerationStructuresKHR_ExpectAnyArgsAndReturn(cmock_retval) vkBuildAccelerationStructuresKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkBuildAccelerationStructuresKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkBuildAccelerationStructuresKHR_ExpectAndReturn(device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos, cmock_retval) vkBuildAccelerationStructuresKHR_CMockExpectAndReturn(__LINE__, device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos, cmock_retval) +void vkBuildAccelerationStructuresKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkBuildAccelerationStructuresKHR_CALLBACK)(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos, int cmock_num_calls); +void vkBuildAccelerationStructuresKHR_AddCallback(CMOCK_vkBuildAccelerationStructuresKHR_CALLBACK Callback); +void vkBuildAccelerationStructuresKHR_Stub(CMOCK_vkBuildAccelerationStructuresKHR_CALLBACK Callback); +#define vkBuildAccelerationStructuresKHR_StubWithCallback vkBuildAccelerationStructuresKHR_AddCallback +#define vkBuildAccelerationStructuresKHR_IgnoreArg_device() vkBuildAccelerationStructuresKHR_CMockIgnoreArg_device(__LINE__) +void vkBuildAccelerationStructuresKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkBuildAccelerationStructuresKHR_IgnoreArg_deferredOperation() vkBuildAccelerationStructuresKHR_CMockIgnoreArg_deferredOperation(__LINE__) +void vkBuildAccelerationStructuresKHR_CMockIgnoreArg_deferredOperation(UNITY_LINE_TYPE cmock_line); +#define vkBuildAccelerationStructuresKHR_IgnoreArg_infoCount() vkBuildAccelerationStructuresKHR_CMockIgnoreArg_infoCount(__LINE__) +void vkBuildAccelerationStructuresKHR_CMockIgnoreArg_infoCount(UNITY_LINE_TYPE cmock_line); +#define vkBuildAccelerationStructuresKHR_IgnoreArg_pInfos() vkBuildAccelerationStructuresKHR_CMockIgnoreArg_pInfos(__LINE__) +void vkBuildAccelerationStructuresKHR_CMockIgnoreArg_pInfos(UNITY_LINE_TYPE cmock_line); +#define vkBuildAccelerationStructuresKHR_IgnoreArg_ppBuildRangeInfos() vkBuildAccelerationStructuresKHR_CMockIgnoreArg_ppBuildRangeInfos(__LINE__) +void vkBuildAccelerationStructuresKHR_CMockIgnoreArg_ppBuildRangeInfos(UNITY_LINE_TYPE cmock_line); +#define vkCopyAccelerationStructureKHR_IgnoreAndReturn(cmock_retval) vkCopyAccelerationStructureKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCopyAccelerationStructureKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCopyAccelerationStructureKHR_StopIgnore() vkCopyAccelerationStructureKHR_CMockStopIgnore() +void vkCopyAccelerationStructureKHR_CMockStopIgnore(void); +#define vkCopyAccelerationStructureKHR_ExpectAnyArgsAndReturn(cmock_retval) vkCopyAccelerationStructureKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCopyAccelerationStructureKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCopyAccelerationStructureKHR_ExpectAndReturn(device, deferredOperation, pInfo, cmock_retval) vkCopyAccelerationStructureKHR_CMockExpectAndReturn(__LINE__, device, deferredOperation, pInfo, cmock_retval) +void vkCopyAccelerationStructureKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCopyAccelerationStructureKHR_CALLBACK)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo, int cmock_num_calls); +void vkCopyAccelerationStructureKHR_AddCallback(CMOCK_vkCopyAccelerationStructureKHR_CALLBACK Callback); +void vkCopyAccelerationStructureKHR_Stub(CMOCK_vkCopyAccelerationStructureKHR_CALLBACK Callback); +#define vkCopyAccelerationStructureKHR_StubWithCallback vkCopyAccelerationStructureKHR_AddCallback +#define vkCopyAccelerationStructureKHR_IgnoreArg_device() vkCopyAccelerationStructureKHR_CMockIgnoreArg_device(__LINE__) +void vkCopyAccelerationStructureKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCopyAccelerationStructureKHR_IgnoreArg_deferredOperation() vkCopyAccelerationStructureKHR_CMockIgnoreArg_deferredOperation(__LINE__) +void vkCopyAccelerationStructureKHR_CMockIgnoreArg_deferredOperation(UNITY_LINE_TYPE cmock_line); +#define vkCopyAccelerationStructureKHR_IgnoreArg_pInfo() vkCopyAccelerationStructureKHR_CMockIgnoreArg_pInfo(__LINE__) +void vkCopyAccelerationStructureKHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkCopyAccelerationStructureToMemoryKHR_IgnoreAndReturn(cmock_retval) vkCopyAccelerationStructureToMemoryKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCopyAccelerationStructureToMemoryKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCopyAccelerationStructureToMemoryKHR_StopIgnore() vkCopyAccelerationStructureToMemoryKHR_CMockStopIgnore() +void vkCopyAccelerationStructureToMemoryKHR_CMockStopIgnore(void); +#define vkCopyAccelerationStructureToMemoryKHR_ExpectAnyArgsAndReturn(cmock_retval) vkCopyAccelerationStructureToMemoryKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCopyAccelerationStructureToMemoryKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCopyAccelerationStructureToMemoryKHR_ExpectAndReturn(device, deferredOperation, pInfo, cmock_retval) vkCopyAccelerationStructureToMemoryKHR_CMockExpectAndReturn(__LINE__, device, deferredOperation, pInfo, cmock_retval) +void vkCopyAccelerationStructureToMemoryKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCopyAccelerationStructureToMemoryKHR_CALLBACK)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo, int cmock_num_calls); +void vkCopyAccelerationStructureToMemoryKHR_AddCallback(CMOCK_vkCopyAccelerationStructureToMemoryKHR_CALLBACK Callback); +void vkCopyAccelerationStructureToMemoryKHR_Stub(CMOCK_vkCopyAccelerationStructureToMemoryKHR_CALLBACK Callback); +#define vkCopyAccelerationStructureToMemoryKHR_StubWithCallback vkCopyAccelerationStructureToMemoryKHR_AddCallback +#define vkCopyAccelerationStructureToMemoryKHR_IgnoreArg_device() vkCopyAccelerationStructureToMemoryKHR_CMockIgnoreArg_device(__LINE__) +void vkCopyAccelerationStructureToMemoryKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCopyAccelerationStructureToMemoryKHR_IgnoreArg_deferredOperation() vkCopyAccelerationStructureToMemoryKHR_CMockIgnoreArg_deferredOperation(__LINE__) +void vkCopyAccelerationStructureToMemoryKHR_CMockIgnoreArg_deferredOperation(UNITY_LINE_TYPE cmock_line); +#define vkCopyAccelerationStructureToMemoryKHR_IgnoreArg_pInfo() vkCopyAccelerationStructureToMemoryKHR_CMockIgnoreArg_pInfo(__LINE__) +void vkCopyAccelerationStructureToMemoryKHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkCopyMemoryToAccelerationStructureKHR_IgnoreAndReturn(cmock_retval) vkCopyMemoryToAccelerationStructureKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCopyMemoryToAccelerationStructureKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCopyMemoryToAccelerationStructureKHR_StopIgnore() vkCopyMemoryToAccelerationStructureKHR_CMockStopIgnore() +void vkCopyMemoryToAccelerationStructureKHR_CMockStopIgnore(void); +#define vkCopyMemoryToAccelerationStructureKHR_ExpectAnyArgsAndReturn(cmock_retval) vkCopyMemoryToAccelerationStructureKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCopyMemoryToAccelerationStructureKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCopyMemoryToAccelerationStructureKHR_ExpectAndReturn(device, deferredOperation, pInfo, cmock_retval) vkCopyMemoryToAccelerationStructureKHR_CMockExpectAndReturn(__LINE__, device, deferredOperation, pInfo, cmock_retval) +void vkCopyMemoryToAccelerationStructureKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCopyMemoryToAccelerationStructureKHR_CALLBACK)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo, int cmock_num_calls); +void vkCopyMemoryToAccelerationStructureKHR_AddCallback(CMOCK_vkCopyMemoryToAccelerationStructureKHR_CALLBACK Callback); +void vkCopyMemoryToAccelerationStructureKHR_Stub(CMOCK_vkCopyMemoryToAccelerationStructureKHR_CALLBACK Callback); +#define vkCopyMemoryToAccelerationStructureKHR_StubWithCallback vkCopyMemoryToAccelerationStructureKHR_AddCallback +#define vkCopyMemoryToAccelerationStructureKHR_IgnoreArg_device() vkCopyMemoryToAccelerationStructureKHR_CMockIgnoreArg_device(__LINE__) +void vkCopyMemoryToAccelerationStructureKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCopyMemoryToAccelerationStructureKHR_IgnoreArg_deferredOperation() vkCopyMemoryToAccelerationStructureKHR_CMockIgnoreArg_deferredOperation(__LINE__) +void vkCopyMemoryToAccelerationStructureKHR_CMockIgnoreArg_deferredOperation(UNITY_LINE_TYPE cmock_line); +#define vkCopyMemoryToAccelerationStructureKHR_IgnoreArg_pInfo() vkCopyMemoryToAccelerationStructureKHR_CMockIgnoreArg_pInfo(__LINE__) +void vkCopyMemoryToAccelerationStructureKHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkWriteAccelerationStructuresPropertiesKHR_IgnoreAndReturn(cmock_retval) vkWriteAccelerationStructuresPropertiesKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkWriteAccelerationStructuresPropertiesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkWriteAccelerationStructuresPropertiesKHR_StopIgnore() vkWriteAccelerationStructuresPropertiesKHR_CMockStopIgnore() +void vkWriteAccelerationStructuresPropertiesKHR_CMockStopIgnore(void); +#define vkWriteAccelerationStructuresPropertiesKHR_ExpectAnyArgsAndReturn(cmock_retval) vkWriteAccelerationStructuresPropertiesKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkWriteAccelerationStructuresPropertiesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkWriteAccelerationStructuresPropertiesKHR_ExpectAndReturn(device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride, cmock_retval) vkWriteAccelerationStructuresPropertiesKHR_CMockExpectAndReturn(__LINE__, device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride, cmock_retval) +void vkWriteAccelerationStructuresPropertiesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALLBACK)(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride, int cmock_num_calls); +void vkWriteAccelerationStructuresPropertiesKHR_AddCallback(CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALLBACK Callback); +void vkWriteAccelerationStructuresPropertiesKHR_Stub(CMOCK_vkWriteAccelerationStructuresPropertiesKHR_CALLBACK Callback); +#define vkWriteAccelerationStructuresPropertiesKHR_StubWithCallback vkWriteAccelerationStructuresPropertiesKHR_AddCallback +#define vkWriteAccelerationStructuresPropertiesKHR_ReturnThruPtr_pData(pData) vkWriteAccelerationStructuresPropertiesKHR_CMockReturnMemThruPtr_pData(__LINE__, pData, sizeof(*pData)) +#define vkWriteAccelerationStructuresPropertiesKHR_ReturnArrayThruPtr_pData(pData, cmock_len) vkWriteAccelerationStructuresPropertiesKHR_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_len * sizeof(*pData)) +#define vkWriteAccelerationStructuresPropertiesKHR_ReturnMemThruPtr_pData(pData, cmock_size) vkWriteAccelerationStructuresPropertiesKHR_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_size) +void vkWriteAccelerationStructuresPropertiesKHR_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, void const* pData, size_t cmock_size); +#define vkWriteAccelerationStructuresPropertiesKHR_IgnoreArg_device() vkWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_device(__LINE__) +void vkWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkWriteAccelerationStructuresPropertiesKHR_IgnoreArg_accelerationStructureCount() vkWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_accelerationStructureCount(__LINE__) +void vkWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_accelerationStructureCount(UNITY_LINE_TYPE cmock_line); +#define vkWriteAccelerationStructuresPropertiesKHR_IgnoreArg_pAccelerationStructures() vkWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_pAccelerationStructures(__LINE__) +void vkWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_pAccelerationStructures(UNITY_LINE_TYPE cmock_line); +#define vkWriteAccelerationStructuresPropertiesKHR_IgnoreArg_queryType() vkWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_queryType(__LINE__) +void vkWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_queryType(UNITY_LINE_TYPE cmock_line); +#define vkWriteAccelerationStructuresPropertiesKHR_IgnoreArg_dataSize() vkWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_dataSize(__LINE__) +void vkWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_dataSize(UNITY_LINE_TYPE cmock_line); +#define vkWriteAccelerationStructuresPropertiesKHR_IgnoreArg_pData() vkWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_pData(__LINE__) +void vkWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line); +#define vkWriteAccelerationStructuresPropertiesKHR_IgnoreArg_stride() vkWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_stride(__LINE__) +void vkWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyAccelerationStructureKHR_Ignore() vkCmdCopyAccelerationStructureKHR_CMockIgnore() +void vkCmdCopyAccelerationStructureKHR_CMockIgnore(void); +#define vkCmdCopyAccelerationStructureKHR_StopIgnore() vkCmdCopyAccelerationStructureKHR_CMockStopIgnore() +void vkCmdCopyAccelerationStructureKHR_CMockStopIgnore(void); +#define vkCmdCopyAccelerationStructureKHR_ExpectAnyArgs() vkCmdCopyAccelerationStructureKHR_CMockExpectAnyArgs(__LINE__) +void vkCmdCopyAccelerationStructureKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyAccelerationStructureKHR_Expect(commandBuffer, pInfo) vkCmdCopyAccelerationStructureKHR_CMockExpect(__LINE__, commandBuffer, pInfo) +void vkCmdCopyAccelerationStructureKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo); +typedef void (* CMOCK_vkCmdCopyAccelerationStructureKHR_CALLBACK)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo, int cmock_num_calls); +void vkCmdCopyAccelerationStructureKHR_AddCallback(CMOCK_vkCmdCopyAccelerationStructureKHR_CALLBACK Callback); +void vkCmdCopyAccelerationStructureKHR_Stub(CMOCK_vkCmdCopyAccelerationStructureKHR_CALLBACK Callback); +#define vkCmdCopyAccelerationStructureKHR_StubWithCallback vkCmdCopyAccelerationStructureKHR_AddCallback +#define vkCmdCopyAccelerationStructureKHR_IgnoreArg_commandBuffer() vkCmdCopyAccelerationStructureKHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdCopyAccelerationStructureKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyAccelerationStructureKHR_IgnoreArg_pInfo() vkCmdCopyAccelerationStructureKHR_CMockIgnoreArg_pInfo(__LINE__) +void vkCmdCopyAccelerationStructureKHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyAccelerationStructureToMemoryKHR_Ignore() vkCmdCopyAccelerationStructureToMemoryKHR_CMockIgnore() +void vkCmdCopyAccelerationStructureToMemoryKHR_CMockIgnore(void); +#define vkCmdCopyAccelerationStructureToMemoryKHR_StopIgnore() vkCmdCopyAccelerationStructureToMemoryKHR_CMockStopIgnore() +void vkCmdCopyAccelerationStructureToMemoryKHR_CMockStopIgnore(void); +#define vkCmdCopyAccelerationStructureToMemoryKHR_ExpectAnyArgs() vkCmdCopyAccelerationStructureToMemoryKHR_CMockExpectAnyArgs(__LINE__) +void vkCmdCopyAccelerationStructureToMemoryKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyAccelerationStructureToMemoryKHR_Expect(commandBuffer, pInfo) vkCmdCopyAccelerationStructureToMemoryKHR_CMockExpect(__LINE__, commandBuffer, pInfo) +void vkCmdCopyAccelerationStructureToMemoryKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); +typedef void (* CMOCK_vkCmdCopyAccelerationStructureToMemoryKHR_CALLBACK)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo, int cmock_num_calls); +void vkCmdCopyAccelerationStructureToMemoryKHR_AddCallback(CMOCK_vkCmdCopyAccelerationStructureToMemoryKHR_CALLBACK Callback); +void vkCmdCopyAccelerationStructureToMemoryKHR_Stub(CMOCK_vkCmdCopyAccelerationStructureToMemoryKHR_CALLBACK Callback); +#define vkCmdCopyAccelerationStructureToMemoryKHR_StubWithCallback vkCmdCopyAccelerationStructureToMemoryKHR_AddCallback +#define vkCmdCopyAccelerationStructureToMemoryKHR_IgnoreArg_commandBuffer() vkCmdCopyAccelerationStructureToMemoryKHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdCopyAccelerationStructureToMemoryKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyAccelerationStructureToMemoryKHR_IgnoreArg_pInfo() vkCmdCopyAccelerationStructureToMemoryKHR_CMockIgnoreArg_pInfo(__LINE__) +void vkCmdCopyAccelerationStructureToMemoryKHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyMemoryToAccelerationStructureKHR_Ignore() vkCmdCopyMemoryToAccelerationStructureKHR_CMockIgnore() +void vkCmdCopyMemoryToAccelerationStructureKHR_CMockIgnore(void); +#define vkCmdCopyMemoryToAccelerationStructureKHR_StopIgnore() vkCmdCopyMemoryToAccelerationStructureKHR_CMockStopIgnore() +void vkCmdCopyMemoryToAccelerationStructureKHR_CMockStopIgnore(void); +#define vkCmdCopyMemoryToAccelerationStructureKHR_ExpectAnyArgs() vkCmdCopyMemoryToAccelerationStructureKHR_CMockExpectAnyArgs(__LINE__) +void vkCmdCopyMemoryToAccelerationStructureKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyMemoryToAccelerationStructureKHR_Expect(commandBuffer, pInfo) vkCmdCopyMemoryToAccelerationStructureKHR_CMockExpect(__LINE__, commandBuffer, pInfo) +void vkCmdCopyMemoryToAccelerationStructureKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); +typedef void (* CMOCK_vkCmdCopyMemoryToAccelerationStructureKHR_CALLBACK)(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo, int cmock_num_calls); +void vkCmdCopyMemoryToAccelerationStructureKHR_AddCallback(CMOCK_vkCmdCopyMemoryToAccelerationStructureKHR_CALLBACK Callback); +void vkCmdCopyMemoryToAccelerationStructureKHR_Stub(CMOCK_vkCmdCopyMemoryToAccelerationStructureKHR_CALLBACK Callback); +#define vkCmdCopyMemoryToAccelerationStructureKHR_StubWithCallback vkCmdCopyMemoryToAccelerationStructureKHR_AddCallback +#define vkCmdCopyMemoryToAccelerationStructureKHR_IgnoreArg_commandBuffer() vkCmdCopyMemoryToAccelerationStructureKHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdCopyMemoryToAccelerationStructureKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdCopyMemoryToAccelerationStructureKHR_IgnoreArg_pInfo() vkCmdCopyMemoryToAccelerationStructureKHR_CMockIgnoreArg_pInfo(__LINE__) +void vkCmdCopyMemoryToAccelerationStructureKHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetAccelerationStructureDeviceAddressKHR_IgnoreAndReturn(cmock_retval) vkGetAccelerationStructureDeviceAddressKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetAccelerationStructureDeviceAddressKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkDeviceAddress cmock_to_return); +#define vkGetAccelerationStructureDeviceAddressKHR_StopIgnore() vkGetAccelerationStructureDeviceAddressKHR_CMockStopIgnore() +void vkGetAccelerationStructureDeviceAddressKHR_CMockStopIgnore(void); +#define vkGetAccelerationStructureDeviceAddressKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetAccelerationStructureDeviceAddressKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetAccelerationStructureDeviceAddressKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkDeviceAddress cmock_to_return); +#define vkGetAccelerationStructureDeviceAddressKHR_ExpectAndReturn(device, pInfo, cmock_retval) vkGetAccelerationStructureDeviceAddressKHR_CMockExpectAndReturn(__LINE__, device, pInfo, cmock_retval) +void vkGetAccelerationStructureDeviceAddressKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo, VkDeviceAddress cmock_to_return); +typedef VkDeviceAddress (* CMOCK_vkGetAccelerationStructureDeviceAddressKHR_CALLBACK)(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo, int cmock_num_calls); +void vkGetAccelerationStructureDeviceAddressKHR_AddCallback(CMOCK_vkGetAccelerationStructureDeviceAddressKHR_CALLBACK Callback); +void vkGetAccelerationStructureDeviceAddressKHR_Stub(CMOCK_vkGetAccelerationStructureDeviceAddressKHR_CALLBACK Callback); +#define vkGetAccelerationStructureDeviceAddressKHR_StubWithCallback vkGetAccelerationStructureDeviceAddressKHR_AddCallback +#define vkGetAccelerationStructureDeviceAddressKHR_IgnoreArg_device() vkGetAccelerationStructureDeviceAddressKHR_CMockIgnoreArg_device(__LINE__) +void vkGetAccelerationStructureDeviceAddressKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetAccelerationStructureDeviceAddressKHR_IgnoreArg_pInfo() vkGetAccelerationStructureDeviceAddressKHR_CMockIgnoreArg_pInfo(__LINE__) +void vkGetAccelerationStructureDeviceAddressKHR_CMockIgnoreArg_pInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteAccelerationStructuresPropertiesKHR_Ignore() vkCmdWriteAccelerationStructuresPropertiesKHR_CMockIgnore() +void vkCmdWriteAccelerationStructuresPropertiesKHR_CMockIgnore(void); +#define vkCmdWriteAccelerationStructuresPropertiesKHR_StopIgnore() vkCmdWriteAccelerationStructuresPropertiesKHR_CMockStopIgnore() +void vkCmdWriteAccelerationStructuresPropertiesKHR_CMockStopIgnore(void); +#define vkCmdWriteAccelerationStructuresPropertiesKHR_ExpectAnyArgs() vkCmdWriteAccelerationStructuresPropertiesKHR_CMockExpectAnyArgs(__LINE__) +void vkCmdWriteAccelerationStructuresPropertiesKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteAccelerationStructuresPropertiesKHR_Expect(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery) vkCmdWriteAccelerationStructuresPropertiesKHR_CMockExpect(__LINE__, commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery) +void vkCmdWriteAccelerationStructuresPropertiesKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); +typedef void (* CMOCK_vkCmdWriteAccelerationStructuresPropertiesKHR_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery, int cmock_num_calls); +void vkCmdWriteAccelerationStructuresPropertiesKHR_AddCallback(CMOCK_vkCmdWriteAccelerationStructuresPropertiesKHR_CALLBACK Callback); +void vkCmdWriteAccelerationStructuresPropertiesKHR_Stub(CMOCK_vkCmdWriteAccelerationStructuresPropertiesKHR_CALLBACK Callback); +#define vkCmdWriteAccelerationStructuresPropertiesKHR_StubWithCallback vkCmdWriteAccelerationStructuresPropertiesKHR_AddCallback +#define vkCmdWriteAccelerationStructuresPropertiesKHR_IgnoreArg_commandBuffer() vkCmdWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteAccelerationStructuresPropertiesKHR_IgnoreArg_accelerationStructureCount() vkCmdWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_accelerationStructureCount(__LINE__) +void vkCmdWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_accelerationStructureCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteAccelerationStructuresPropertiesKHR_IgnoreArg_pAccelerationStructures() vkCmdWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_pAccelerationStructures(__LINE__) +void vkCmdWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_pAccelerationStructures(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteAccelerationStructuresPropertiesKHR_IgnoreArg_queryType() vkCmdWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_queryType(__LINE__) +void vkCmdWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_queryType(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteAccelerationStructuresPropertiesKHR_IgnoreArg_queryPool() vkCmdWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_queryPool(__LINE__) +void vkCmdWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_queryPool(UNITY_LINE_TYPE cmock_line); +#define vkCmdWriteAccelerationStructuresPropertiesKHR_IgnoreArg_firstQuery() vkCmdWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_firstQuery(__LINE__) +void vkCmdWriteAccelerationStructuresPropertiesKHR_CMockIgnoreArg_firstQuery(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceAccelerationStructureCompatibilityKHR_Ignore() vkGetDeviceAccelerationStructureCompatibilityKHR_CMockIgnore() +void vkGetDeviceAccelerationStructureCompatibilityKHR_CMockIgnore(void); +#define vkGetDeviceAccelerationStructureCompatibilityKHR_StopIgnore() vkGetDeviceAccelerationStructureCompatibilityKHR_CMockStopIgnore() +void vkGetDeviceAccelerationStructureCompatibilityKHR_CMockStopIgnore(void); +#define vkGetDeviceAccelerationStructureCompatibilityKHR_ExpectAnyArgs() vkGetDeviceAccelerationStructureCompatibilityKHR_CMockExpectAnyArgs(__LINE__) +void vkGetDeviceAccelerationStructureCompatibilityKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceAccelerationStructureCompatibilityKHR_Expect(device, pVersionInfo, pCompatibility) vkGetDeviceAccelerationStructureCompatibilityKHR_CMockExpect(__LINE__, device, pVersionInfo, pCompatibility) +void vkGetDeviceAccelerationStructureCompatibilityKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility); +typedef void (* CMOCK_vkGetDeviceAccelerationStructureCompatibilityKHR_CALLBACK)(VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility, int cmock_num_calls); +void vkGetDeviceAccelerationStructureCompatibilityKHR_AddCallback(CMOCK_vkGetDeviceAccelerationStructureCompatibilityKHR_CALLBACK Callback); +void vkGetDeviceAccelerationStructureCompatibilityKHR_Stub(CMOCK_vkGetDeviceAccelerationStructureCompatibilityKHR_CALLBACK Callback); +#define vkGetDeviceAccelerationStructureCompatibilityKHR_StubWithCallback vkGetDeviceAccelerationStructureCompatibilityKHR_AddCallback +#define vkGetDeviceAccelerationStructureCompatibilityKHR_ReturnThruPtr_pCompatibility(pCompatibility) vkGetDeviceAccelerationStructureCompatibilityKHR_CMockReturnMemThruPtr_pCompatibility(__LINE__, pCompatibility, sizeof(VkAccelerationStructureCompatibilityKHR)) +#define vkGetDeviceAccelerationStructureCompatibilityKHR_ReturnArrayThruPtr_pCompatibility(pCompatibility, cmock_len) vkGetDeviceAccelerationStructureCompatibilityKHR_CMockReturnMemThruPtr_pCompatibility(__LINE__, pCompatibility, cmock_len * sizeof(*pCompatibility)) +#define vkGetDeviceAccelerationStructureCompatibilityKHR_ReturnMemThruPtr_pCompatibility(pCompatibility, cmock_size) vkGetDeviceAccelerationStructureCompatibilityKHR_CMockReturnMemThruPtr_pCompatibility(__LINE__, pCompatibility, cmock_size) +void vkGetDeviceAccelerationStructureCompatibilityKHR_CMockReturnMemThruPtr_pCompatibility(UNITY_LINE_TYPE cmock_line, VkAccelerationStructureCompatibilityKHR const* pCompatibility, size_t cmock_size); +#define vkGetDeviceAccelerationStructureCompatibilityKHR_IgnoreArg_device() vkGetDeviceAccelerationStructureCompatibilityKHR_CMockIgnoreArg_device(__LINE__) +void vkGetDeviceAccelerationStructureCompatibilityKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceAccelerationStructureCompatibilityKHR_IgnoreArg_pVersionInfo() vkGetDeviceAccelerationStructureCompatibilityKHR_CMockIgnoreArg_pVersionInfo(__LINE__) +void vkGetDeviceAccelerationStructureCompatibilityKHR_CMockIgnoreArg_pVersionInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetDeviceAccelerationStructureCompatibilityKHR_IgnoreArg_pCompatibility() vkGetDeviceAccelerationStructureCompatibilityKHR_CMockIgnoreArg_pCompatibility(__LINE__) +void vkGetDeviceAccelerationStructureCompatibilityKHR_CMockIgnoreArg_pCompatibility(UNITY_LINE_TYPE cmock_line); +#define vkGetAccelerationStructureBuildSizesKHR_Ignore() vkGetAccelerationStructureBuildSizesKHR_CMockIgnore() +void vkGetAccelerationStructureBuildSizesKHR_CMockIgnore(void); +#define vkGetAccelerationStructureBuildSizesKHR_StopIgnore() vkGetAccelerationStructureBuildSizesKHR_CMockStopIgnore() +void vkGetAccelerationStructureBuildSizesKHR_CMockStopIgnore(void); +#define vkGetAccelerationStructureBuildSizesKHR_ExpectAnyArgs() vkGetAccelerationStructureBuildSizesKHR_CMockExpectAnyArgs(__LINE__) +void vkGetAccelerationStructureBuildSizesKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkGetAccelerationStructureBuildSizesKHR_Expect(device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo) vkGetAccelerationStructureBuildSizesKHR_CMockExpect(__LINE__, device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo) +void vkGetAccelerationStructureBuildSizesKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo); +typedef void (* CMOCK_vkGetAccelerationStructureBuildSizesKHR_CALLBACK)(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo, int cmock_num_calls); +void vkGetAccelerationStructureBuildSizesKHR_AddCallback(CMOCK_vkGetAccelerationStructureBuildSizesKHR_CALLBACK Callback); +void vkGetAccelerationStructureBuildSizesKHR_Stub(CMOCK_vkGetAccelerationStructureBuildSizesKHR_CALLBACK Callback); +#define vkGetAccelerationStructureBuildSizesKHR_StubWithCallback vkGetAccelerationStructureBuildSizesKHR_AddCallback +#define vkGetAccelerationStructureBuildSizesKHR_ReturnThruPtr_pSizeInfo(pSizeInfo) vkGetAccelerationStructureBuildSizesKHR_CMockReturnMemThruPtr_pSizeInfo(__LINE__, pSizeInfo, sizeof(VkAccelerationStructureBuildSizesInfoKHR)) +#define vkGetAccelerationStructureBuildSizesKHR_ReturnArrayThruPtr_pSizeInfo(pSizeInfo, cmock_len) vkGetAccelerationStructureBuildSizesKHR_CMockReturnMemThruPtr_pSizeInfo(__LINE__, pSizeInfo, cmock_len * sizeof(*pSizeInfo)) +#define vkGetAccelerationStructureBuildSizesKHR_ReturnMemThruPtr_pSizeInfo(pSizeInfo, cmock_size) vkGetAccelerationStructureBuildSizesKHR_CMockReturnMemThruPtr_pSizeInfo(__LINE__, pSizeInfo, cmock_size) +void vkGetAccelerationStructureBuildSizesKHR_CMockReturnMemThruPtr_pSizeInfo(UNITY_LINE_TYPE cmock_line, VkAccelerationStructureBuildSizesInfoKHR const* pSizeInfo, size_t cmock_size); +#define vkGetAccelerationStructureBuildSizesKHR_IgnoreArg_device() vkGetAccelerationStructureBuildSizesKHR_CMockIgnoreArg_device(__LINE__) +void vkGetAccelerationStructureBuildSizesKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetAccelerationStructureBuildSizesKHR_IgnoreArg_buildType() vkGetAccelerationStructureBuildSizesKHR_CMockIgnoreArg_buildType(__LINE__) +void vkGetAccelerationStructureBuildSizesKHR_CMockIgnoreArg_buildType(UNITY_LINE_TYPE cmock_line); +#define vkGetAccelerationStructureBuildSizesKHR_IgnoreArg_pBuildInfo() vkGetAccelerationStructureBuildSizesKHR_CMockIgnoreArg_pBuildInfo(__LINE__) +void vkGetAccelerationStructureBuildSizesKHR_CMockIgnoreArg_pBuildInfo(UNITY_LINE_TYPE cmock_line); +#define vkGetAccelerationStructureBuildSizesKHR_IgnoreArg_pMaxPrimitiveCounts() vkGetAccelerationStructureBuildSizesKHR_CMockIgnoreArg_pMaxPrimitiveCounts(__LINE__) +void vkGetAccelerationStructureBuildSizesKHR_CMockIgnoreArg_pMaxPrimitiveCounts(UNITY_LINE_TYPE cmock_line); +#define vkGetAccelerationStructureBuildSizesKHR_IgnoreArg_pSizeInfo() vkGetAccelerationStructureBuildSizesKHR_CMockIgnoreArg_pSizeInfo(__LINE__) +void vkGetAccelerationStructureBuildSizesKHR_CMockIgnoreArg_pSizeInfo(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysKHR_Ignore() vkCmdTraceRaysKHR_CMockIgnore() +void vkCmdTraceRaysKHR_CMockIgnore(void); +#define vkCmdTraceRaysKHR_StopIgnore() vkCmdTraceRaysKHR_CMockStopIgnore() +void vkCmdTraceRaysKHR_CMockStopIgnore(void); +#define vkCmdTraceRaysKHR_ExpectAnyArgs() vkCmdTraceRaysKHR_CMockExpectAnyArgs(__LINE__) +void vkCmdTraceRaysKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysKHR_Expect(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth) vkCmdTraceRaysKHR_CMockExpect(__LINE__, commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth) +void vkCmdTraceRaysKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth); +typedef void (* CMOCK_vkCmdTraceRaysKHR_CALLBACK)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth, int cmock_num_calls); +void vkCmdTraceRaysKHR_AddCallback(CMOCK_vkCmdTraceRaysKHR_CALLBACK Callback); +void vkCmdTraceRaysKHR_Stub(CMOCK_vkCmdTraceRaysKHR_CALLBACK Callback); +#define vkCmdTraceRaysKHR_StubWithCallback vkCmdTraceRaysKHR_AddCallback +#define vkCmdTraceRaysKHR_IgnoreArg_commandBuffer() vkCmdTraceRaysKHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdTraceRaysKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysKHR_IgnoreArg_pRaygenShaderBindingTable() vkCmdTraceRaysKHR_CMockIgnoreArg_pRaygenShaderBindingTable(__LINE__) +void vkCmdTraceRaysKHR_CMockIgnoreArg_pRaygenShaderBindingTable(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysKHR_IgnoreArg_pMissShaderBindingTable() vkCmdTraceRaysKHR_CMockIgnoreArg_pMissShaderBindingTable(__LINE__) +void vkCmdTraceRaysKHR_CMockIgnoreArg_pMissShaderBindingTable(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysKHR_IgnoreArg_pHitShaderBindingTable() vkCmdTraceRaysKHR_CMockIgnoreArg_pHitShaderBindingTable(__LINE__) +void vkCmdTraceRaysKHR_CMockIgnoreArg_pHitShaderBindingTable(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysKHR_IgnoreArg_pCallableShaderBindingTable() vkCmdTraceRaysKHR_CMockIgnoreArg_pCallableShaderBindingTable(__LINE__) +void vkCmdTraceRaysKHR_CMockIgnoreArg_pCallableShaderBindingTable(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysKHR_IgnoreArg_width() vkCmdTraceRaysKHR_CMockIgnoreArg_width(__LINE__) +void vkCmdTraceRaysKHR_CMockIgnoreArg_width(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysKHR_IgnoreArg_height() vkCmdTraceRaysKHR_CMockIgnoreArg_height(__LINE__) +void vkCmdTraceRaysKHR_CMockIgnoreArg_height(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysKHR_IgnoreArg_depth() vkCmdTraceRaysKHR_CMockIgnoreArg_depth(__LINE__) +void vkCmdTraceRaysKHR_CMockIgnoreArg_depth(UNITY_LINE_TYPE cmock_line); +#define vkCreateRayTracingPipelinesKHR_IgnoreAndReturn(cmock_retval) vkCreateRayTracingPipelinesKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkCreateRayTracingPipelinesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateRayTracingPipelinesKHR_StopIgnore() vkCreateRayTracingPipelinesKHR_CMockStopIgnore() +void vkCreateRayTracingPipelinesKHR_CMockStopIgnore(void); +#define vkCreateRayTracingPipelinesKHR_ExpectAnyArgsAndReturn(cmock_retval) vkCreateRayTracingPipelinesKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkCreateRayTracingPipelinesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkCreateRayTracingPipelinesKHR_ExpectAndReturn(device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, cmock_retval) vkCreateRayTracingPipelinesKHR_CMockExpectAndReturn(__LINE__, device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, cmock_retval) +void vkCreateRayTracingPipelinesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkCreateRayTracingPipelinesKHR_CALLBACK)(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, int cmock_num_calls); +void vkCreateRayTracingPipelinesKHR_AddCallback(CMOCK_vkCreateRayTracingPipelinesKHR_CALLBACK Callback); +void vkCreateRayTracingPipelinesKHR_Stub(CMOCK_vkCreateRayTracingPipelinesKHR_CALLBACK Callback); +#define vkCreateRayTracingPipelinesKHR_StubWithCallback vkCreateRayTracingPipelinesKHR_AddCallback +#define vkCreateRayTracingPipelinesKHR_ReturnThruPtr_pPipelines(pPipelines) vkCreateRayTracingPipelinesKHR_CMockReturnMemThruPtr_pPipelines(__LINE__, pPipelines, sizeof(VkPipeline)) +#define vkCreateRayTracingPipelinesKHR_ReturnArrayThruPtr_pPipelines(pPipelines, cmock_len) vkCreateRayTracingPipelinesKHR_CMockReturnMemThruPtr_pPipelines(__LINE__, pPipelines, cmock_len * sizeof(*pPipelines)) +#define vkCreateRayTracingPipelinesKHR_ReturnMemThruPtr_pPipelines(pPipelines, cmock_size) vkCreateRayTracingPipelinesKHR_CMockReturnMemThruPtr_pPipelines(__LINE__, pPipelines, cmock_size) +void vkCreateRayTracingPipelinesKHR_CMockReturnMemThruPtr_pPipelines(UNITY_LINE_TYPE cmock_line, VkPipeline const* pPipelines, size_t cmock_size); +#define vkCreateRayTracingPipelinesKHR_IgnoreArg_device() vkCreateRayTracingPipelinesKHR_CMockIgnoreArg_device(__LINE__) +void vkCreateRayTracingPipelinesKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkCreateRayTracingPipelinesKHR_IgnoreArg_deferredOperation() vkCreateRayTracingPipelinesKHR_CMockIgnoreArg_deferredOperation(__LINE__) +void vkCreateRayTracingPipelinesKHR_CMockIgnoreArg_deferredOperation(UNITY_LINE_TYPE cmock_line); +#define vkCreateRayTracingPipelinesKHR_IgnoreArg_pipelineCache() vkCreateRayTracingPipelinesKHR_CMockIgnoreArg_pipelineCache(__LINE__) +void vkCreateRayTracingPipelinesKHR_CMockIgnoreArg_pipelineCache(UNITY_LINE_TYPE cmock_line); +#define vkCreateRayTracingPipelinesKHR_IgnoreArg_createInfoCount() vkCreateRayTracingPipelinesKHR_CMockIgnoreArg_createInfoCount(__LINE__) +void vkCreateRayTracingPipelinesKHR_CMockIgnoreArg_createInfoCount(UNITY_LINE_TYPE cmock_line); +#define vkCreateRayTracingPipelinesKHR_IgnoreArg_pCreateInfos() vkCreateRayTracingPipelinesKHR_CMockIgnoreArg_pCreateInfos(__LINE__) +void vkCreateRayTracingPipelinesKHR_CMockIgnoreArg_pCreateInfos(UNITY_LINE_TYPE cmock_line); +#define vkCreateRayTracingPipelinesKHR_IgnoreArg_pAllocator() vkCreateRayTracingPipelinesKHR_CMockIgnoreArg_pAllocator(__LINE__) +void vkCreateRayTracingPipelinesKHR_CMockIgnoreArg_pAllocator(UNITY_LINE_TYPE cmock_line); +#define vkCreateRayTracingPipelinesKHR_IgnoreArg_pPipelines() vkCreateRayTracingPipelinesKHR_CMockIgnoreArg_pPipelines(__LINE__) +void vkCreateRayTracingPipelinesKHR_CMockIgnoreArg_pPipelines(UNITY_LINE_TYPE cmock_line); +#define vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_IgnoreAndReturn(cmock_retval) vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_StopIgnore() vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockStopIgnore() +void vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockStopIgnore(void); +#define vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkResult cmock_to_return); +#define vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_ExpectAndReturn(device, pipeline, firstGroup, groupCount, dataSize, pData, cmock_retval) vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockExpectAndReturn(__LINE__, device, pipeline, firstGroup, groupCount, dataSize, pData, cmock_retval) +void vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, VkResult cmock_to_return); +typedef VkResult (* CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALLBACK)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData, int cmock_num_calls); +void vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_AddCallback(CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALLBACK Callback); +void vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_Stub(CMOCK_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CALLBACK Callback); +#define vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_StubWithCallback vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_AddCallback +#define vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_ReturnThruPtr_pData(pData) vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockReturnMemThruPtr_pData(__LINE__, pData, sizeof(*pData)) +#define vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_ReturnArrayThruPtr_pData(pData, cmock_len) vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_len * sizeof(*pData)) +#define vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_ReturnMemThruPtr_pData(pData, cmock_size) vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockReturnMemThruPtr_pData(__LINE__, pData, cmock_size) +void vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockReturnMemThruPtr_pData(UNITY_LINE_TYPE cmock_line, void const* pData, size_t cmock_size); +#define vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_IgnoreArg_device() vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockIgnoreArg_device(__LINE__) +void vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_IgnoreArg_pipeline() vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockIgnoreArg_pipeline(__LINE__) +void vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockIgnoreArg_pipeline(UNITY_LINE_TYPE cmock_line); +#define vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_IgnoreArg_firstGroup() vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockIgnoreArg_firstGroup(__LINE__) +void vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockIgnoreArg_firstGroup(UNITY_LINE_TYPE cmock_line); +#define vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_IgnoreArg_groupCount() vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockIgnoreArg_groupCount(__LINE__) +void vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockIgnoreArg_groupCount(UNITY_LINE_TYPE cmock_line); +#define vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_IgnoreArg_dataSize() vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockIgnoreArg_dataSize(__LINE__) +void vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockIgnoreArg_dataSize(UNITY_LINE_TYPE cmock_line); +#define vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_IgnoreArg_pData() vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockIgnoreArg_pData(__LINE__) +void vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_CMockIgnoreArg_pData(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysIndirectKHR_Ignore() vkCmdTraceRaysIndirectKHR_CMockIgnore() +void vkCmdTraceRaysIndirectKHR_CMockIgnore(void); +#define vkCmdTraceRaysIndirectKHR_StopIgnore() vkCmdTraceRaysIndirectKHR_CMockStopIgnore() +void vkCmdTraceRaysIndirectKHR_CMockStopIgnore(void); +#define vkCmdTraceRaysIndirectKHR_ExpectAnyArgs() vkCmdTraceRaysIndirectKHR_CMockExpectAnyArgs(__LINE__) +void vkCmdTraceRaysIndirectKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysIndirectKHR_Expect(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress) vkCmdTraceRaysIndirectKHR_CMockExpect(__LINE__, commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress) +void vkCmdTraceRaysIndirectKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress); +typedef void (* CMOCK_vkCmdTraceRaysIndirectKHR_CALLBACK)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress, int cmock_num_calls); +void vkCmdTraceRaysIndirectKHR_AddCallback(CMOCK_vkCmdTraceRaysIndirectKHR_CALLBACK Callback); +void vkCmdTraceRaysIndirectKHR_Stub(CMOCK_vkCmdTraceRaysIndirectKHR_CALLBACK Callback); +#define vkCmdTraceRaysIndirectKHR_StubWithCallback vkCmdTraceRaysIndirectKHR_AddCallback +#define vkCmdTraceRaysIndirectKHR_IgnoreArg_commandBuffer() vkCmdTraceRaysIndirectKHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdTraceRaysIndirectKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysIndirectKHR_IgnoreArg_pRaygenShaderBindingTable() vkCmdTraceRaysIndirectKHR_CMockIgnoreArg_pRaygenShaderBindingTable(__LINE__) +void vkCmdTraceRaysIndirectKHR_CMockIgnoreArg_pRaygenShaderBindingTable(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysIndirectKHR_IgnoreArg_pMissShaderBindingTable() vkCmdTraceRaysIndirectKHR_CMockIgnoreArg_pMissShaderBindingTable(__LINE__) +void vkCmdTraceRaysIndirectKHR_CMockIgnoreArg_pMissShaderBindingTable(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysIndirectKHR_IgnoreArg_pHitShaderBindingTable() vkCmdTraceRaysIndirectKHR_CMockIgnoreArg_pHitShaderBindingTable(__LINE__) +void vkCmdTraceRaysIndirectKHR_CMockIgnoreArg_pHitShaderBindingTable(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysIndirectKHR_IgnoreArg_pCallableShaderBindingTable() vkCmdTraceRaysIndirectKHR_CMockIgnoreArg_pCallableShaderBindingTable(__LINE__) +void vkCmdTraceRaysIndirectKHR_CMockIgnoreArg_pCallableShaderBindingTable(UNITY_LINE_TYPE cmock_line); +#define vkCmdTraceRaysIndirectKHR_IgnoreArg_indirectDeviceAddress() vkCmdTraceRaysIndirectKHR_CMockIgnoreArg_indirectDeviceAddress(__LINE__) +void vkCmdTraceRaysIndirectKHR_CMockIgnoreArg_indirectDeviceAddress(UNITY_LINE_TYPE cmock_line); +#define vkGetRayTracingShaderGroupStackSizeKHR_IgnoreAndReturn(cmock_retval) vkGetRayTracingShaderGroupStackSizeKHR_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void vkGetRayTracingShaderGroupStackSizeKHR_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, VkDeviceSize cmock_to_return); +#define vkGetRayTracingShaderGroupStackSizeKHR_StopIgnore() vkGetRayTracingShaderGroupStackSizeKHR_CMockStopIgnore() +void vkGetRayTracingShaderGroupStackSizeKHR_CMockStopIgnore(void); +#define vkGetRayTracingShaderGroupStackSizeKHR_ExpectAnyArgsAndReturn(cmock_retval) vkGetRayTracingShaderGroupStackSizeKHR_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void vkGetRayTracingShaderGroupStackSizeKHR_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, VkDeviceSize cmock_to_return); +#define vkGetRayTracingShaderGroupStackSizeKHR_ExpectAndReturn(device, pipeline, group, groupShader, cmock_retval) vkGetRayTracingShaderGroupStackSizeKHR_CMockExpectAndReturn(__LINE__, device, pipeline, group, groupShader, cmock_retval) +void vkGetRayTracingShaderGroupStackSizeKHR_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader, VkDeviceSize cmock_to_return); +typedef VkDeviceSize (* CMOCK_vkGetRayTracingShaderGroupStackSizeKHR_CALLBACK)(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader, int cmock_num_calls); +void vkGetRayTracingShaderGroupStackSizeKHR_AddCallback(CMOCK_vkGetRayTracingShaderGroupStackSizeKHR_CALLBACK Callback); +void vkGetRayTracingShaderGroupStackSizeKHR_Stub(CMOCK_vkGetRayTracingShaderGroupStackSizeKHR_CALLBACK Callback); +#define vkGetRayTracingShaderGroupStackSizeKHR_StubWithCallback vkGetRayTracingShaderGroupStackSizeKHR_AddCallback +#define vkGetRayTracingShaderGroupStackSizeKHR_IgnoreArg_device() vkGetRayTracingShaderGroupStackSizeKHR_CMockIgnoreArg_device(__LINE__) +void vkGetRayTracingShaderGroupStackSizeKHR_CMockIgnoreArg_device(UNITY_LINE_TYPE cmock_line); +#define vkGetRayTracingShaderGroupStackSizeKHR_IgnoreArg_pipeline() vkGetRayTracingShaderGroupStackSizeKHR_CMockIgnoreArg_pipeline(__LINE__) +void vkGetRayTracingShaderGroupStackSizeKHR_CMockIgnoreArg_pipeline(UNITY_LINE_TYPE cmock_line); +#define vkGetRayTracingShaderGroupStackSizeKHR_IgnoreArg_group() vkGetRayTracingShaderGroupStackSizeKHR_CMockIgnoreArg_group(__LINE__) +void vkGetRayTracingShaderGroupStackSizeKHR_CMockIgnoreArg_group(UNITY_LINE_TYPE cmock_line); +#define vkGetRayTracingShaderGroupStackSizeKHR_IgnoreArg_groupShader() vkGetRayTracingShaderGroupStackSizeKHR_CMockIgnoreArg_groupShader(__LINE__) +void vkGetRayTracingShaderGroupStackSizeKHR_CMockIgnoreArg_groupShader(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetRayTracingPipelineStackSizeKHR_Ignore() vkCmdSetRayTracingPipelineStackSizeKHR_CMockIgnore() +void vkCmdSetRayTracingPipelineStackSizeKHR_CMockIgnore(void); +#define vkCmdSetRayTracingPipelineStackSizeKHR_StopIgnore() vkCmdSetRayTracingPipelineStackSizeKHR_CMockStopIgnore() +void vkCmdSetRayTracingPipelineStackSizeKHR_CMockStopIgnore(void); +#define vkCmdSetRayTracingPipelineStackSizeKHR_ExpectAnyArgs() vkCmdSetRayTracingPipelineStackSizeKHR_CMockExpectAnyArgs(__LINE__) +void vkCmdSetRayTracingPipelineStackSizeKHR_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetRayTracingPipelineStackSizeKHR_Expect(commandBuffer, pipelineStackSize) vkCmdSetRayTracingPipelineStackSizeKHR_CMockExpect(__LINE__, commandBuffer, pipelineStackSize) +void vkCmdSetRayTracingPipelineStackSizeKHR_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t pipelineStackSize); +typedef void (* CMOCK_vkCmdSetRayTracingPipelineStackSizeKHR_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize, int cmock_num_calls); +void vkCmdSetRayTracingPipelineStackSizeKHR_AddCallback(CMOCK_vkCmdSetRayTracingPipelineStackSizeKHR_CALLBACK Callback); +void vkCmdSetRayTracingPipelineStackSizeKHR_Stub(CMOCK_vkCmdSetRayTracingPipelineStackSizeKHR_CALLBACK Callback); +#define vkCmdSetRayTracingPipelineStackSizeKHR_StubWithCallback vkCmdSetRayTracingPipelineStackSizeKHR_AddCallback +#define vkCmdSetRayTracingPipelineStackSizeKHR_IgnoreArg_commandBuffer() vkCmdSetRayTracingPipelineStackSizeKHR_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdSetRayTracingPipelineStackSizeKHR_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdSetRayTracingPipelineStackSizeKHR_IgnoreArg_pipelineStackSize() vkCmdSetRayTracingPipelineStackSizeKHR_CMockIgnoreArg_pipelineStackSize(__LINE__) +void vkCmdSetRayTracingPipelineStackSizeKHR_CMockIgnoreArg_pipelineStackSize(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksEXT_Ignore() vkCmdDrawMeshTasksEXT_CMockIgnore() +void vkCmdDrawMeshTasksEXT_CMockIgnore(void); +#define vkCmdDrawMeshTasksEXT_StopIgnore() vkCmdDrawMeshTasksEXT_CMockStopIgnore() +void vkCmdDrawMeshTasksEXT_CMockStopIgnore(void); +#define vkCmdDrawMeshTasksEXT_ExpectAnyArgs() vkCmdDrawMeshTasksEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdDrawMeshTasksEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksEXT_Expect(commandBuffer, groupCountX, groupCountY, groupCountZ) vkCmdDrawMeshTasksEXT_CMockExpect(__LINE__, commandBuffer, groupCountX, groupCountY, groupCountZ) +void vkCmdDrawMeshTasksEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef void (* CMOCK_vkCmdDrawMeshTasksEXT_CALLBACK)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, int cmock_num_calls); +void vkCmdDrawMeshTasksEXT_AddCallback(CMOCK_vkCmdDrawMeshTasksEXT_CALLBACK Callback); +void vkCmdDrawMeshTasksEXT_Stub(CMOCK_vkCmdDrawMeshTasksEXT_CALLBACK Callback); +#define vkCmdDrawMeshTasksEXT_StubWithCallback vkCmdDrawMeshTasksEXT_AddCallback +#define vkCmdDrawMeshTasksEXT_IgnoreArg_commandBuffer() vkCmdDrawMeshTasksEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDrawMeshTasksEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksEXT_IgnoreArg_groupCountX() vkCmdDrawMeshTasksEXT_CMockIgnoreArg_groupCountX(__LINE__) +void vkCmdDrawMeshTasksEXT_CMockIgnoreArg_groupCountX(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksEXT_IgnoreArg_groupCountY() vkCmdDrawMeshTasksEXT_CMockIgnoreArg_groupCountY(__LINE__) +void vkCmdDrawMeshTasksEXT_CMockIgnoreArg_groupCountY(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksEXT_IgnoreArg_groupCountZ() vkCmdDrawMeshTasksEXT_CMockIgnoreArg_groupCountZ(__LINE__) +void vkCmdDrawMeshTasksEXT_CMockIgnoreArg_groupCountZ(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksIndirectEXT_Ignore() vkCmdDrawMeshTasksIndirectEXT_CMockIgnore() +void vkCmdDrawMeshTasksIndirectEXT_CMockIgnore(void); +#define vkCmdDrawMeshTasksIndirectEXT_StopIgnore() vkCmdDrawMeshTasksIndirectEXT_CMockStopIgnore() +void vkCmdDrawMeshTasksIndirectEXT_CMockStopIgnore(void); +#define vkCmdDrawMeshTasksIndirectEXT_ExpectAnyArgs() vkCmdDrawMeshTasksIndirectEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdDrawMeshTasksIndirectEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksIndirectEXT_Expect(commandBuffer, buffer, offset, drawCount, stride) vkCmdDrawMeshTasksIndirectEXT_CMockExpect(__LINE__, commandBuffer, buffer, offset, drawCount, stride) +void vkCmdDrawMeshTasksIndirectEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void (* CMOCK_vkCmdDrawMeshTasksIndirectEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride, int cmock_num_calls); +void vkCmdDrawMeshTasksIndirectEXT_AddCallback(CMOCK_vkCmdDrawMeshTasksIndirectEXT_CALLBACK Callback); +void vkCmdDrawMeshTasksIndirectEXT_Stub(CMOCK_vkCmdDrawMeshTasksIndirectEXT_CALLBACK Callback); +#define vkCmdDrawMeshTasksIndirectEXT_StubWithCallback vkCmdDrawMeshTasksIndirectEXT_AddCallback +#define vkCmdDrawMeshTasksIndirectEXT_IgnoreArg_commandBuffer() vkCmdDrawMeshTasksIndirectEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDrawMeshTasksIndirectEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksIndirectEXT_IgnoreArg_buffer() vkCmdDrawMeshTasksIndirectEXT_CMockIgnoreArg_buffer(__LINE__) +void vkCmdDrawMeshTasksIndirectEXT_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksIndirectEXT_IgnoreArg_offset() vkCmdDrawMeshTasksIndirectEXT_CMockIgnoreArg_offset(__LINE__) +void vkCmdDrawMeshTasksIndirectEXT_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksIndirectEXT_IgnoreArg_drawCount() vkCmdDrawMeshTasksIndirectEXT_CMockIgnoreArg_drawCount(__LINE__) +void vkCmdDrawMeshTasksIndirectEXT_CMockIgnoreArg_drawCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksIndirectEXT_IgnoreArg_stride() vkCmdDrawMeshTasksIndirectEXT_CMockIgnoreArg_stride(__LINE__) +void vkCmdDrawMeshTasksIndirectEXT_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksIndirectCountEXT_Ignore() vkCmdDrawMeshTasksIndirectCountEXT_CMockIgnore() +void vkCmdDrawMeshTasksIndirectCountEXT_CMockIgnore(void); +#define vkCmdDrawMeshTasksIndirectCountEXT_StopIgnore() vkCmdDrawMeshTasksIndirectCountEXT_CMockStopIgnore() +void vkCmdDrawMeshTasksIndirectCountEXT_CMockStopIgnore(void); +#define vkCmdDrawMeshTasksIndirectCountEXT_ExpectAnyArgs() vkCmdDrawMeshTasksIndirectCountEXT_CMockExpectAnyArgs(__LINE__) +void vkCmdDrawMeshTasksIndirectCountEXT_CMockExpectAnyArgs(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksIndirectCountEXT_Expect(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride) vkCmdDrawMeshTasksIndirectCountEXT_CMockExpect(__LINE__, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride) +void vkCmdDrawMeshTasksIndirectCountEXT_CMockExpect(UNITY_LINE_TYPE cmock_line, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef void (* CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALLBACK)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride, int cmock_num_calls); +void vkCmdDrawMeshTasksIndirectCountEXT_AddCallback(CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALLBACK Callback); +void vkCmdDrawMeshTasksIndirectCountEXT_Stub(CMOCK_vkCmdDrawMeshTasksIndirectCountEXT_CALLBACK Callback); +#define vkCmdDrawMeshTasksIndirectCountEXT_StubWithCallback vkCmdDrawMeshTasksIndirectCountEXT_AddCallback +#define vkCmdDrawMeshTasksIndirectCountEXT_IgnoreArg_commandBuffer() vkCmdDrawMeshTasksIndirectCountEXT_CMockIgnoreArg_commandBuffer(__LINE__) +void vkCmdDrawMeshTasksIndirectCountEXT_CMockIgnoreArg_commandBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksIndirectCountEXT_IgnoreArg_buffer() vkCmdDrawMeshTasksIndirectCountEXT_CMockIgnoreArg_buffer(__LINE__) +void vkCmdDrawMeshTasksIndirectCountEXT_CMockIgnoreArg_buffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksIndirectCountEXT_IgnoreArg_offset() vkCmdDrawMeshTasksIndirectCountEXT_CMockIgnoreArg_offset(__LINE__) +void vkCmdDrawMeshTasksIndirectCountEXT_CMockIgnoreArg_offset(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksIndirectCountEXT_IgnoreArg_countBuffer() vkCmdDrawMeshTasksIndirectCountEXT_CMockIgnoreArg_countBuffer(__LINE__) +void vkCmdDrawMeshTasksIndirectCountEXT_CMockIgnoreArg_countBuffer(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksIndirectCountEXT_IgnoreArg_countBufferOffset() vkCmdDrawMeshTasksIndirectCountEXT_CMockIgnoreArg_countBufferOffset(__LINE__) +void vkCmdDrawMeshTasksIndirectCountEXT_CMockIgnoreArg_countBufferOffset(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksIndirectCountEXT_IgnoreArg_maxDrawCount() vkCmdDrawMeshTasksIndirectCountEXT_CMockIgnoreArg_maxDrawCount(__LINE__) +void vkCmdDrawMeshTasksIndirectCountEXT_CMockIgnoreArg_maxDrawCount(UNITY_LINE_TYPE cmock_line); +#define vkCmdDrawMeshTasksIndirectCountEXT_IgnoreArg_stride() vkCmdDrawMeshTasksIndirectCountEXT_CMockIgnoreArg_stride(__LINE__) +void vkCmdDrawMeshTasksIndirectCountEXT_CMockIgnoreArg_stride(UNITY_LINE_TYPE cmock_line); + +#ifdef __cplusplus +} +#endif + +#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__) +#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0))) +#pragma GCC diagnostic pop +#endif +#endif + +#endif diff --git a/tests/src/rse_graphics_tests.c b/tests/src/rse_graphics_tests.c deleted file mode 100644 index 64bf83c6..00000000 --- a/tests/src/rse_graphics_tests.c +++ /dev/null @@ -1,183 +0,0 @@ -#include "criterion/criterion.h" -#include "graphics/src/rse_math.h" - -/*-----------------RSE MATH TEST------------------------*/ - -TestSuite(rse_math); - -Test(rse_math, normalize) -{ - float res_x = 0.8017f; - float res_y = 0.2672f; - float res_z = 0.5345f; - struct vec3_t test_vec = {3.0f, 1.0f, 2.0f}; - - struct vec3_t result = rse_math_normalize_vec3(&test_vec); - - cr_expect_float_eq(result.x, res_x, 0.0001, "Expected %f, got %f", res_x, result.x); - cr_expect_float_eq(result.y, res_y, 0.0001, "Expected %f, got %f", res_y, result.y); - cr_expect_float_eq(result.z, res_z, 0.0001, "Expected %f, got %f", res_z, result.z); -} - -Test(rse_math, cross) -{ - float res_x = -3.0f; - float res_y = 6.0f; - float res_z = -3.0f; - struct vec3_t test_vec1 = {2.0f, 3.0f, 4.0f}; - struct vec3_t test_vec2 = {5.0f, 6.0f, 7.0f}; - - struct vec3_t result = rse_math_cross_vec3(&test_vec1, &test_vec2); - - cr_expect_float_eq(result.x, res_x, 0.0001, "Expected %f, got %f", res_x, result.x); - cr_expect_float_eq(result.y, res_y, 0.0001, "Expected %f, got %f", res_y, result.y); - cr_expect_float_eq(result.z, res_z, 0.0001, "Expected %f, got %f", res_z, result.z); -} - -Test(rse_math, look_at) -{ - struct vec3_t eye; - struct vec3_t center; - struct vec3_t up; - struct mat4_t result; - struct mat4_t expected; - - eye.x = 0.0f; - eye.y = 0.0f; - eye.z = 5.0f; - - center.x = 0.0f; - center.y = 0.0f; - center.z = 0.0f; - - up.x = 0.0f; - up.y = 0.1f; - up.z = 0.0f; - - expected.x_1 = 1.0f; - expected.y_1 = 0.0f; - expected.z_1 = 0.0f; - expected.w_1 = 0.0f; - - expected.x_2 = 0.0f; - expected.y_2 = 1.0f; - expected.z_2 = 0.0f; - expected.w_2 = 0.0f; - - expected.x_3 = 0.0f; - expected.y_3 = 0.0f; - expected.z_3 = 1.0f; - expected.w_3 = 0.0f; - - expected.x_4 = 0.0f; - expected.y_4 = 0.0f; - expected.z_4 = -5.0f; - expected.w_4 = 1.0f; - - result = rse_math_look_at(&eye, ¢er, &up); - - cr_expect_float_eq(result.x_1, expected.x_1, 0.0001, "Expected x_1 %f, got %f", expected.x_1, result.x_1); - cr_expect_float_eq(result.y_1, expected.y_1, 0.0001, "Expected y_1 %f, got %f", expected.y_1, result.y_1); - cr_expect_float_eq(result.z_1, expected.z_1, 0.0001, "Expected z_1 %f, got %f", expected.z_1, result.z_1); - cr_expect_float_eq(result.w_1, expected.w_1, 0.0001, "Expected w_1 %f, got %f", expected.w_1, result.w_1); - - cr_expect_float_eq(result.x_2, expected.x_2, 0.0001, "Expected x_2 %f, got %f", expected.x_2, result.x_2); - cr_expect_float_eq(result.y_2, expected.y_2, 0.0001, "Expected y_2 %f, got %f", expected.y_2, result.y_2); - cr_expect_float_eq(result.z_2, expected.z_2, 0.0001, "Expected z_2 %f, got %f", expected.z_2, result.z_2); - cr_expect_float_eq(result.w_2, expected.w_2, 0.0001, "Expected w_2 %f, got %f", expected.w_2, result.w_2); - - cr_expect_float_eq(result.x_3, expected.x_3, 0.0001, "Expected x_3 %f, got %f", expected.x_3, result.x_3); - cr_expect_float_eq(result.y_3, expected.y_3, 0.0001, "Expected y_3 %f, got %f", expected.y_3, result.y_3); - cr_expect_float_eq(result.z_3, expected.z_3, 0.0001, "Expected z_3 %f, got %f", expected.z_3, result.z_3); - cr_expect_float_eq(result.w_3, expected.w_3, 0.0001, "Expected w_3 %f, got %f", expected.w_3, result.w_3); - - cr_expect_float_eq(result.x_4, expected.x_4, 0.0001, "Expected x_4 %f, got %f", expected.x_4, result.x_4); - cr_expect_float_eq(result.y_4, expected.y_4, 0.0001, "Expected y_4 %f, got %f", expected.y_4, result.y_4); - cr_expect_float_eq(result.z_4, expected.z_4, 0.0001, "Expected z_4 %f, got %f", expected.z_4, result.z_4); - cr_expect_float_eq(result.w_4, expected.w_4, 0.0001, "Expected w_4 %f, got %f", expected.w_4, result.w_4); - -} - -Test(rse_math, radians) -{ - float degrees; - float radians; - float expected_radians; - - degrees = 45.0f; - expected_radians = 0.7853; - - radians = rse_math_deg_to_radians(degrees); - - cr_expect_float_eq(radians, expected_radians, 0.0001, "Expected %f, got %f", expected_radians, radians); -} - -Test(rse_math, perspective) -{ - float fovy; - float width; - float height; - float z_near; - float z_far; - struct mat4_t result; - struct mat4_t expected; - - fovy = rse_math_deg_to_radians(45.0f); - width = 640.0f; - height = 480.0f; - z_near = 0.1f; - z_far = 20.0f; - - expected.x_1 = -1.81066012; - expected.y_1 = 0; - expected.z_1 = 0; - expected.w_1 = 0; - - expected.x_2 = 0; - expected.y_2 = 2.41421342; - expected.z_2 = 0; - expected.w_2 = 0; - - expected.x_3 = 0; - expected.y_3 = 0; - expected.z_3 = -1.0100503; - expected.w_3 = -1; - - expected.x_4 = 0; - expected.y_4 = 0; - expected.z_4 = -0.201005027; - expected.w_4 = 0; - - result = rse_math_perspective(fovy, width / height, z_near, z_far); - - cr_expect_float_eq(result.x_1, expected.x_1, 0.0001, "Expected x_1 %f, got %f", expected.x_1, result.x_1); - cr_expect_float_eq(result.y_1, expected.y_1, 0.0001, "Expected y_1 %f, got %f", expected.y_1, result.y_1); - cr_expect_float_eq(result.z_1, expected.z_1, 0.0001, "Expected z_1 %f, got %f", expected.z_1, result.z_1); - cr_expect_float_eq(result.w_1, expected.w_1, 0.0001, "Expected w_1 %f, got %f", expected.w_1, result.w_1); - - cr_expect_float_eq(result.x_2, expected.x_2, 0.0001, "Expected x_2 %f, got %f", expected.x_2, result.x_2); - cr_expect_float_eq(result.y_2, expected.y_2, 0.0001, "Expected y_2 %f, got %f", expected.y_2, result.y_2); - cr_expect_float_eq(result.z_2, expected.z_2, 0.0001, "Expected z_2 %f, got %f", expected.z_2, result.z_2); - cr_expect_float_eq(result.w_2, expected.w_2, 0.0001, "Expected w_2 %f, got %f", expected.w_2, result.w_2); - - cr_expect_float_eq(result.x_3, expected.x_3, 0.0001, "Expected x_3 %f, got %f", expected.x_3, result.x_3); - cr_expect_float_eq(result.y_3, expected.y_3, 0.0001, "Expected y_3 %f, got %f", expected.y_3, result.y_3); - cr_expect_float_eq(result.z_3, expected.z_3, 0.0001, "Expected z_3 %f, got %f", expected.z_3, result.z_3); - cr_expect_float_eq(result.w_3, expected.w_3, 0.0001, "Expected w_3 %f, got %f", expected.w_3, result.w_3); - - cr_expect_float_eq(result.x_4, expected.x_4, 0.0001, "Expected x_4 %f, got %f", expected.x_4, result.x_4); - cr_expect_float_eq(result.y_4, expected.y_4, 0.0001, "Expected y_4 %f, got %f", expected.y_4, result.y_4); - cr_expect_float_eq(result.z_4, expected.z_4, 0.0001, "Expected z_4 %f, got %f", expected.z_4, result.z_4); - cr_expect_float_eq(result.w_4, expected.w_4, 0.0001, "Expected w_4 %f, got %f", expected.w_4, result.w_4); - -} - -/*-----------------RSE TEXTURES TEST------------------------*/ - -#include "graphics/src/rse_texture.h" -TestSuite(rse_textures); - -Test(rse_textures, load_png_image) -{ - rse_load_texture("../../test_image.jpg"); -} diff --git a/tests/src/rse_graphics_vulkan_tests.c b/tests/src/rse_graphics_vulkan_tests.c new file mode 100644 index 00000000..cc15d413 --- /dev/null +++ b/tests/src/rse_graphics_vulkan_tests.c @@ -0,0 +1,61 @@ +/** + * @file rse_graphics_vulkan_tests.c + * @author Piotr Krygier (everyonecancode@gmail.com) + * @brief + * @version 0.1 + * @date 2024-02-16 + * + * @copyright Copyright (c) 2024 + * + */ + +#include "mocks/vulkan/Mockvulkan_core.h" +#include "mocks/GLFW/Mockglfw3.h" +#include "rse_graphics_vulkan_tests.h" +#include +#include "graphics/rse_graphics.h" +#include "utilities/rse_errors_common.h" +#include "unity.h" +#include "vulkan/vulkan_core.h" + +static void test_rse_graphics_init(void) +{ + VkExtensionProperties extenstion_properties[1]; + VkLayerProperties layer_properties[1]; + uint32_t count = 1; + + sprintf(extenstion_properties[0].extensionName, "VK_KHR_surface"); + sprintf(layer_properties[0].layerName, "VK_LAYER_KHRONOS_validation"); + + /* initialize GLFW */ + glfwInit_ExpectAndReturn(GLFW_TRUE); + glfwVulkanSupported_ExpectAndReturn(GLFW_TRUE); + glfwSetErrorCallback_ExpectAndReturn(NULL, NULL); + glfwSetErrorCallback_IgnoreArg_callback(); + glfwWindowHint_Expect(GLFW_CLIENT_API, GLFW_NO_API); + glfwCreateWindow_ExpectAndReturn(640, 480, "RedScarfEngine", NULL, NULL, (GLFWwindow*)1); + glfwSetKeyCallback_ExpectAndReturn((GLFWwindow*)1, NULL, NULL); + glfwSetKeyCallback_IgnoreArg_callback(); + glfwSetFramebufferSizeCallback_ExpectAndReturn((GLFWwindow*)1, NULL, NULL); + glfwSetFramebufferSizeCallback_IgnoreArg_callback(); + + /* create instance */ + vkEnumerateInstanceLayerProperties_ExpectAnyArgsAndReturn(VK_SUCCESS); + vkEnumerateInstanceLayerProperties_ExpectAnyArgsAndReturn(VK_SUCCESS); + vkEnumerateInstanceLayerProperties_ReturnThruPtr_pPropertyCount(&count); + /* TODO: Currently, due to the implementation, layer_properties that we get here is NULL. + * This is because mocked rse_malloc does nothing. Fix this somehow */ + vkEnumerateInstanceLayerProperties_ReturnThruPtr_pProperties(layer_properties); + + vkEnumerateInstanceExtensionProperties_ExpectAnyArgsAndReturn(VK_SUCCESS); + vkEnumerateInstanceExtensionProperties_ExpectAnyArgsAndReturn(VK_SUCCESS); + vkEnumerateInstanceExtensionProperties_ReturnThruPtr_pPropertyCount(&count); + vkEnumerateInstanceExtensionProperties_ReturnThruPtr_pProperties(extenstion_properties); + + TEST_ASSERT_EQUAL(RSE_ERROR_NO_ERROR, rse_graphics_init()); +} + +void rse_graphics_vulkan_tests(void) +{ + RUN_TEST(test_rse_graphics_init); +} diff --git a/tests/src/rse_graphics_vulkan_tests.h b/tests/src/rse_graphics_vulkan_tests.h new file mode 100644 index 00000000..06d3c5ee --- /dev/null +++ b/tests/src/rse_graphics_vulkan_tests.h @@ -0,0 +1,17 @@ +/** + * @file rse_graphics_vulkan_tests.h + * @author Piotr Krygier (everyonecancode@gmail.com) + * @brief Tests for rse_graphics_vulkan module + * @version 0.1 + * @date 2024-02-16 + * + * @copyright Copyright (c) 2024 + * + */ + +#ifndef RSE_GRAPHICS_VULKAN_TESTS_H +#define RSE_GRAPHICS_VULKAN_TESTS_H + +void rse_graphics_vulkan_tests(void); + +#endif // RSE_GRAPHICS_VULKAN_TESTS_H \ No newline at end of file diff --git a/tests/src/rse_graphics_window_tests.c b/tests/src/rse_graphics_window_tests.c new file mode 100644 index 00000000..58859807 --- /dev/null +++ b/tests/src/rse_graphics_window_tests.c @@ -0,0 +1,60 @@ +#include "rse_graphics_window_tests.h" + +/*-----------------RSE WINDOW TESTS------------------------*/ +#include "mocks/GLFW/Mockglfw3.h" +#include "graphics/src/window.h" +#include "utilities/rse_errors_common.h" +#include "graphics/src/rse_window_errors.h" + +void setUp (void) {} +void tearDown (void) {} + +static void test_rse_window_init_window_init_success() +{ + uint8_t window = 0; + + glfwInit_ExpectAndReturn(GLFW_TRUE); + glfwVulkanSupported_ExpectAndReturn(GLFW_TRUE); + glfwSetErrorCallback_ExpectAndReturn(NULL, NULL); + glfwSetErrorCallback_IgnoreArg_callback(); + glfwWindowHint_Expect(GLFW_CLIENT_API, GLFW_NO_API); + glfwCreateWindow_ExpectAndReturn(640, 480, "RedScarfEngine", NULL, NULL, (GLFWwindow*)&window); + glfwSetKeyCallback_ExpectAndReturn((GLFWwindow*)&window, NULL, NULL); + glfwSetKeyCallback_IgnoreArg_callback(); + glfwSetFramebufferSizeCallback_ExpectAndReturn((GLFWwindow*)&window, NULL, NULL); + glfwSetFramebufferSizeCallback_IgnoreArg_callback(); + + TEST_ASSERT_EQUAL(RSE_ERROR_NO_ERROR, window_init()); +} + +static void test_rse_window_init_glfw_init_failed() +{ + glfwInit_ExpectAndReturn(GLFW_FALSE); + TEST_ASSERT_EQUAL(WINDOW_ERROR_GLFW_INIT_FAILED, window_init()); +} + +static void test_rse_window_init_glfw_vulkan_not_supported() +{ + glfwInit_ExpectAndReturn(GLFW_TRUE); + glfwVulkanSupported_ExpectAndReturn(GLFW_FALSE); + TEST_ASSERT_EQUAL(WINDOW_ERROR_VULKAN_NOT_LOADED, window_init()); +} + +static void test_rse_window_init_window_not_created() +{ + glfwInit_ExpectAndReturn(GLFW_TRUE); + glfwVulkanSupported_ExpectAndReturn(GLFW_TRUE); + glfwSetErrorCallback_ExpectAndReturn(NULL, NULL); + glfwSetErrorCallback_IgnoreArg_callback(); + glfwWindowHint_Expect(GLFW_CLIENT_API, GLFW_NO_API); + glfwCreateWindow_ExpectAndReturn(640, 480, "RedScarfEngine", NULL, NULL, NULL); + TEST_ASSERT_EQUAL(WINDOW_ERROR_WINDOW_NOT_CREATED, window_init()); +} + +void rse_graphics_window_tests(void) +{ + RUN_TEST(test_rse_window_init_window_init_success); + RUN_TEST(test_rse_window_init_glfw_init_failed); + RUN_TEST(test_rse_window_init_glfw_vulkan_not_supported); + RUN_TEST(test_rse_window_init_window_not_created); +} diff --git a/tests/src/rse_graphics_window_tests.h b/tests/src/rse_graphics_window_tests.h new file mode 100644 index 00000000..73c6c08d --- /dev/null +++ b/tests/src/rse_graphics_window_tests.h @@ -0,0 +1,17 @@ +/** + * @file rse_graphics_window_tests.h + * @author Piotr Krygier (everyonecancode@gmail.com) + * @brief Tests for rse_graphics module + * @version 0.1 + * @date 2024-02-16 + * + * @copyright Copyright (c) 2024 + * + */ + +#ifndef RSE_GRAPHICS_TESTS_H +#define RSE_GRAPHICS_TESTS_H + +void rse_graphics_window_tests(void); + +#endif // RSE_GRAPHICS_TESTS_H \ No newline at end of file diff --git a/tests/src/rse_math_tests.c b/tests/src/rse_math_tests.c index 9a022955..9695ae4e 100644 --- a/tests/src/rse_math_tests.c +++ b/tests/src/rse_math_tests.c @@ -1,31 +1,36 @@ -#include "criterion/criterion.h" -#include "graphics/src/rse_math.h" +/** + * @file rse_math_tests.c + * @author Piotr Krygier (everyonecancode@gmail.com) + * @brief Tests for rse_math module + * @version 0.1 + * @date 2024-02-16 + * + * @copyright Copyright (c) 2024 + * + */ +#include "rse_math_tests.h" +#include "graphics/src/rse_math.h" +#include "unity.h" #include #include - - -/*-----------------RSE MATH TEST------------------------*/ - -TestSuite(rse_math); - -Test(rse_math, normalize) +static void test_rse_math_test_vector3_normalize(void) { - float res_x = 0.8017f; - float res_y = 0.2672f; - float res_z = 0.5345f; + float res_x = 0.8017837f; + float res_y = 0.2672612f; + float res_z = 0.5345224f; struct vec3_t test_vec = {3.0f, 1.0f, 2.0f}; struct vec3_t result = rse_math_normalize_vec3(&test_vec); - cr_expect_float_eq(result.x, res_x, 0.0001, "Expected %f, got %f", res_x, result.x); - cr_expect_float_eq(result.y, res_y, 0.0001, "Expected %f, got %f", res_y, result.y); - cr_expect_float_eq(result.z, res_z, 0.0001, "Expected %f, got %f", res_z, result.z); + TEST_ASSERT_EQUAL_FLOAT(res_x, result.x); + TEST_ASSERT_EQUAL_FLOAT(res_y, result.y); + TEST_ASSERT_EQUAL_FLOAT(res_z, result.z); } -Test(rse_math, cross) +static void test_rse_math_test_vector3_cross(void) { float res_x = -3.0f; float res_y = 6.0f; @@ -35,12 +40,12 @@ Test(rse_math, cross) struct vec3_t result = rse_math_cross_vec3(&test_vec1, &test_vec2); - cr_expect_float_eq(result.x, res_x, 0.0001, "Expected %f, got %f", res_x, result.x); - cr_expect_float_eq(result.y, res_y, 0.0001, "Expected %f, got %f", res_y, result.y); - cr_expect_float_eq(result.z, res_z, 0.0001, "Expected %f, got %f", res_z, result.z); + TEST_ASSERT_EQUAL_FLOAT(res_x, result.x); + TEST_ASSERT_EQUAL_FLOAT(res_y, result.y); + TEST_ASSERT_EQUAL_FLOAT(res_z, result.z); } -Test(rse_math, look_at) +static void test_rse_math_test_look_at(void) { struct vec3_t eye; struct vec3_t center; @@ -82,45 +87,44 @@ Test(rse_math, look_at) result = rse_math_look_at(&eye, ¢er, &up); - cr_expect_float_eq(result.x_1, expected.x_1, 0.0001, "Expected x_1 %f, got %f", expected.x_1, result.x_1); - cr_expect_float_eq(result.y_1, expected.y_1, 0.0001, "Expected y_1 %f, got %f", expected.y_1, result.y_1); - cr_expect_float_eq(result.z_1, expected.z_1, 0.0001, "Expected z_1 %f, got %f", expected.z_1, result.z_1); - cr_expect_float_eq(result.w_1, expected.w_1, 0.0001, "Expected w_1 %f, got %f", expected.w_1, result.w_1); + TEST_ASSERT_EQUAL_FLOAT(expected.x_1, result.x_1); + TEST_ASSERT_EQUAL_FLOAT(expected.y_1, result.y_1); + TEST_ASSERT_EQUAL_FLOAT(expected.z_1, result.z_1); + TEST_ASSERT_EQUAL_FLOAT(expected.w_1, result.w_1); - cr_expect_float_eq(result.x_2, expected.x_2, 0.0001, "Expected x_2 %f, got %f", expected.x_2, result.x_2); - cr_expect_float_eq(result.y_2, expected.y_2, 0.0001, "Expected y_2 %f, got %f", expected.y_2, result.y_2); - cr_expect_float_eq(result.z_2, expected.z_2, 0.0001, "Expected z_2 %f, got %f", expected.z_2, result.z_2); - cr_expect_float_eq(result.w_2, expected.w_2, 0.0001, "Expected w_2 %f, got %f", expected.w_2, result.w_2); + TEST_ASSERT_EQUAL_FLOAT(expected.x_2, result.x_2); + TEST_ASSERT_EQUAL_FLOAT(expected.y_2, result.y_2); + TEST_ASSERT_EQUAL_FLOAT(expected.z_2, result.z_2); + TEST_ASSERT_EQUAL_FLOAT(expected.w_2, result.w_2); - cr_expect_float_eq(result.x_3, expected.x_3, 0.0001, "Expected x_3 %f, got %f", expected.x_3, result.x_3); - cr_expect_float_eq(result.y_3, expected.y_3, 0.0001, "Expected y_3 %f, got %f", expected.y_3, result.y_3); - cr_expect_float_eq(result.z_3, expected.z_3, 0.0001, "Expected z_3 %f, got %f", expected.z_3, result.z_3); - cr_expect_float_eq(result.w_3, expected.w_3, 0.0001, "Expected w_3 %f, got %f", expected.w_3, result.w_3); - - cr_expect_float_eq(result.x_4, expected.x_4, 0.0001, "Expected x_4 %f, got %f", expected.x_4, result.x_4); - cr_expect_float_eq(result.y_4, expected.y_4, 0.0001, "Expected y_4 %f, got %f", expected.y_4, result.y_4); - cr_expect_float_eq(result.z_4, expected.z_4, 0.0001, "Expected z_4 %f, got %f", expected.z_4, result.z_4); - cr_expect_float_eq(result.w_4, expected.w_4, 0.0001, "Expected w_4 %f, got %f", expected.w_4, result.w_4); + TEST_ASSERT_EQUAL_FLOAT(expected.x_3, result.x_3); + TEST_ASSERT_EQUAL_FLOAT(expected.y_3, result.y_3); + TEST_ASSERT_EQUAL_FLOAT(expected.z_3, result.z_3); + TEST_ASSERT_EQUAL_FLOAT(expected.w_3, result.w_3); + TEST_ASSERT_EQUAL_FLOAT(expected.x_4, result.x_4); + TEST_ASSERT_EQUAL_FLOAT(expected.y_4, result.y_4); + TEST_ASSERT_EQUAL_FLOAT(expected.z_4, result.z_4); + TEST_ASSERT_EQUAL_FLOAT(expected.w_4, result.w_4); } -Test(rse_math, radians) +static void rse_math_test_radians(void) { float degrees; float radians; float expected_radians; degrees = 45.0f; - expected_radians = 0.7853; + expected_radians = 0.7853982; radians = rse_math_deg_to_radians(degrees); - cr_expect_float_eq(radians, expected_radians, 0.0001, "Expected %f, got %f", expected_radians, radians); + TEST_ASSERT_EQUAL_FLOAT(expected_radians, radians); } -Test(rse_math, perspective) +static void rse_math_test_perspective(void) { - float fovy; + float fovy; float width; float height; float z_near; @@ -156,29 +160,28 @@ Test(rse_math, perspective) result = rse_math_perspective(fovy, width / height, z_near, z_far); - cr_expect_float_eq(result.x_1, expected.x_1, 0.0001, "Expected x_1 %f, got %f", expected.x_1, result.x_1); - cr_expect_float_eq(result.y_1, expected.y_1, 0.0001, "Expected y_1 %f, got %f", expected.y_1, result.y_1); - cr_expect_float_eq(result.z_1, expected.z_1, 0.0001, "Expected z_1 %f, got %f", expected.z_1, result.z_1); - cr_expect_float_eq(result.w_1, expected.w_1, 0.0001, "Expected w_1 %f, got %f", expected.w_1, result.w_1); + TEST_ASSERT_EQUAL_FLOAT(expected.x_1, result.x_1); + TEST_ASSERT_EQUAL_FLOAT(expected.y_1, result.y_1); + TEST_ASSERT_EQUAL_FLOAT(expected.z_1, result.z_1); + TEST_ASSERT_EQUAL_FLOAT(expected.w_1, result.w_1); - cr_expect_float_eq(result.x_2, expected.x_2, 0.0001, "Expected x_2 %f, got %f", expected.x_2, result.x_2); - cr_expect_float_eq(result.y_2, expected.y_2, 0.0001, "Expected y_2 %f, got %f", expected.y_2, result.y_2); - cr_expect_float_eq(result.z_2, expected.z_2, 0.0001, "Expected z_2 %f, got %f", expected.z_2, result.z_2); - cr_expect_float_eq(result.w_2, expected.w_2, 0.0001, "Expected w_2 %f, got %f", expected.w_2, result.w_2); + TEST_ASSERT_EQUAL_FLOAT(expected.x_2, result.x_2); + TEST_ASSERT_EQUAL_FLOAT(expected.y_2, result.y_2); + TEST_ASSERT_EQUAL_FLOAT(expected.z_2, result.z_2); + TEST_ASSERT_EQUAL_FLOAT(expected.w_2, result.w_2); - cr_expect_float_eq(result.x_3, expected.x_3, 0.0001, "Expected x_3 %f, got %f", expected.x_3, result.x_3); - cr_expect_float_eq(result.y_3, expected.y_3, 0.0001, "Expected y_3 %f, got %f", expected.y_3, result.y_3); - cr_expect_float_eq(result.z_3, expected.z_3, 0.0001, "Expected z_3 %f, got %f", expected.z_3, result.z_3); - cr_expect_float_eq(result.w_3, expected.w_3, 0.0001, "Expected w_3 %f, got %f", expected.w_3, result.w_3); - - cr_expect_float_eq(result.x_4, expected.x_4, 0.0001, "Expected x_4 %f, got %f", expected.x_4, result.x_4); - cr_expect_float_eq(result.y_4, expected.y_4, 0.0001, "Expected y_4 %f, got %f", expected.y_4, result.y_4); - cr_expect_float_eq(result.z_4, expected.z_4, 0.0001, "Expected z_4 %f, got %f", expected.z_4, result.z_4); - cr_expect_float_eq(result.w_4, expected.w_4, 0.0001, "Expected w_4 %f, got %f", expected.w_4, result.w_4); + TEST_ASSERT_EQUAL_FLOAT(expected.x_3, result.x_3); + TEST_ASSERT_EQUAL_FLOAT(expected.y_3, result.y_3); + TEST_ASSERT_EQUAL_FLOAT(expected.z_3, result.z_3); + TEST_ASSERT_EQUAL_FLOAT(expected.w_3, result.w_3); + TEST_ASSERT_EQUAL_FLOAT(expected.x_4, result.x_4); + TEST_ASSERT_EQUAL_FLOAT(expected.y_4, result.y_4); + TEST_ASSERT_EQUAL_FLOAT(expected.z_4, result.z_4); + TEST_ASSERT_EQUAL_FLOAT(expected.w_4, result.w_4); } -Test(rse_math, rotation) +static void rse_math_test_rotation(void) { struct mat4_t matrix_to_rotate = rse_math_uniform_mat4(); struct vec3_t rotation_vector = {1.0f, 0.0f, 0.0f}; @@ -195,23 +198,34 @@ Test(rse_math, rotation) result = rse_math_rotate(matrix_to_rotate, rotation, rotation_vector); - cr_expect_float_eq(result.x_1, expected.x_1, 0.0001, "Expected x_1 %f, got %f", expected.x_1, result.x_1); - cr_expect_float_eq(result.y_1, expected.y_1, 0.0001, "Expected y_1 %f, got %f", expected.y_1, result.y_1); - cr_expect_float_eq(result.z_1, expected.z_1, 0.0001, "Expected z_1 %f, got %f", expected.z_1, result.z_1); - cr_expect_float_eq(result.w_1, expected.w_1, 0.0001, "Expected w_1 %f, got %f", expected.w_1, result.w_1); - cr_expect_float_eq(result.x_2, expected.x_2, 0.0001, "Expected x_2 %f, got %f", expected.x_2, result.x_2); - cr_expect_float_eq(result.y_2, expected.y_2, 0.0001, "Expected y_2 %f, got %f", expected.y_2, result.y_2); - cr_expect_float_eq(result.z_2, expected.z_2, 0.0001, "Expected z_2 %f, got %f", expected.z_2, result.z_2); - cr_expect_float_eq(result.w_2, expected.w_2, 0.0001, "Expected w_2 %f, got %f", expected.w_2, result.w_2); + TEST_ASSERT_EQUAL_FLOAT(expected.x_1, result.x_1); + TEST_ASSERT_EQUAL_FLOAT(expected.y_1, result.y_1); + TEST_ASSERT_EQUAL_FLOAT(expected.z_1, result.z_1); + TEST_ASSERT_EQUAL_FLOAT(expected.w_1, result.w_1); - cr_expect_float_eq(result.x_3, expected.x_3, 0.0001, "Expected x_3 %f, got %f", expected.x_3, result.x_3); - cr_expect_float_eq(result.y_3, expected.y_3, 0.0001, "Expected y_3 %f, got %f", expected.y_3, result.y_3); - cr_expect_float_eq(result.z_3, expected.z_3, 0.0001, "Expected z_3 %f, got %f", expected.z_3, result.z_3); - cr_expect_float_eq(result.w_3, expected.w_3, 0.0001, "Expected w_3 %f, got %f", expected.w_3, result.w_3); + TEST_ASSERT_EQUAL_FLOAT(expected.x_2, result.x_2); + TEST_ASSERT_EQUAL_FLOAT(expected.y_2, result.y_2); + TEST_ASSERT_EQUAL_FLOAT(expected.z_2, result.z_2); + TEST_ASSERT_EQUAL_FLOAT(expected.w_2, result.w_2); - cr_expect_float_eq(result.x_4, expected.x_4, 0.0001, "Expected x_4 %f, got %f", expected.x_4, result.x_4); - cr_expect_float_eq(result.y_4, expected.y_4, 0.0001, "Expected y_4 %f, got %f", expected.y_4, result.y_4); - cr_expect_float_eq(result.z_4, expected.z_4, 0.0001, "Expected z_4 %f, got %f", expected.z_4, result.z_4); - cr_expect_float_eq(result.w_4, expected.w_4, 0.0001, "Expected w_4 %f, got %f", expected.w_4, result.w_4); -} \ No newline at end of file + TEST_ASSERT_EQUAL_FLOAT(expected.x_3, result.x_3); + TEST_ASSERT_EQUAL_FLOAT(expected.y_3, result.y_3); + TEST_ASSERT_EQUAL_FLOAT(expected.z_3, result.z_3); + TEST_ASSERT_EQUAL_FLOAT(expected.w_3, result.w_3); + + TEST_ASSERT_EQUAL_FLOAT(expected.x_4, result.x_4); + TEST_ASSERT_EQUAL_FLOAT(expected.y_4, result.y_4); + TEST_ASSERT_EQUAL_FLOAT(expected.z_4, result.z_4); + TEST_ASSERT_EQUAL_FLOAT(expected.w_4, result.w_4); +} + +void rse_math_tests(void) +{ + RUN_TEST(test_rse_math_test_vector3_normalize); + RUN_TEST(test_rse_math_test_vector3_cross); + RUN_TEST(test_rse_math_test_look_at); + RUN_TEST(rse_math_test_radians); + RUN_TEST(rse_math_test_perspective); + RUN_TEST(rse_math_test_rotation); +} diff --git a/tests/src/rse_math_tests.h b/tests/src/rse_math_tests.h new file mode 100644 index 00000000..ceac0a06 --- /dev/null +++ b/tests/src/rse_math_tests.h @@ -0,0 +1,12 @@ +/** + * @file rse_math_tests.h + * @author Piotr Krygier (everyonecancode@gmail.com) + * @brief Tests for rse_math module + * @version 0.1 + * @date 2024-02-16 + * + * @copyright Copyright (c) 2024 + * + */ + +void rse_math_tests(void); \ No newline at end of file diff --git a/utilities/CMakeLists.txt b/utilities/CMakeLists.txt index 243a3843..d538f2c9 100644 --- a/utilities/CMakeLists.txt +++ b/utilities/CMakeLists.txt @@ -1,3 +1,5 @@ +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Werror") + add_library(rse_utilities SHARED) target_include_directories(rse_utilities PRIVATE diff --git a/utilities/logger.h b/utilities/logger.h index 6a30e44e..d45623a7 100644 --- a/utilities/logger.h +++ b/utilities/logger.h @@ -12,16 +12,11 @@ #ifndef RSE_LOGGER_H #define RSE_LOGGER_H -#ifndef LOG_LEVEL -#define LOG_LEVEL LOGLEVEL_DEBUG -#endif - #include #include #define __FILENAME__ (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__) #define LOGGER(log_level, ...) _log_log(log_level, __FILENAME__, __LINE__, __VA_ARGS__) -// #define LOGGER(log_level, ...) printf("[##log_level] %s:%d", __FILE__, __LINE__); printf(__VA_ARGS__) #define LOGT(...) LOGGER(LOGLEVEL_TRACE, __VA_ARGS__) #define LOGD(...) LOGGER(LOGLEVEL_DEBUG, __VA_ARGS__) @@ -41,7 +36,8 @@ enum log_level_t LOGLEVEL_INFO, LOGLEVEL_WARNING, LOGLEVEL_ERROR, - LOGLEVEL_FATAL + LOGLEVEL_FATAL, + LOGLEVEL_NONE }; void _log_log(unsigned int level, const char* file, int line, const char* fmt, ...); diff --git a/utilities/rse_commons.h b/utilities/rse_commons.h index 80d9b01d..a42723fa 100644 --- a/utilities/rse_commons.h +++ b/utilities/rse_commons.h @@ -19,13 +19,23 @@ * @brief Macro for allocating memory and checking it on the same line * */ +#ifndef RSE_TEST #define rse_malloc(ptr, size) \ ptr = malloc(size); \ if (ptr == NULL) { \ - LOGF(common_messages[COMMON_ERROR_MEMORY_ALLOCATION_FAILED]); \ - return RSE_COMMON_ERROR_MALLLOC_FAILED; \ + LOGF(common_messages[COMMON_ERROR_MEMORY_ALLOCATION_FAILED]); \ + exit(1); \ } +#define rse_free(ptr) free(ptr); + +#define rse_memcpy(dst, src, size) memcpy(dst, src, size); +#else +#define rse_malloc(ptr, size) ptr = NULL; +#define rse_free(ptr) +#define rse_memcpy(dst, src, size) +#endif + /** * @brief Error type for RSE * diff --git a/utilities/src/logger.c b/utilities/src/logger.c index aa2029f5..c9bb2ed1 100644 --- a/utilities/src/logger.c +++ b/utilities/src/logger.c @@ -5,10 +5,19 @@ const char* log_levels[] = { "[TRACE]", "[DEBUG]", "[INFO]", "WARNING", "[ERROR]", "[FATAL]" }; +#ifndef LOGLEVEL +#define LOGLEVEL LOGLEVEL_DEBUG +#endif + void _log_log(unsigned int level, const char* file, int line, const char* fmt, ...) { va_list list; + if (level < LOGLEVEL) + { + return; + } + va_start(list, fmt); fprintf(stdout, "%s %s:%d: ", log_levels[level], file, line); vfprintf(stdout, fmt, list);